@meowdown/core 0.65.2 → 0.65.3

package/dist/index.d.ts

@@ -14,11 +14,12 @@ import { VirtualElement } from "@floating-ui/dom";
 /**
  * How faithfully markdown survives a parse-then-serialize round trip:
  * - `exact`: byte-identical (modulo the trailing newline).
- * - `normalizing`: bytes differ, but only as layout the parser collapses back -
- *   no non-blank line content is lost and re-parsing the output yields the same
- *   doc (e.g. a lazy continuation re-indented to its canonical column, or a
- *   table delimiter row rewritten to canonical dashes).
- * - `lossy`: content changed - a non-blank line differs, or the re-parsed doc does.
+ * - `normalizing`: bytes differ, but only as layout the parser reads back
+ *   through - every content line survives and the output re-parses to the same
+ *   document (e.g. a lazy continuation re-indented to its canonical column, or
+ *   a table delimiter row rewritten to canonical dashes).
+ * - `lossy`: content changed - a content line differs or disappeared, or the
+ *   output re-parses to a different document.
  */
 type RoundTripFidelity = 'exact' | 'normalizing' | 'lossy';
 /**

package/dist/index.js

@@ -43,6 +43,12 @@ import { closeHistory } from "@prosekit/pm/history";
 import { registerResizableHandleElement, registerResizableRootElement } from "@prosekit/web/resizable";
 import { InputRule } from "@prosekit/pm/inputrules";
 
+//#region src/extensions/node-names.ts
+function isNodeOfType(node, name) {
+	return node.type.name === name;
+}
+
+//#endregion
 //#region src/utils/composition.ts
 const COMPOSITION_TAIL_MS = 50;
 let compositionEndedAt = -1;
@@ -920,12 +926,6 @@ function atomUnitToDOM(atom, sourceText) {
 	}
 }
 
-//#endregion
-//#region src/extensions/node-names.ts
-function isNodeOfType(node, name) {
-	return node.type.name === name;
-}
-
 //#endregion
 //#region src/extensions/heading.ts
 /**
@@ -1294,27 +1294,6 @@ function definePlainTextPaste() {
 	}));
 }
 
-//#endregion
-//#region src/utils/backticks.ts
-/**
-* Length of the longest run of `charCode` in `text`, at least `min`.
-*/
-function longestCharRun(text, charCode, min = 0) {
-	let longest = min;
-	let run = 0;
-	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === charCode) {
-		run++;
-		if (run > longest) longest = run;
-	} else run = 0;
-	return longest;
-}
-/**
-* Length of the longest run of backticks in `text`, at least `min`.
-*/
-function longestBacktickRun(text, min = 0) {
-	return longestCharRun(text, 96, min);
-}
-
 //#endregion
 //#region src/converters/pm-to-md.ts
 /**
@@ -1376,7 +1355,8 @@ function emitHeading(node, out) {
 		out.closeBlock();
 		return;
 	}
-	out.write(HEADING_PREFIX[attrs.level] ?? "# ");
+	const prefix = HEADING_PREFIX[attrs.level] ?? "# ";
+	out.write(node.content.size > 0 ? prefix : prefix.slice(0, -1));
 	emitInlineChildren(node, out);
 	const closingHashes = attrs.closingHashes;
 	if (closingHashes != null && closingHashes > 0) out.write(" " + "#".repeat(closingHashes));
@@ -1390,10 +1370,22 @@ var MdOut = class {
 		this.atLineStart = true;
 		this.deferredBlankPrefix = null;
 	}
-	write(text) {
+	/**
+	* Write `text`, opening each embedded line with the current line prefix.
+	*
+	* `lazyLines` lets a line the prefix would change the meaning of - a setext
+	* underline, a tab-indented line under a blockquote, a block opener - go out
+	* as a lazy continuation instead (see `continuationPrefix`). Markdown keeps
+	* such a line as text only when it arrives lazily, and the container picks
+	* the paragraph up again on the next line. Only paragraph-like text may ask
+	* for this: an unprefixed line would fall out of a code block, an html
+	* comment, or an HTML block.
+	*/
+	write(text, lazyLines = false) {
 		if (text === "") return;
 		this.emitDeferredBlankLine();
 		if (this.atLineStart) {
+			if (this.pendingFirst !== null && isThematicBreak(this.pendingFirst + text)) this.breakMarkerLine();
 			this.parts.push(this.pendingFirst ?? this.linePrefix);
 			this.pendingFirst = null;
 			this.atLineStart = false;
@@ -1403,9 +1395,11 @@ var MdOut = class {
 			return;
 		}
 		const lines = text.split("\n");
+		const lazy = lazyLines && this.linePrefix !== "";
 		for (let i = 0; i < lines.length; i++) {
-			if (i > 0) this.parts.push("\n", this.linePrefix);
-			if (lines[i] !== "") this.parts.push(lines[i]);
+			const line = lines[i];
+			if (i > 0) this.parts.push("\n", lazy ? continuationPrefix(line, this.linePrefix) : this.linePrefix);
+			if (line !== "") this.parts.push(line);
 		}
 	}
 	/**
@@ -1432,7 +1426,8 @@ var MdOut = class {
 	closeBlock() {
 		if (this.atLineStart && this.pendingFirst !== null) {
 			this.emitDeferredBlankLine();
-			this.parts.push(this.pendingFirst.trimEnd());
+			const marker = this.pendingFirst;
+			this.parts.push(marker.endsWith("] ") ? marker : marker.trimEnd());
 			this.pendingFirst = null;
 			this.atLineStart = false;
 		}
@@ -1441,6 +1436,18 @@ var MdOut = class {
 		this.deferredBlankPrefix = this.linePrefix;
 	}
 	/**
+	* Give the markers pending on this line a line of their own, so what comes
+	* next opens a new one. Unlike `closeBlock` this owes no blank line: the
+	* items are still part of the same tight list.
+	*/
+	breakMarkerLine() {
+		if (this.pendingFirst === null) return;
+		this.emitDeferredBlankLine();
+		this.parts.push(this.pendingFirst.trimEnd(), "\n");
+		this.pendingFirst = null;
+		this.atLineStart = true;
+	}
+	/**
 	* Cancel the blank line deferred by the last `closeBlock`, so the next
 	* write starts directly on the following line. Used between the blocks of
 	* a tight list, where markdown separates items (and an item's paragraph
@@ -1462,14 +1469,24 @@ var MdOut = class {
 		this.linePrefix = savedLine + continuation;
 		if (firstLine !== null) {
 			const base = savedFirst ?? savedLine;
-			this.pendingFirst = base + firstLine;
+			if (savedFirst !== null && isThematicBreak(base + firstLine)) {
+				this.breakMarkerLine();
+				this.pendingFirst = savedLine + firstLine;
+			} else this.pendingFirst = base + firstLine;
 		}
 		fn();
 		this.linePrefix = savedLine;
 		this.pendingFirst = firstLine !== null ? null : savedFirst;
 	}
 	finish() {
-		return this.parts.join("").replace(/\s+$/, "") + "\n";
+		const text = this.parts.join("");
+		let cut = text.length;
+		for (let i = text.length - 1; i >= 0; i--) {
+			const code = text.charCodeAt(i);
+			if (code === 10) cut = i;
+			else if (code !== 32 && code !== 9) break;
+		}
+		return text.slice(0, cut) + "\n";
 	}
 	emitDeferredBlankLine() {
 		const prefix = this.deferredBlankPrefix;
@@ -1548,13 +1565,39 @@ function emitBlockChildren(node, out, tightItem = false) {
 		while (runEnd < count && isNodeOfType(node.child(runEnd), "list")) runEnd++;
 		const tightRun = isTightRun(node, index, runEnd);
 		for (let item = index; item < runEnd; item++) {
-			if (item === index ? tightItem && index > 0 : tightRun) out.suppressBlank();
-			emitList(node.child(item), out, tightRun);
+			const child = node.child(item);
+			const isRunStart = item === index;
+			const tight = isRunStart ? tightItem && index > 0 : tightRun;
+			const carriesOn = !isRunStart && listMarkerChar(node.child(item - 1)) === listMarkerChar(child);
+			if (tight && (carriesOn || canInterruptParagraph(child))) out.suppressBlank();
+			emitList(child, out, tightRun);
 		}
 		index = runEnd;
 	}
 }
 /**
+* Whether `list`'s marker line still opens an item when the line above it is a
+* paragraph. CommonMark lets a list interrupt a paragraph only when the item
+* carries content and, if ordered, is numbered 1; anything else reads as more of
+* the paragraph, so the blank line before it is what keeps it a list at all.
+*/
+function canInterruptParagraph(list) {
+	const attrs = list.attrs;
+	if (attrs.kind === "ordered" && (attrs.order ?? 1) !== 1) return false;
+	return attrs.kind === "task" || list.childCount > 0 && list.child(0).content.size > 0;
+}
+/**
+* The character a list item's marker ends with: the bullet itself, or the
+* delimiter after an ordered item's number. A markdown list runs for as long as
+* this stays the same, and a different one opens a new list.
+*/
+function listMarkerChar(node) {
+	const { kind, marker, collapsed } = node.attrs;
+	if (kind === "ordered") return marker === ")" ? ")" : ".";
+	if (kind === "task") return marker === "+" ? "+" : marker === "*" ? "*" : "-";
+	return collapsed ? "+" : marker === "*" ? "*" : "-";
+}
+/**
 * A run of sibling `list` nodes serializes tight iff every item is "simple":
 * at most one leading paragraph, then only nested lists. Any other shape
 * (multiple paragraphs, a blockquote, a code block, …) needs blank-line
@@ -1576,6 +1619,177 @@ function isTightItem(item) {
 	return true;
 }
 /**
+* The prefix a leaf's continuation line goes out with. The container's full
+* `prefix` is the default. A line the full prefix would change the meaning of -
+* a setext underline, a tab whose columns the prefix shrinks below the four
+* that kept it inert, a block opener the source kept inert with indentation the
+* parser dedented away - needs a lazy spelling instead: without its `>` marker
+* the line can only continue the paragraph, because no block may start on a
+* lazy line.
+*
+* The lazy spelling carries `lazyIndent(prefix)`, the columns the parser
+* dedents an unmarked line by, so the text comes back exactly. It goes out bare
+* only when the dedent would leave it alone anyway and its own whitespace
+* measures four columns flush left (or it is a setext underline, which nothing
+* at the top level turns back into an underline).
+*/
+function continuationPrefix(line, prefix) {
+	if (measureIndent(line, prefix.length) >= 4) return prefix;
+	const shrunk = measureIndent(line, 0) >= 4;
+	const underline = isSetextUnderline(line);
+	const opens = !shrunk && lineOpensBlock(line);
+	if (!shrunk && !underline && !opens) return prefix;
+	const lazy = lazyIndent(prefix);
+	return !opens && dedentKeepsLine(line, lazy.length) ? "" : lazy;
+}
+/**
+* The lazy spelling's indent: the whitespace the containers write after the
+* last `>` marker, which is also the columns the parser dedents an unmarked
+* continuation line by (`sliceColumn` in `md-to-pm.ts`). The single space
+* directly after the `>` belongs to the marker, not to the indent. A prefix
+* with no `>` to drop has flush left as its only lazy spelling: its columns
+* are the list's own indent, and writing them would just re-match the item.
+*/
+function lazyIndent(prefix) {
+	let start = prefix.length;
+	while (start > 0 && prefix.charCodeAt(start - 1) === 32) start--;
+	if (start === 0 || prefix.charCodeAt(start - 1) !== 62) return "";
+	return prefix.slice(start + 1);
+}
+/**
+* Whether the parser's dedent (`sliceColumn` at `column`) returns `line`
+* unchanged: its leading whitespace stops short of the column, or a tab in it
+* reaches past. Such a line round-trips byte-exact when written bare.
+*/
+function dedentKeepsLine(line, column) {
+	let col = 0;
+	for (let index = 0; col < column; index++) {
+		const code = line.charCodeAt(index);
+		if (code === 32) col += 1;
+		else if (code === 9) {
+			const width = 4 - col % 4;
+			if (col + width > column) return true;
+			col += width;
+		} else return true;
+	}
+	return false;
+}
+/**
+* The line patterns that open an HTML block, the openers of `HTMLBlockStyle`
+* in `@lezer/markdown`: script/pre/style, a comment, a processing instruction,
+* a declaration, CDATA, a known block-level tag, and a complete tag alone on
+* its line. Leading whitespace is stripped before matching.
+*/
+const HTML_BLOCK_OPEN = [
+	/^<(?:script|pre|style)(?:\s|>|$)/i,
+	/^<!--/,
+	/^<\?/,
+	/^<![A-Z]/,
+	/^<!\[CDATA\[/,
+	/^<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|\/?>|$)/i,
+	/^(?:<\/[a-z][\w-]*\s*>|<[a-z][\w-]*(\s+[a-z:_][\w.-]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*>)\s*$/i
+];
+/**
+* Whether `text`'s first line opens an HTML block. The last pattern (a
+* complete tag) cannot interrupt a paragraph, but a lazy spelling of such a
+* line round-trips all the same, so one check serves both callers.
+*/
+function opensHTMLBlock(text) {
+	const lineEnd = text.indexOf("\n");
+	const line = lineEnd < 0 ? text : text.slice(0, lineEnd);
+	for (const pattern of HTML_BLOCK_OPEN) if (pattern.test(line)) return true;
+	return false;
+}
+/**
+* Whether `line`, at the start of a container's content, opens a block instead
+* of continuing the paragraph above it: a blockquote, an ATX heading, a fence,
+* `$$` math, an HTML block, a thematic break, a bullet item (even an empty
+* one), and an ordered item that carries content and is numbered 1.
+*/
+function lineOpensBlock(line) {
+	let index = 0;
+	while (isSpaceOrTab(line.charCodeAt(index))) index++;
+	const first = line.charCodeAt(index);
+	switch (first) {
+		case 62: return true;
+		case 60: return opensHTMLBlock(index === 0 ? line : line.slice(index));
+		case 35: {
+			let end = index + 1;
+			while (line.charCodeAt(end) === 35) end++;
+			return end - index <= 6 && (end === line.length || isSpaceOrTab(line.charCodeAt(end)));
+		}
+		case 96:
+		case 126: {
+			let end = index + 1;
+			while (line.charCodeAt(end) === first) end++;
+			return end - index >= 3;
+		}
+		case 36: return line.charCodeAt(index + 1) === 36;
+		case 95: return isUnderscoreBreak(line, index);
+		case 42:
+		case 45:
+		case 43: return isThematicBreak(line) || index + 1 >= line.length || isSpaceOrTab(line.charCodeAt(index + 1));
+		case 49: {
+			const delimiter = line.charCodeAt(index + 1);
+			return (delimiter === 46 || delimiter === 41) && startsNonEmptyItem(line, index + 1);
+		}
+		default: return false;
+	}
+}
+/**
+* A `___` thematic break: three or more underscores with nothing but spaces
+* and tabs between them. (`isThematicBreak` covers `-` and `*`, the two break
+* characters that double as list bullets.)
+*/
+function isUnderscoreBreak(line, index) {
+	let count = 0;
+	for (; index < line.length; index++) {
+		const code = line.charCodeAt(index);
+		if (code === 95) count++;
+		else if (!isSpaceOrTab(code)) return false;
+	}
+	return count >= 3;
+}
+/**
+* Whether the list delimiter at `index` is followed by the gap and content
+* (`1. x`) that let an ordered item interrupt a paragraph.
+*/
+function startsNonEmptyItem(line, index) {
+	if (!isSpaceOrTab(line.charCodeAt(index + 1))) return false;
+	for (let i = index + 2; i < line.length; i++) if (!isSpaceOrTab(line.charCodeAt(i))) return true;
+	return false;
+}
+/**
+* The columns of leading whitespace `line` stands for when it starts at column
+* `start`, where a tab reaches the next multiple of four.
+*/
+function measureIndent(line, start) {
+	let col = start;
+	for (let i = 0; i < line.length; i++) {
+		const code = line.charCodeAt(i);
+		if (code === 32) col += 1;
+		else if (code === 9) col += 4 - col % 4;
+		else break;
+	}
+	return col - start;
+}
+/**
+* Whether `line` is a run of one character, `=` or `-`, and so would read as a
+* setext underline under a container's line prefix. Surrounding whitespace does
+* not save it: an underline may carry any indentation the prefix leaves under
+* four columns, and any trailing spaces at all.
+*/
+function isSetextUnderline(line) {
+	let start = 0;
+	while (start < line.length && isSpaceChar(line.charCodeAt(start))) start++;
+	const first = line.charCodeAt(start);
+	if (first !== 61 && first !== 45) return false;
+	let end = line.length;
+	while (isSpaceChar(line.charCodeAt(end - 1))) end--;
+	for (let i = start + 1; i < end; i++) if (line.charCodeAt(i) !== first) return false;
+	return true;
+}
+/**
 * Walk inline children writing text directly. The schema has no marks, so
 * every inline child is currently a text node - but going through this
 * loop instead of `node.textContent` avoids one intermediate string
@@ -1583,23 +1797,45 @@ function isTightItem(item) {
 */
 function emitInlineChildren(node, out) {
 	const count = node.childCount;
+	if (count === 0) return;
+	const first = node.child(0).text;
+	const lazy = first == null || first.charCodeAt(0) !== 60 || !opensHTMLBlock(first);
 	for (let i = 0; i < count; i++) {
 		const child = node.child(i);
-		if (child.isText && child.text) out.write(child.text);
+		if (child.isText && child.text) out.write(child.text, lazy);
 	}
 }
 function emitList(node, out, tight) {
-	const { kind, marker, order, taskMarker, collapsed, markerGap, checked } = node.attrs;
-	const bulletMarker = kind === "task" ? marker === "+" ? "+" : marker === "*" ? "*" : "-" : collapsed ? "+" : marker === "*" ? "*" : "-";
-	const orderMarker = marker === ")" ? ")" : ".";
+	const { kind, order, taskMarker, markerGap, checked } = node.attrs;
+	const markerChar = listMarkerChar(node);
 	const checkMark = taskMarker === "X" ? "X" : "x";
 	const gap = Math.min(Math.max(markerGap ?? 1, 1), 4);
-	const prefix = `${kind === "ordered" ? `${order ?? 1}${orderMarker}` : bulletMarker}${" ".repeat(gap)}`;
+	const prefix = `${kind === "ordered" ? `${order ?? 1}${markerChar}` : markerChar}${" ".repeat(gap)}`;
 	const outputMarker = kind === "task" ? `${prefix}[${checked ? checkMark : " "}] ` : prefix;
 	const continuation = " ".repeat(prefix.length);
 	out.withPrefix(continuation, outputMarker, () => emitBlockChildren(node, out, tight));
 	out.closeBlock();
 }
+/**
+* Whether a line of list markers reads as a thematic break: three or more `-`
+* or `*`, all the same character, with nothing but spaces, tabs and blockquote
+* markers around them.
+*/
+function isThematicBreak(line) {
+	let breakChar = 0;
+	let count = 0;
+	for (let i = 0; i < line.length; i++) {
+		const code = line.charCodeAt(i);
+		if (code === 10) break;
+		if (code === 32 || code === 9) continue;
+		if (code === 62 && count === 0) continue;
+		if (code !== 45 && code !== 42) return false;
+		if (breakChar === 0) breakChar = code;
+		else if (code !== breakChar) return false;
+		count++;
+	}
+	return count >= 3;
+}
 function emitCodeBlock(node, out) {
 	const attrs = node.attrs;
 	const language = attrs.language || "";
@@ -1624,10 +1860,9 @@ function emitCodeBlock(node, out) {
 		return;
 	}
 	const tilde = attrs.fenceStyle === "tilde";
-	const minWidth = longestCharRun(code, tilde ? 126 : 96, 2) + 1;
-	const fence = (tilde ? "~" : "`").repeat(Math.max(attrs.fenceLength ?? 0, minWidth));
+	const fence = (tilde ? "~" : "`").repeat(Math.max(attrs.fenceLength ?? 0, minFenceLength(code, tilde)));
 	out.write(fence);
-	if (language) out.write(language);
+	if (language) out.write(language.startsWith(tilde ? "~" : "`") ? " " + language : language);
 	out.write("\n");
 	if (code) {
 		out.write(code);
@@ -1637,16 +1872,53 @@ function emitCodeBlock(node, out) {
 	out.closeBlock();
 }
 /**
+* The narrowest fence that can hold `code`: wider than every line of it that
+* would close the fence early, and never under CommonMark's minimum of three. A
+* closing fence is a run of the fence character alone on its line; a run with
+* anything else on the line (`` a ``` ``, `` ``` x ``) or four columns in closes
+* nothing, so the fence holds it as it is.
+*/
+function minFenceLength(code, tilde) {
+	const fenceChar = tilde ? 126 : 96;
+	let longest = 2;
+	let lineStart = 0;
+	while (lineStart <= code.length) {
+		let lineEnd = code.indexOf("\n", lineStart);
+		if (lineEnd < 0) lineEnd = code.length;
+		let index = lineStart;
+		while (index < lineEnd && code.charCodeAt(index) === 32) index++;
+		if (index - lineStart < 4) {
+			const runStart = index;
+			while (index < lineEnd && code.charCodeAt(index) === fenceChar) index++;
+			const run = index - runStart;
+			while (index < lineEnd && isSpaceOrTab(code.charCodeAt(index))) index++;
+			if (index === lineEnd && run > longest) longest = run;
+		}
+		lineStart = lineEnd + 1;
+	}
+	return longest + 1;
+}
+function isSpaceOrTab(char) {
+	return char === 32 || char === 9;
+}
+/**
+* Whether indentation can spell `code` as an indented code block. There is no
+* line to carry the four columns of a block with no content at all, and none to
+* carry a blank line at either end.
+*/
+function canIndentCode(code) {
+	return code !== "" && !code.startsWith("\n") && !code.endsWith("\n");
+}
+/**
 * Indent `code` for an indented code block, or return `undefined` for shapes
-* the indented form cannot express (empty content, or a leading or trailing
-* blank line), which fall back to a fence. Blank interior lines stay empty so
-* a round-trip adds no trailing whitespace; `MdOut.write` still prepends the
-* enclosing `linePrefix` (blockquote or list continuation) per line.
+* the indented form cannot express, which fall back to a fence. Blank interior
+* lines stay empty so a round-trip adds no trailing whitespace; `MdOut.write`
+* still prepends the enclosing `linePrefix` (blockquote or list continuation)
+* per line.
 */
 function toIndentedCode(code) {
-	if (code === "") return void 0;
+	if (!canIndentCode(code)) return void 0;
 	const lines = code.split("\n");
-	if (lines[0] === "" || lines[lines.length - 1] === "") return void 0;
 	for (let i = 0; i < lines.length; i++) if (lines[i] !== "") lines[i] = `    ${lines[i]}`;
 	return lines.join("\n");
 }
@@ -3817,6 +4089,27 @@ function defineInlineMarks() {
 	return union(defineMdMark(), defineMdEm(), defineMdStrong(), defineMdCode(), defineMdLinkText(), defineMdLinkUri(), defineMdLinkTitle(), defineMdDel(), defineMdHighlight(), defineMdTag(), defineMdWikilink(), defineMdImage(), defineMdFile(), defineMdMath(), defineMdPack());
 }
 
+//#endregion
+//#region src/utils/backticks.ts
+/**
+* Length of the longest run of `charCode` in `text`, at least `min`.
+*/
+function longestCharRun(text, charCode, min = 0) {
+	let longest = min;
+	let run = 0;
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === charCode) {
+		run++;
+		if (run > longest) longest = run;
+	} else run = 0;
+	return longest;
+}
+/**
+* Length of the longest run of backticks in `text`, at least `min`.
+*/
+function longestBacktickRun(text, min = 0) {
+	return longestCharRun(text, 96, min);
+}
+
 //#endregion
 //#region src/extensions/inline-toggle.ts
 const TOGGLE_SPECS = {
@@ -5696,7 +5989,7 @@ function markdownToDoc(markdown, options = {}) {
 		frontmatterBody = body;
 		if (matchLength) rest = markdown.slice(matchLength);
 	}
-	const blocks = collectBlocks(nodes, gfmBlockOnlyParser.parse(rest).cursor(), rest);
+	const blocks = collectBlocks(nodes, gfmBlockOnlyParser.parse(rest).cursor(), rest, 0);
 	return nodes.doc(frontmatterBody === void 0 ? {} : { frontmatter: frontmatterBody }, blocks);
 }
 /**
@@ -5718,19 +6011,38 @@ function matchFrontmatter(markdown) {
 * and flattening any node converter that returns multiple siblings
 * (lists are the main case).
 */
-function collectBlocks(nodes, cursor, text) {
+function collectBlocks(nodes, cursor, text, column) {
 	const out = [];
 	if (!cursor.firstChild()) return out;
 	let previousTo;
 	do {
 		if (previousTo != null) appendGapParagraphs(out, nodes, text, previousTo, cursor.from);
 		previousTo = cursor.to;
-		out.push(...convertBlock(nodes, cursor, text));
+		appendBlocks(out, nodes, convertBlock(nodes, cursor, text, column));
 	} while (cursor.nextSibling());
 	cursor.parent();
 	return out;
 }
 /**
+* Append `blocks`, dropping the indented spelling from a code block that lands
+* right after a list: four columns of indentation would put it inside the item
+* above instead of after it, so it can only be written as a fence.
+*/
+function appendBlocks(out, nodes, blocks) {
+	for (const block of blocks) {
+		const attrs = block.attrs;
+		if (attrs.fenceStyle === "indented" && isNodeOfType(block, "codeBlock") && out.length > 0 && isNodeOfType(out[out.length - 1], "list")) {
+			out.push(nodes.codeBlock({
+				language: attrs.language,
+				fenceStyle: null,
+				fenceLength: attrs.fenceLength
+			}, block.textContent));
+			continue;
+		}
+		out.push(block);
+	}
+}
+/**
 * Blank lines between two sibling blocks are content: a run of K blank lines
 * is one block separator plus K-1 empty paragraphs. The gap slice between the
 * siblings' ranges holds only line terminators and structural prefixes
@@ -5742,24 +6054,24 @@ function appendGapParagraphs(out, nodes, text, gapFrom, gapTo) {
 	for (let i = gapFrom; i < gapTo; i++) if (text.charCodeAt(i) === 10) newlineCount++;
 	for (let i = 2; i < newlineCount; i++) out.push(nodes.paragraph());
 }
-function convertBlock(nodes, cursor, text) {
+function convertBlock(nodes, cursor, text, column) {
 	switch (cursor.type.id) {
-		case LEZER_NODE_IDS.ATXHeading1: return [convertHeading(nodes, cursor, text, 1, false)];
-		case LEZER_NODE_IDS.ATXHeading2: return [convertHeading(nodes, cursor, text, 2, false)];
-		case LEZER_NODE_IDS.ATXHeading3: return [convertHeading(nodes, cursor, text, 3, false)];
-		case LEZER_NODE_IDS.ATXHeading4: return [convertHeading(nodes, cursor, text, 4, false)];
-		case LEZER_NODE_IDS.ATXHeading5: return [convertHeading(nodes, cursor, text, 5, false)];
-		case LEZER_NODE_IDS.ATXHeading6: return [convertHeading(nodes, cursor, text, 6, false)];
-		case LEZER_NODE_IDS.SetextHeading1: return [convertHeading(nodes, cursor, text, 1, true)];
-		case LEZER_NODE_IDS.SetextHeading2: return [convertHeading(nodes, cursor, text, 2, true)];
-		case LEZER_NODE_IDS.Paragraph: return [convertParagraph(nodes, cursor, text)];
-		case LEZER_NODE_IDS.LinkReference: return [convertParagraph(nodes, cursor, text)];
-		case LEZER_NODE_IDS.CommentBlock: return [convertHTMLComment(nodes, cursor, text)];
+		case LEZER_NODE_IDS.ATXHeading1: return [convertHeading(nodes, cursor, text, column, 1, false)];
+		case LEZER_NODE_IDS.ATXHeading2: return [convertHeading(nodes, cursor, text, column, 2, false)];
+		case LEZER_NODE_IDS.ATXHeading3: return [convertHeading(nodes, cursor, text, column, 3, false)];
+		case LEZER_NODE_IDS.ATXHeading4: return [convertHeading(nodes, cursor, text, column, 4, false)];
+		case LEZER_NODE_IDS.ATXHeading5: return [convertHeading(nodes, cursor, text, column, 5, false)];
+		case LEZER_NODE_IDS.ATXHeading6: return [convertHeading(nodes, cursor, text, column, 6, false)];
+		case LEZER_NODE_IDS.SetextHeading1: return [convertHeading(nodes, cursor, text, column, 1, true)];
+		case LEZER_NODE_IDS.SetextHeading2: return [convertHeading(nodes, cursor, text, column, 2, true)];
+		case LEZER_NODE_IDS.Paragraph: return [convertParagraph(nodes, cursor, text, column)];
+		case LEZER_NODE_IDS.LinkReference: return [convertParagraph(nodes, cursor, text, column)];
+		case LEZER_NODE_IDS.CommentBlock: return [convertHTMLComment(nodes, cursor, text, column)];
 		case LEZER_NODE_IDS.HTMLBlock:
-		case LEZER_NODE_IDS.ProcessingInstructionBlock: return [convertParagraph(nodes, cursor, text)];
+		case LEZER_NODE_IDS.ProcessingInstructionBlock: return [convertParagraph(nodes, cursor, text, column)];
 		case LEZER_NODE_IDS.Blockquote: return [convertBlockquote(nodes, cursor, text)];
-		case LEZER_NODE_IDS.BulletList: return convertList(nodes, cursor, text, "bullet");
-		case LEZER_NODE_IDS.OrderedList: return convertList(nodes, cursor, text, "ordered");
+		case LEZER_NODE_IDS.BulletList: return convertList(nodes, cursor, text, column, "bullet");
+		case LEZER_NODE_IDS.OrderedList: return convertList(nodes, cursor, text, column, "ordered");
 		case LEZER_NODE_IDS.FencedCode:
 		case LEZER_NODE_IDS.CodeBlock: return [convertCodeBlock(nodes, cursor, text)];
 		case LEZER_NODE_IDS.BlockMath: return [convertBlockMath(nodes, cursor, text)];
@@ -5768,14 +6080,14 @@ function convertBlock(nodes, cursor, text) {
 			return [nodes.horizontalRule({ marker: marker === "---" ? null : marker })];
 		}
 		case LEZER_NODE_IDS.Table: return [convertTable(nodes, cursor, text)];
-		case LEZER_NODE_IDS.Task: return [convertParagraph(nodes, cursor, text)];
+		case LEZER_NODE_IDS.Task: return [convertParagraph(nodes, cursor, text, column)];
 		default:
 			if (text.slice(cursor.from, cursor.to).trim() === "") return [];
 			console.warn(`[meowdown] unsupported lezer block "${cursor.type.name}"`);
-			return [convertParagraph(nodes, cursor, text)];
+			return [convertParagraph(nodes, cursor, text, column)];
 	}
 }
-function convertHeading(nodes, cursor, text, level, isSetext) {
+function convertHeading(nodes, cursor, text, column, level, isSetext) {
 	const headingFrom = cursor.from;
 	let contentStart = cursor.from;
 	let contentEnd = cursor.to;
@@ -5792,13 +6104,14 @@ function convertHeading(nodes, cursor, text, level, isSetext) {
 			lastTo = cursor.to;
 		} while (cursor.nextSibling());
 		if (lastId === LEZER_NODE_IDS.HeaderMark && lastFrom > contentStart) {
-			contentEnd = lastFrom;
+			contentEnd = isSetext ? text.lastIndexOf("\n", lastFrom - 1) : lastFrom;
 			trailingMarkFrom = lastFrom;
 			trailingMarkTo = lastTo;
 		}
 		cursor.parent();
 	}
-	const content = dedentContinuation(text.slice(contentStart, contentEnd), measureContentColumn(text, contentStart)).trim();
+	const raw = dedentContinuation(readLeafText(cursor, text, contentStart, contentEnd), column);
+	const content = isSetext ? raw : trimGap(raw);
 	const setextUnderline = isSetext ? countUnderlineChars(text, trailingMarkFrom, trailingMarkTo) || 1 : null;
 	const closingHashes = !isSetext && trailingMarkFrom >= 0 ? countHashChars(text, trailingMarkFrom, trailingMarkTo) || null : null;
 	return nodes.heading({
@@ -5808,6 +6121,20 @@ function convertHeading(nodes, cursor, text, level, isSetext) {
 	}, content);
 }
 /**
+* Trim the whitespace lezer's marker gap can contain: space, tab and the line
+* ends (`space` in `@lezer/markdown`, matching `isSpaceChar`). A plain
+* `String.prototype.trim` would also take a no-break or an ideographic space,
+* which lezer reads as heading text - and a `#` left standing next to one flips
+* into a closing run on the way back (`# #\u{A0}`).
+*/
+function trimGap(text) {
+	let start = 0;
+	let end = text.length;
+	while (start < end && isSpaceChar(text.charCodeAt(start))) start++;
+	while (end > start && isSpaceChar(text.charCodeAt(end - 1))) end--;
+	return text.slice(start, end);
+}
+/**
 * Count the `=` / `-` characters in a setext underline run.
 */
 function countUnderlineChars(text, from, to) {
@@ -5840,16 +6167,23 @@ function measureContentColumn(text, from) {
 	return col;
 }
 /**
-* Drop a line's leading whitespace up to `column`, counting a tab as `4 - col % 4` columns.
+* Drop a line's leading whitespace up to `column`, counting a tab as `4 - col % 4`
+* columns. Whitespace the container never wrote is left alone: a tab that would
+* reach past `column` stands for more columns than the container takes, and a
+* line whose indentation stops short of `column` was written lazily, without any
+* prefix at all.
 */
 function sliceColumn(line, column) {
 	let col = 0;
 	let index = 0;
-	while (index < line.length && col < column) {
+	while (col < column) {
 		const code = line.charCodeAt(index);
 		if (code === 32) col += 1;
-		else if (code === 9) col += 4 - col % 4;
-		else break;
+		else if (code === 9) {
+			const width = 4 - col % 4;
+			if (col + width > column) break;
+			col += width;
+		} else return line;
 		index++;
 	}
 	return line.slice(index);
@@ -5870,6 +6204,69 @@ function dedentContinuation(content, column) {
 	return content.split("\n").map((line, index) => index === 0 ? line : sliceColumn(line, column)).join("\n");
 }
 /**
+* The blockquote markers inside `from`..`to`, as a flat run of `from, to` pairs
+* in document order. A marker can sit at any depth: a paragraph carries its own,
+* while a link reference's lands inside the `LinkLabel` that spans the break.
+* The cursor ends where it started.
+*/
+function collectQuoteMarks(cursor, marks, from, to) {
+	if (!cursor.firstChild()) return;
+	do {
+		if (cursor.from >= to) break;
+		if (cursor.to <= from) continue;
+		if (cursor.type.id === LEZER_NODE_IDS.QuoteMark) {
+			marks.push(cursor.from, cursor.to);
+			continue;
+		}
+		collectQuoteMarks(cursor, marks, from, to);
+	} while (cursor.nextSibling());
+	cursor.parent();
+}
+/**
+* The source between `from` and `to`, minus the blockquote markers inside it.
+*
+* In block-only parsing a leaf block has no inline children, with one
+* exception: lezer leaves the `QuoteMark` of every continuation line of a
+* multi-line block (`> l1\n> l2`) inside the block's own span. A marker takes
+* the whole line prefix with it, the single space after it included, exactly as
+* the serializer's own prefix puts it back. Only a space: a tab after the marker
+* stands for the columns up to the next tab stop, more than the prefix writes
+* back, so it stays in the text as the indentation it is. A line with no marker
+* carried no prefix at all - it is a lazy continuation, and every column on it
+* is its own. Markers outside `from`..`to` (an ATX heading's own marks, a setext
+* underline's line) are left alone. The cursor ends where it started.
+*/
+function readLeafText(cursor, text, from, to) {
+	const lineBreak = text.indexOf("\n", from);
+	if (lineBreak < 0 || lineBreak >= to) return text.slice(from, to);
+	const marks = [];
+	collectQuoteMarks(cursor, marks, from, to);
+	let content = "";
+	let pos = from;
+	for (let index = 0; index < marks.length; index += 2) {
+		content += text.slice(pos, Math.max(pos, text.lastIndexOf("\n", marks[index]) + 1));
+		pos = marks[index + 1];
+		if (text.charCodeAt(pos) === 32) pos += 1;
+	}
+	return trimTrailingBlankLines(content + text.slice(pos, to));
+}
+/**
+* Drop the blank lines a block ends with, the line break in front of them
+* included. A raw HTML or processing-instruction block with no closing sequence
+* runs its span to the end of the document and swallows them; a leaf block's
+* text ends where its last line does, which is where the serializer ends its
+* own output (`MdOut.finish`), so recording more would lose it on the way back.
+*/
+function trimTrailingBlankLines(content) {
+	let end = content.length;
+	for (let index = end - 1; index >= 0; index--) {
+		const code = content.charCodeAt(index);
+		if (code === 10) end = index;
+		else if (code !== 32 && code !== 9) break;
+	}
+	return content.slice(0, end);
+}
+/**
 * Build a paragraph from raw markdown content, dedenting continuation lines so
 * the serializer's own line prefix does not double the indent. A soft line break
 * stays a literal `\n` in a single text node; the paragraph spec's
@@ -5878,25 +6275,8 @@ function dedentContinuation(content, column) {
 function buildParagraph(nodes, content, column) {
 	return nodes.paragraph(dedentContinuation(content, column));
 }
-function convertParagraph(nodes, cursor, text) {
-	const from = cursor.from;
-	const to = cursor.to;
-	const column = measureContentColumn(text, from);
-	if (cursor.firstChild()) {
-		let content = "";
-		let pos = from;
-		do
-			if (cursor.type.id === LEZER_NODE_IDS.QuoteMark) {
-				content += text.slice(pos, cursor.from);
-				pos = cursor.to;
-				if (isSpaceChar(text.charCodeAt(pos))) pos += 1;
-			}
-		while (cursor.nextSibling());
-		cursor.parent();
-		content += text.slice(pos, to);
-		return buildParagraph(nodes, content, column);
-	}
-	return buildParagraph(nodes, text.slice(from, to), column);
+function convertParagraph(nodes, cursor, text, column) {
+	return buildParagraph(nodes, readLeafText(cursor, text, cursor.from, cursor.to), column);
 }
 /**
 * Build the invisible `htmlComment` node from a `CommentBlock`. The raw comment
@@ -5904,11 +6284,14 @@ function convertParagraph(nodes, cursor, text) {
 * continuation lines are dedented like a paragraph's so the serializer's own
 * line prefix re-applies the container indent instead of doubling it.
 */
-function convertHTMLComment(nodes, cursor, text) {
-	const column = measureContentColumn(text, cursor.from);
-	const content = dedentContinuation(text.slice(cursor.from, cursor.to), column);
+function convertHTMLComment(nodes, cursor, text, column) {
+	const content = dedentContinuation(readLeafText(cursor, text, cursor.from, cursor.to), column);
 	return nodes.htmlComment({ content });
 }
+/**
+* A blockquote's children start at column 0: every column an enclosing container
+* wrote sits in front of the `> ` marker on the line, and comes off with it.
+*/
 function convertBlockquote(nodes, cursor, text) {
 	const content = [];
 	if (cursor.firstChild()) {
@@ -5917,17 +6300,17 @@ function convertBlockquote(nodes, cursor, text) {
 			if (cursor.type.id === LEZER_NODE_IDS.QuoteMark) continue;
 			if (previousTo != null) appendGapParagraphs(content, nodes, text, previousTo, cursor.from);
 			previousTo = cursor.to;
-			content.push(...convertBlock(nodes, cursor, text));
+			appendBlocks(content, nodes, convertBlock(nodes, cursor, text, 0));
 		} while (cursor.nextSibling());
 		cursor.parent();
 	}
 	return nodes.blockquote(content);
 }
-function convertList(nodes, cursor, text, kind) {
+function convertList(nodes, cursor, text, column, kind) {
 	const items = [];
 	if (cursor.firstChild()) {
 		do
-			if (cursor.type.id === LEZER_NODE_IDS.ListItem) items.push(convertListItem(nodes, cursor, text, kind));
+			if (cursor.type.id === LEZER_NODE_IDS.ListItem) items.push(convertListItem(nodes, cursor, text, column, kind));
 		while (cursor.nextSibling());
 		cursor.parent();
 	}
@@ -5958,7 +6341,7 @@ function readListMark(cursor, text, kind) {
 * A GFM `Task` leaf (`[ ] text` / `[x] text`, after the list mark). The checkbox
 * becomes the item's own attributes; the text after it becomes its paragraph.
 */
-function convertTaskItem(nodes, cursor, text) {
+function convertTaskItem(nodes, cursor, text, column) {
 	let taskStart = cursor.from;
 	const taskEnd = cursor.to;
 	let checked = false;
@@ -5978,43 +6361,54 @@ function convertTaskItem(nodes, cursor, text) {
 		cursor.parent();
 	}
 	if (isSpaceChar(text.charCodeAt(taskStart))) taskStart += 1;
-	const paragraph = buildParagraph(nodes, text.slice(taskStart, taskEnd), measureContentColumn(text, taskStart));
+	const paragraph = buildParagraph(nodes, text.slice(taskStart, taskEnd), column);
 	return {
 		checked,
 		taskMarker,
 		paragraph
 	};
 }
-function convertListItem(nodes, cursor, text, kind) {
+function convertListItem(nodes, cursor, text, column, kind) {
 	const content = [];
 	let taskChecked;
 	let taskMarker;
 	let order;
 	let marker;
-	let markEndColumn;
-	let firstContentColumn;
+	let markWidth = 1;
+	let markTo;
+	let markEndColumn = 0;
+	let markerGap = 1;
+	let contentColumn = column + markWidth + markerGap;
+	let sawContent = false;
 	if (cursor.firstChild()) {
 		do {
-			if (cursor.type.id !== LEZER_NODE_IDS.ListMark && firstContentColumn == null) firstContentColumn = measureContentColumn(text, cursor.from);
+			if (cursor.type.id === LEZER_NODE_IDS.QuoteMark) continue;
 			if (cursor.type.id === LEZER_NODE_IDS.ListMark) {
 				const listMark = readListMark(cursor, text, kind);
 				marker = listMark.marker;
 				order = listMark.order;
+				markWidth = cursor.to - cursor.from;
+				markTo = cursor.to;
 				markEndColumn = measureContentColumn(text, cursor.to);
 				continue;
 			}
+			if (!sawContent) {
+				sawContent = true;
+				const gap = markTo != null && text.lastIndexOf("\n", cursor.from - 1) < markTo ? measureContentColumn(text, cursor.from) - markEndColumn : 1;
+				markerGap = gap >= 2 && gap <= 4 ? gap : 1;
+				contentColumn = column + markWidth + markerGap;
+			}
 			if (kind === "bullet" && cursor.type.id === LEZER_NODE_IDS.Task) {
-				const task = convertTaskItem(nodes, cursor, text);
+				const task = convertTaskItem(nodes, cursor, text, contentColumn);
 				taskChecked = task.checked;
 				taskMarker = task.taskMarker;
 				content.push(task.paragraph);
 				continue;
 			}
-			content.push(...convertBlock(nodes, cursor, text));
+			appendBlocks(content, nodes, convertBlock(nodes, cursor, text, contentColumn));
 		} while (cursor.nextSibling());
 		cursor.parent();
 	}
-	const gap = firstContentColumn != null && markEndColumn != null ? firstContentColumn - markEndColumn : 1;
 	const isTask = taskChecked != null;
 	const collapsed = !isTask && kind === "bullet" && marker === "+";
 	const attrs = {
@@ -6024,36 +6418,41 @@ function convertListItem(nodes, cursor, text, kind) {
 		collapsed,
 		marker: collapsed ? null : marker,
 		taskMarker,
-		markerGap: gap >= 2 && gap <= 4 ? gap : 1
+		markerGap
 	};
 	return nodes.list(attrs, content);
 }
 function convertCodeBlock(nodes, cursor, text) {
 	const indented = cursor.type.id === LEZER_NODE_IDS.CodeBlock;
+	const blockTo = cursor.to;
 	let language = "";
 	let code = "";
 	let fenceStyle = indented ? "indented" : null;
 	let fenceLength = null;
 	let sawOpeningMark = false;
+	let pos = cursor.from;
 	if (cursor.firstChild()) {
-		do
+		do {
+			code += uncoveredCode(text, pos, cursor.from);
+			pos = cursor.to;
 			switch (cursor.type.id) {
-				case LEZER_NODE_IDS.CodeMark: {
+				case LEZER_NODE_IDS.CodeMark:
 					if (sawOpeningMark) break;
 					sawOpeningMark = true;
 					if (text.charCodeAt(cursor.from) === 126) fenceStyle = "tilde";
-					const markLength = cursor.to - cursor.from;
-					if (markLength > 3) fenceLength = markLength;
+					fenceLength = cursor.to - cursor.from;
 					break;
-				}
 				case LEZER_NODE_IDS.CodeInfo:
 					language = text.slice(cursor.from, cursor.to);
 					break;
 				case LEZER_NODE_IDS.CodeText: code += text.slice(cursor.from, cursor.to);
 			}
-		while (cursor.nextSibling());
+		} while (cursor.nextSibling());
 		cursor.parent();
+		code += uncoveredCode(text, pos, blockTo);
 	}
+	if (fenceStyle === "indented" && !canIndentCode(code)) fenceStyle = null;
+	if (fenceLength != null && fenceLength <= minFenceLength(code, fenceStyle === "tilde")) fenceLength = null;
 	return nodes.codeBlock({
 		language,
 		fenceStyle,
@@ -6061,6 +6460,17 @@ function convertCodeBlock(nodes, cursor, text) {
 	}, code);
 }
 /**
+* Text inside a code block that no child node covers is the whitespace in
+* front of a line's content: indentation, marker spaces, line breaks. The one
+* exception is a quote marker indented with a tab (`>\t \n\t>2`), where lezer
+* leaves the content after the marker uncovered too, so anything from a gap's
+* first non-whitespace character on is code the child list dropped.
+*/
+function uncoveredCode(text, from, to) {
+	for (let index = from; index < to; index++) if (!isSpaceChar(text.charCodeAt(index))) return text.slice(index, to);
+	return "";
+}
+/**
 * A `$$` display math block is a code block whose `language` is `math`; the
 * `dollar` fence style makes it serialize back to `$$` fences.
 */
@@ -6087,15 +6497,29 @@ function convertTable(nodes, cursor, text) {
 		cursor.parent();
 	}
 	const rows = [];
+	let columnCount = aligns.length;
 	if (cursor.firstChild()) {
 		do {
 			const id = cursor.type.id;
-			if (id === LEZER_NODE_IDS.TableHeader) rows.push(convertTableRow(nodes, cursor, text, true, aligns));
-			else if (id === LEZER_NODE_IDS.TableRow) rows.push(convertTableRow(nodes, cursor, text, false, aligns));
+			if (id !== LEZER_NODE_IDS.TableHeader && id !== LEZER_NODE_IDS.TableRow) continue;
+			const cells = readTableCells(cursor, text);
+			if (cells.length > columnCount) columnCount = cells.length;
+			rows.push({
+				isHeader: id === LEZER_NODE_IDS.TableHeader,
+				cells
+			});
 		} while (cursor.nextSibling());
 		cursor.parent();
 	}
-	return nodes.table(rows);
+	return nodes.table(rows.map(({ isHeader, cells }) => {
+		const built = [];
+		for (let column = 0; column < columnCount; column++) {
+			const attrs = { align: aligns[column] ?? null };
+			const paragraph = nodes.paragraph(cells[column] ?? "");
+			built.push(isHeader ? nodes.tableHeaderCell(attrs, paragraph) : nodes.tableCell(attrs, paragraph));
+		}
+		return nodes.tableRow(built);
+	}));
 }
 function parseDelimiterAligns(separator) {
 	return separator.split("|").map((segment) => segment.trim()).filter((segment) => segment !== "").map((segment) => {
@@ -6107,71 +6531,88 @@ function parseDelimiterAligns(separator) {
 		return null;
 	});
 }
-function convertTableRow(nodes, cursor, text, isHeader, aligns) {
-	const columnCount = aligns.length;
-	const cellTexts = Array(columnCount).fill("");
-	if (cursor.firstChild()) {
-		const hasLeadingPipe = cursor.type.id === LEZER_NODE_IDS.TableDelimiter;
-		let delimiterCount = 0;
-		do
-			if (cursor.type.id === LEZER_NODE_IDS.TableDelimiter) delimiterCount++;
-			else if (cursor.type.id === LEZER_NODE_IDS.TableCell) {
-				const column = delimiterCount - (hasLeadingPipe ? 1 : 0);
-				if (column >= 0 && column < columnCount) cellTexts[column] = text.slice(cursor.from, cursor.to).trim().replaceAll(String.raw`\|`, "|");
-			}
-		while (cursor.nextSibling());
-		cursor.parent();
-	}
-	const cells = cellTexts.map((cellText, column) => {
-		const paragraph = nodes.paragraph(cellText);
-		const attrs = { align: aligns[column] };
-		return isHeader ? nodes.tableHeaderCell(attrs, paragraph) : nodes.tableCell(attrs, paragraph);
-	});
-	return nodes.tableRow(cells);
+/**
+* A row's cell texts, indexed by column. `@lezer/markdown` emits no `TableCell`
+* for an empty cell, so the column comes from the pipes counted so far, not
+* from the cells seen so far.
+*/
+function readTableCells(cursor, text) {
+	const cellTexts = [];
+	if (!cursor.firstChild()) return cellTexts;
+	const hasLeadingPipe = cursor.type.id === LEZER_NODE_IDS.TableDelimiter;
+	let delimiterCount = 0;
+	do {
+		if (cursor.type.id === LEZER_NODE_IDS.TableDelimiter) {
+			delimiterCount++;
+			continue;
+		}
+		if (cursor.type.id !== LEZER_NODE_IDS.TableCell) continue;
+		const column = delimiterCount - (hasLeadingPipe ? 1 : 0);
+		if (column < 0) continue;
+		while (cellTexts.length <= column) cellTexts.push("");
+		cellTexts[column] = text.slice(cursor.from, cursor.to).trim().replaceAll(String.raw`\|`, "|");
+	} while (cursor.nextSibling());
+	cursor.parent();
+	return cellTexts;
 }
 
 //#endregion
 //#region src/converters/check-roundtrip.ts
 function trimTrailingNewlines(text) {
-	return text.replace(/\n+$/u, "");
+	let end = text.length;
+	while (end > 0 && text.charCodeAt(end - 1) === 10) end--;
+	return text.slice(0, end);
 }
-function isBlankLine(line) {
-	return /^[\s>]*$/u.test(line);
-}
-function nonBlankLines(text) {
-	return text.split("\n").filter((line) => !isBlankLine(line));
-}
-function collapseWhitespace(line) {
-	return line.trim().replaceAll(/\s+/gu, " ");
+const CONTAINER_PREFIX_RE = /^(?:[\s>]|[-+*](?=\s|$)|\d{1,9}[.)](?=\s|$))+/u;
+function stripWhitespace(line) {
+	return line.replaceAll(/\s/gu, "");
 }
 const DELIMITER_CELL_RE = /^:?-+:?$/u;
-function canonicalizeDelimiterCell(cell) {
-	const alignsLeft = cell.startsWith(":");
-	const alignsRight = cell.endsWith(":");
-	if (alignsLeft && alignsRight) return ":-:";
-	if (alignsLeft) return ":--";
-	if (alignsRight) return "--:";
-	return "---";
-}
 function canonicalizeTableRow(line) {
 	if (!line.includes("|")) return void 0;
-	const prefix = /^[\s>]*/u.exec(line)?.[0] ?? "";
-	const cells = line.slice(prefix.length).trim().replace(/^\|/u, "").replace(/\|$/u, "").split("|").map((cell) => collapseWhitespace(cell));
-	return collapseWhitespace(`${prefix} | ${(cells.every((cell) => DELIMITER_CELL_RE.test(cell)) ? cells.map(canonicalizeDelimiterCell) : cells).join(" | ")} |`);
+	const cells = line.replace(/^\|/u, "").replace(/\|$/u, "").split("|");
+	if (cells.every((cell) => DELIMITER_CELL_RE.test(cell))) return "";
+	return cells.filter((cell) => cell !== "").join("|");
+}
+/**
+* The lines of `text` that carry content, each reduced to that content. A line
+* left empty by dropping its markers and whitespace (a blank line, a bare `>`,
+* a list marker whose content is on the next line) carries none and is skipped.
+*/
+function contentLines(text) {
+	const lines = [];
+	for (const line of text.split("\n")) {
+		const content = stripWhitespace(line.replace(CONTAINER_PREFIX_RE, ""));
+		if (content !== "") lines.push(canonicalizeTableRow(content) ?? content);
+	}
+	return lines;
 }
-function normalizeLine(line) {
-	return canonicalizeTableRow(line) ?? collapseWhitespace(line);
+/**
+* Whether `wanted` appears in `found` as an ordered subsequence.
+*
+* The serializer may write a line the source never had: an unterminated fenced
+* block gets the closing fence it was missing. Such a line carries no content,
+* which the document comparison proves - so only a content line that fails to
+* come back out is loss.
+*/
+function containsInOrder(found, wanted) {
+	let index = 0;
+	for (const line of found) {
+		if (index === wanted.length) return true;
+		if (line === wanted[index]) index++;
+	}
+	return index === wanted.length;
 }
 /**
 * Classify how `markdown` survives the editor's parse-then-serialize round trip.
 */
 function checkRoundTrip(markdown, options = {}) {
-	const doc = markdownToDoc(markdown, { frontmatter: options.frontmatter });
-	const serialized = docToMarkdown(doc, { frontmatter: options.frontmatter });
+	const { frontmatter } = options;
+	const doc = markdownToDoc(markdown, { frontmatter });
+	const serialized = docToMarkdown(doc, { frontmatter });
 	if (trimTrailingNewlines(serialized) === trimTrailingNewlines(markdown)) return "exact";
-	const before = nonBlankLines(markdown);
-	const after = nonBlankLines(serialized);
-	return before.length === after.length && before.every((line, i) => normalizeLine(line) === normalizeLine(after[i])) ? "normalizing" : "lossy";
+	if (!containsInOrder(contentLines(serialized), contentLines(markdown))) return "lossy";
+	return markdownToDoc(serialized, { frontmatter }).eq(doc) ? "normalizing" : "lossy";
 }
 
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meowdown/core",
   "type": "module",
-  "version": "0.65.2",
+  "version": "0.65.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
     "remark-stringify": "^11.0.0",
     "unicode-by-name": "^0.2.0",
     "unified": "^11.0.5",
-    "@meowdown/markdown": "^0.65.2"
+    "@meowdown/markdown": "^0.65.3"
   },
   "devDependencies": {
     "@ocavue/tsconfig": "^0.7.1",
@@ -53,6 +53,7 @@
     "@vitest/browser-playwright": "^4.1.10",
     "dedent": "^1.7.2",
     "diffable-html-snapshot": "^0.3.0",
+    "fast-check": "^4.9.0",
     "tsdown": "^0.23.0-beta.2",
     "vitest": "^4.1.10",
     "@meowdown/vitest": "0.0.0"