@meowdown/core 0.77.0 → 0.78.1

package/dist/index.js

@@ -1,9 +1,8 @@
+import { LEZER_NODE_IDS, checkRoundTrip, collectInlineElements, getAutolinkHref, gfmParser, isSpaceChar, matchEmbed, parseInline, parseMarkdownAst, parseXPostId, serializeMarkdownAst } from "@meowdown/markdown";
 import { Priority, Priority as Priority$1, createMarkBuilders, createNodeBuilders, defaultBlockAt, defineBaseCommands, defineBaseKeymap, defineClipboardSerializer, defineCommands, defineHistory, defineKeymap, defineMarkSpec, defineMarkView, defineNodeAttr, defineNodeSpec, definePlugin, findMarkRange, getMarkRange, getMarkType, getNodeType, isAllSelection, isApple, isAtBlockStart, isNodeSelection, isTextSelection, setBlockType, toggleNode, union, unsetBlockType, withPriority, withPriority as withPriority$1, withSkipCodeBlock } from "@prosekit/core";
 import { defineCodeBlock, defineCodeBlockHighlight, defineCodeBlockPreviewPlugin, isCodeBlockPreviewHiddenDecoration } from "@prosekit/extensions/code-block";
 import { definePlaceholder, definePlaceholder as definePlaceholder$1 } from "@prosekit/extensions/placeholder";
-import { NodeSelection, Plugin, PluginKey, Selection, TextSelection } from "@prosekit/pm/state";
 import { defineSearchCommands, defineSearchQuery, defineSearchStatusHandler, getSearchStatus, getSearchStatus as getSearchStatus$1 } from "@prosekit/extensions/search";
-import { LEZER_NODE_IDS, collectInlineElements, getAutolinkHref, gfmBlockOnlyParser, gfmParser, isSpaceChar, matchEmbed, parseInline, parseXPostId } from "@meowdown/markdown";
 import { isElementLike, isHTMLElement, isObject, once } from "@ocavue/utils";
 import { defineBlockquote } from "@prosekit/extensions/blockquote";
 import { defineDoc } from "@prosekit/extensions/doc";
@@ -11,6 +10,7 @@ import { defineGapCursor } from "@prosekit/extensions/gap-cursor";
 import { defineModClickPrevention } from "@prosekit/extensions/mod-click-prevention";
 import { defineText } from "@prosekit/extensions/text";
 import { defineVirtualSelection } from "@prosekit/extensions/virtual-selection";
+import { NodeSelection, Plugin, PluginKey, Selection, TextSelection } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";
 import { NO_BREAK_SPACE } from "unicode-by-name";
 import { defaultHandlers } from "hast-util-to-mdast";
@@ -48,18 +48,6 @@ import { createListRenderingPlugin, createSafariInputMethodWorkaroundPlugin, cre
 import { defineTableCellSpec, defineTableCommands, defineTableDropIndicator, defineTableEditingPlugin, defineTableHeaderCellSpec, defineTableRowSpec, defineTableSpec, deleteTable, isCellSelection } from "@prosekit/extensions/table";
 import { InputRule } from "@prosekit/pm/inputrules";
 
-//#region src/extensions/readonly.ts
-function defineReadonly(getReadonly = () => true) {
-	return definePlugin(new Plugin({ props: { editable: (state) => !getReadonly(state) } }));
-}
-
-//#endregion
-//#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;
@@ -633,6 +621,12 @@ function defineAtomMarkNavigation({ marks }) {
 	}), Priority$1.high), definePlugin(createCaretSnapPlugin(marks)), definePlugin(createSelectionPlugin(marks)));
 }
 
+//#endregion
+//#region src/extensions/node-names.ts
+function isNodeOfType(node, name) {
+	return node.type.name === name;
+}
+
 //#endregion
 //#region src/extensions/bullet-after-heading.ts
 /**
@@ -1382,724 +1376,150 @@ function definePlainTextPaste() {
 }
 
 //#endregion
-//#region src/converters/pm-to-md.ts
-/**
-* Convert a ProseMirror document into a Markdown string.
-*
-* Performance design:
-* - Output accumulates in a `string[]` buffer; joined once at the end.
-*   Avoids per-block intermediate strings while keeping the
-*   function-per-node-type readability of a switch dispatch.
-* - Indent stack lives as a mutable `linePrefix` on the buffer object,
-*   restored via local variables across nested calls - no fresh
-*   context objects per recursion.
-* - Inline content is walked directly (not via `node.textContent`) to
-*   skip one intermediate string allocation per leaf block.
-* - Backtick fence width and cell escaping use single linear loops, no
-*   regex on the hot path.
-*/
-function docToMarkdown(node, options = {}) {
-	const out = new MdOut();
-	if (options.frontmatter) emitFrontmatter(node.attrs.frontmatter, out);
-	const child = node.childCount === 1 ? node.child(0) : void 0;
-	if (!(child && isNodeOfType(child, "paragraph") && child.childCount === 0)) emit$1(node, out);
-	return out.finish();
-}
-/**
-* Emit the document's YAML frontmatter (stored as a `doc` attribute) as a
-* leading `---\n{body}\n---` block. `null` (the default) emits nothing; an
-* empty body emits `---\n---` with no middle blank line.
-*/
-function emitFrontmatter(body, out) {
-	if (body === null) return;
-	out.write("---");
-	out.write("\n");
-	if (body !== "") {
-		out.write(body);
-		out.write("\n");
-	}
-	out.write("---");
-	out.closeBlock();
-}
-/**
-* Heading prefixes indexed by level (1..6). Index 0 is a sentinel.
-*/
-const HEADING_PREFIX = [
-	"",
-	"# ",
-	"## ",
-	"### ",
-	"#### ",
-	"##### ",
-	"###### "
-];
-function emitHeading(node, out) {
-	const attrs = node.attrs;
-	const underline = attrs.setextUnderline;
-	if (underline != null && node.content.size > 0 && attrs.level <= 2) {
-		emitInlineChildren(node, out);
-		const underlineChar = attrs.level === 1 ? "=" : "-";
-		out.write("\n" + underlineChar.repeat(Math.max(1, underline)));
-		out.closeBlock();
-		return;
-	}
-	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));
-	out.closeBlock();
-}
-var MdOut = class {
-	constructor() {
-		this.parts = [];
-		this.linePrefix = "";
-		this.pendingFirst = null;
-		this.atLineStart = true;
-		this.deferredBlankPrefix = null;
-		this.contentEnd = 0;
-	}
-	/**
-	* 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;
-		}
-		if (!text.includes("\n")) {
-			this.parts.push(text);
-			return;
-		}
-		const lines = text.split("\n");
-		const lazy = lazyLines && this.linePrefix !== "";
-		for (let i = 0; i < lines.length; 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);
-		}
-	}
-	/**
-	* End a block that owns no line of its own (an empty paragraph): it is one
-	* blank line. After another block, the blank line that block owes is this
-	* one, and the next block is owed a fresh one, so each empty block adds a
-	* blank line to the separator. With nothing owed (the start of the output)
-	* the line is written directly and nothing is owed after it: a leading empty
-	* block is a blank line, not a separator. A marker-bearing block (an empty
-	* list item's `- `, an empty quote line's `>`) writes its marker as the line.
-	*/
-	closeEmptyBlock() {
-		if (!this.atLineStart) {
-			this.closeBlock();
-			return;
-		}
-		if (this.pendingFirst !== null) {
-			this.emitDeferredBlankLine();
-			const marker = this.pendingFirst;
-			this.parts.push(marker.endsWith("] ") ? marker : marker.trimEnd(), "\n");
-			this.pendingFirst = null;
-			return;
-		}
-		if (this.deferredBlankPrefix === null) {
-			this.parts.push(this.linePrefix.trimEnd(), "\n");
-			return;
-		}
-		this.emitDeferredBlankLine();
-		this.deferredBlankPrefix = this.linePrefix;
-	}
-	/**
-	* End the current block; the next write gets a blank line before it.
-	*/
-	closeBlock() {
-		if (this.atLineStart && this.pendingFirst !== null) {
-			this.emitDeferredBlankLine();
-			const marker = this.pendingFirst;
-			this.parts.push(marker.endsWith("] ") ? marker : marker.trimEnd());
-			this.pendingFirst = null;
-			this.atLineStart = false;
-		}
-		if (!this.atLineStart) {
-			this.parts.push("\n");
-			this.contentEnd = this.parts.length;
-		}
-		this.atLineStart = true;
-		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
-	* from its nested list) with a single newline.
-	*/
-	suppressBlank() {
-		this.deferredBlankPrefix = null;
-	}
-	get atContentStart() {
-		return this.atLineStart && !this.pendingFirst?.endsWith("] ");
-	}
-	/**
-	* Run `fn` with `linePrefix` extended by `continuation`.
-	* If `firstLine` is given, it replaces the prefix on the NEXT line only -
-	* used for list items where the marker (`- `) only appears on line 1.
-	* Composes with any outer one-shot prefix: a blockquote inside a list
-	* item should emit "- > " on the first line, not just "> ".
-	*/
-	withPrefix(continuation, firstLine, fn) {
-		const savedLine = this.linePrefix;
-		const savedFirst = this.pendingFirst;
-		this.linePrefix = savedLine + continuation;
-		if (firstLine !== null) {
-			const base = savedFirst ?? savedLine;
-			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() {
-		const text = this.parts.slice(0, this.contentEnd).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 (cut === 0 ? "" : text.slice(0, cut) + "\n") + this.parts.slice(this.contentEnd).join("") || "\n";
-	}
-	emitDeferredBlankLine() {
-		const prefix = this.deferredBlankPrefix;
-		if (prefix === null) return;
-		this.parts.push(prefix.trimEnd(), "\n");
-		this.deferredBlankPrefix = null;
-	}
-};
-function emit$1(node, out) {
-	switch (node.type.name) {
-		case "doc":
-			emitBlockChildren(node, out);
-			return;
-		case "paragraph":
-			if (node.childCount === 0) {
-				out.closeEmptyBlock();
-				return;
-			}
-			emitInlineChildren(node, out);
-			out.closeBlock();
-			return;
-		case "heading":
-			emitHeading(node, out);
-			return;
-		case "blockquote":
-			out.withPrefix("> ", "> ", () => emitBlockChildren(node, out));
-			out.closeBlock();
-			return;
-		case "list":
-			emitList(node, out, isTightItem(node));
-			return;
-		case "codeBlock":
-			emitCodeBlock(node, out);
-			return;
-		case "horizontalRule": {
-			const { marker } = node.attrs;
-			out.write(marker || "---");
-			out.closeBlock();
-			return;
-		}
-		case "htmlComment": {
-			const { content } = node.attrs;
-			out.write(content);
-			out.closeBlock();
-			return;
-		}
-		case "table":
-			emitTable(node, out);
-			return;
-		case "text":
-			if (node.text) out.write(node.text);
-			return;
-	}
-}
+//#region src/converters/pm-to-ast.ts
 /**
-* Emit block-level children. Consecutive `list` children form one markdown
-* list ("run") whose tightness is decided once for the whole run, matching
-* CommonMark's list-wide loose/tight semantics.
-*
-* `tightItem` is true when `node` is a list item inside a tight run: its
-* blocks (a paragraph followed by nested lists) are then separated by single
-* newlines instead of blank lines.
-*/
-function emitBlockChildren(node, out, tightItem = false) {
-	const count = node.childCount;
-	let index = 0;
-	while (index < count) {
-		const child = node.child(index);
-		if (!isNodeOfType(child, "list")) {
-			if (tightItem && index > 0) out.suppressBlank();
-			emit$1(child, out);
-			index++;
-			continue;
-		}
-		let runEnd = index + 1;
-		while (runEnd < count && isNodeOfType(node.child(runEnd), "list")) runEnd++;
-		const tightRun = isTightRun(node, index, runEnd);
-		for (let item = index; item < runEnd; item++) {
-			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.
+* Read persisted block data. Editor marks do not add Markdown delimiters.
 */
-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
-* separation inside the item, which per CommonMark makes the whole list
-* loose.
-*/
-function isTightRun(parent, from, to) {
-	for (let i = from; i < to; i++) if (!isTightItem(parent.child(i))) return false;
-	return true;
-}
-function isTightItem(item) {
-	const count = item.childCount;
-	for (let i = 0; i < count; i++) {
-		const typeName = item.child(i).type.name;
-		if (typeName === "list") continue;
-		if (typeName === "paragraph" && i === 0) continue;
-		return false;
-	}
-	return true;
+function docToAst(node) {
+	if (isNodeOfType(node, "doc")) return {
+		type: "document",
+		frontmatter: node.attrs.frontmatter ?? void 0,
+		children: readBlocks(node)
+	};
+	if (isNodeOfType(node, "tableRow")) return readTableRow(node);
+	if (isNodeOfType(node, "tableCell") || isNodeOfType(node, "tableHeaderCell")) return readTableCell(node);
+	return readBlock(node);
 }
-/**
-* 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;
+function readBlocks(node) {
+	return node.content.content.map(readBlock);
 }
-/**
-* 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) {
-	if (text.charCodeAt(0) !== 60) return false;
-	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)));
+function readBlock(node) {
+	switch (node.type.name) {
+		case "paragraph": {
+			const inline = readInline(node);
+			return {
+				type: "paragraph",
+				value: inline.value,
+				segments: inline.segments
+			};
 		}
-		case 96:
-		case 126: {
-			let end = index + 1;
-			while (line.charCodeAt(end) === first) end++;
-			return end - index >= 3;
+		case "heading": {
+			const attrs = node.attrs;
+			const inline = readInline(node);
+			return {
+				type: "heading",
+				level: attrs.level,
+				setextUnderline: attrs.setextUnderline ?? void 0,
+				closingHashes: attrs.closingHashes ?? void 0,
+				value: inline.value,
+				segments: inline.segments
+			};
 		}
-		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);
+		case "blockquote": return {
+			type: "blockquote",
+			children: readBlocks(node)
+		};
+		case "list": {
+			const attrs = node.attrs;
+			return {
+				type: "listItem",
+				kind: attrs.kind === "ordered" || attrs.kind === "task" ? attrs.kind : "bullet",
+				order: attrs.order ?? void 0,
+				checked: !!attrs.checked,
+				collapsed: !!attrs.collapsed,
+				marker: attrs.marker ?? void 0,
+				taskMarker: attrs.taskMarker ?? void 0,
+				markerGap: attrs.markerGap,
+				children: readBlocks(node)
+			};
 		}
-		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;
+		case "codeBlock": {
+			const attrs = node.attrs;
+			return {
+				type: "codeBlock",
+				language: attrs.language || "",
+				fenceStyle: attrs.fenceStyle ?? void 0,
+				fenceLength: attrs.fenceLength ?? void 0,
+				value: node.textContent
+			};
+		}
+		case "horizontalRule": return {
+			type: "horizontalRule",
+			marker: node.attrs.marker ?? void 0
+		};
+		case "htmlComment": return {
+			type: "htmlComment",
+			value: node.attrs.content
+		};
+		case "table": return readTable(node);
+		case "text": return {
+			type: "text",
+			value: node.text ?? ""
+		};
+		default: return {
+			type: "ignored",
+			value: node.textContent,
+			hasContent: node.content.size > 0
+		};
 	}
-	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
-* allocation per leaf block (paragraph / heading content).
-*/
-function emitInlineChildren(node, out) {
-	const count = node.childCount;
-	if (count === 0) return;
-	const first = node.child(0).text;
-	const lazy = first == null || !out.atContentStart || !opensHTMLBlock(first);
+function readInline(node) {
+	const content = node.content.content;
+	const count = content.length;
+	if (count === 0) return {
+		value: "",
+		segments: void 0
+	};
+	const first = node.child(0);
+	if (count === 1 && first.isText) return {
+		value: first.text ?? "",
+		segments: void 0
+	};
+	const chunks = new Array(count);
+	let value = "";
 	for (let i = 0; i < count; i++) {
-		const child = node.child(i);
-		if (child.isText && child.text) out.write(child.text, lazy);
-	}
-}
-function emitList(node, out, tight) {
-	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}${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 || "";
-	const code = node.textContent;
-	if (attrs.fenceStyle === "indented" && !language) {
-		const indentedCode = toIndentedCode(code);
-		if (indentedCode != null) {
-			out.write(indentedCode);
-			out.closeBlock();
-			return;
-		}
-	}
-	if (attrs.fenceStyle === "dollar" && language === "math" && !hasDollarFenceLine(code)) {
-		out.write("$$");
-		out.write("\n");
-		if (code) {
-			out.write(code);
-			out.write("\n");
-		}
-		out.write("$$");
-		out.closeBlock();
-		return;
+		const child = content[i];
+		const text = child.isText ? child.text : void 0;
+		chunks[i] = text;
+		if (text) value += text;
 	}
-	const tilde = attrs.fenceStyle === "tilde";
-	const fence = (tilde ? "~" : "`").repeat(Math.max(attrs.fenceLength ?? 0, minFenceLength(code, tilde)));
-	out.write(fence);
-	if (language) out.write(language.startsWith(tilde ? "~" : "`") ? " " + language : language);
-	out.write("\n");
-	if (code) {
-		out.write(code);
-		out.write("\n");
-	}
-	out.write(fence);
-	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;
+	return {
+		value,
+		segments: {
+			value,
+			chunks,
+			textContent: node.textContent
 		}
-		lineStart = lineEnd + 1;
-	}
-	return longest + 1;
+	};
 }
-function isSpaceOrTab(char) {
-	return char === 32 || char === 9;
+function readTable(node) {
+	return {
+		type: "table",
+		children: node.content.content.map(readTableRow)
+	};
 }
-/**
-* 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");
+function readTableRow(node) {
+	return {
+		type: "tableRow",
+		children: node.content.content.map(readTableCell)
+	};
 }
-/**
-* Indent `code` for an indented code block, or return `undefined` for shapes
-* 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 (!canIndentCode(code)) return void 0;
-	const lines = code.split("\n");
-	for (let i = 0; i < lines.length; i++) if (lines[i] !== "") lines[i] = `    ${lines[i]}`;
-	return lines.join("\n");
+function readTableCell(node) {
+	return {
+		type: "tableCell",
+		header: isNodeOfType(node, "tableHeaderCell"),
+		align: node.attrs.align ?? void 0,
+		children: readBlocks(node)
+	};
 }
+
+//#endregion
+//#region src/converters/pm-to-md.ts
 /**
-* Whether any content line would read as a closing `$$` fence.
+* Convert persisted editor content to Markdown through the shared block serializer.
 */
-function hasDollarFenceLine(code) {
-	return code.split("\n").some((line) => line.trim() === "$$");
-}
-function emitTable(node, out) {
-	const rowCount = node.childCount;
-	if (rowCount === 0) return;
-	const rows = [];
-	let colCount = 0;
-	let headerIdx = -1;
-	for (let r = 0; r < rowCount; r++) {
-		const row = node.child(r);
-		const cells = [];
-		let isHeaderRow = false;
-		for (let c = 0; c < row.childCount; c++) {
-			const cell = row.child(c);
-			if (isNodeOfType(cell, "tableHeaderCell")) isHeaderRow = true;
-			cells.push(extractCellText(cell));
-		}
-		if (isHeaderRow && headerIdx < 0) headerIdx = r;
-		if (cells.length > colCount) colCount = cells.length;
-		rows.push(cells);
-	}
-	if (colCount === 0) return;
-	const alignmentRow = node.child(headerIdx >= 0 ? headerIdx : 0);
-	const delimiters = [];
-	for (let c = 0; c < colCount; c++) {
-		const cell = c < alignmentRow.childCount ? alignmentRow.child(c) : void 0;
-		const align = cell ? cell.attrs.align : void 0;
-		delimiters.push(formatDelimiter(align));
-	}
-	const separator = "| " + delimiters.join(" | ") + " |";
-	const headRow = headerIdx >= 0 ? rows[headerIdx] : new Array(colCount).fill("");
-	out.write(formatTableRow(headRow, colCount));
-	out.write("\n");
-	out.write(separator);
-	for (let r = 0; r < rowCount; r++) {
-		if (r === headerIdx) continue;
-		out.write("\n");
-		out.write(formatTableRow(rows[r], colCount));
-	}
-	out.closeBlock();
-}
-function formatDelimiter(align) {
-	switch (align) {
-		case "left": return ":--";
-		case "center": return ":-:";
-		case "right": return "--:";
-		default: return "---";
-	}
-}
-function formatTableRow(cells, colCount) {
-	let s = "|";
-	for (let c = 0; c < colCount; c++) s += " " + (cells[c] ?? "") + " |";
-	return s;
-}
-/**
-* Trim cell text and escape pipes / collapse newlines into spaces.
-*
-* Why trim: the forward parser (`markdownToDoc`) calls `.trim()`
-* on cell text, matching GFM's documented behavior. We must do the same
-* here for round-trip stability.
-*
-* Fast path: if the trimmed text contains no `|` or `\n`, return it as-is
-* with no further allocation.
-*/
-function extractCellText(cell) {
-	const raw = cell.textContent.trim();
-	if (!raw.includes("|") && !raw.includes("\n")) return raw;
-	return raw.replaceAll("|", String.raw`\|`).replaceAll("\n", " ");
+function docToMarkdown(node, options = {}) {
+	return serializeMarkdownAst(docToAst(node), options);
 }
 
 //#endregion
@@ -2566,6 +1986,7 @@ var ConfigController = class {
 };
 const refreshKeys = /* @__PURE__ */ new Set([
 	"markMode",
+	"referenceDefinitions",
 	"placeholder",
 	"readOnly",
 	"spellCheck",
@@ -5099,6 +4520,75 @@ function emit(out, from, to, marks) {
 	]);
 }
 
+//#endregion
+//#region src/converters/paragraph.ts
+/**
+* Build one paragraph without interpreting block-opening Markdown.
+*/
+function paragraphMarkdownToDoc(markdown, nodes = getNodeBuilders()) {
+	return astToDoc({
+		type: "document",
+		children: [{
+			type: "paragraph",
+			value: markdown.replaceAll(/\r\n?/g, "\n").replaceAll(/\n[ \t]*\n+/g, "\n")
+		}]
+	}, nodes);
+}
+/**
+* Flatten textblocks into one paragraph's source content.
+*/
+function docToParagraphMarkdown(doc) {
+	const paragraphs = [];
+	doc.descendants((node) => {
+		if (!node.isTextblock) return true;
+		paragraphs.push(node.textContent);
+		return false;
+	});
+	return paragraphs.join("\n").replaceAll(/\r\n?/g, "\n").replaceAll(/\n[ \t]*\n+/g, "\n");
+}
+
+//#endregion
+//#region src/extensions/single-paragraph.ts
+const singleParagraphPluginKey = new PluginKey("single-paragraph");
+/**
+* Keep editing and pasted content within one paragraph.
+* Opt into this extension for inline Markdown fields such as task paragraphs.
+* Register it alongside `defineMeowdown`, seed content with
+* `paragraphMarkdownToDoc`, and read edits with `docToParagraphMarkdown`.
+* Ordinary note editors should keep their full document behavior.
+*
+* Text input stays literal, before block input rules can consume prefixes.
+* Transactions and pasted blocks flatten to paragraph text separated by soft
+* lines. Reference definitions come from `referenceDefinitions` in the editor
+* config; definition-looking content in the field remains visible literal text.
+* Enter/submit, focus, and persistence remain the caller's responsibility.
+*
+* @example
+* const editor = createEditor({
+*   extension: union(defineMeowdown({ referenceDefinitions }), defineSingleParagraph()),
+*   defaultContent: paragraphMarkdownToDoc('Buy **milk**'),
+* })
+* const markdown = docToParagraphMarkdown(editor.state.doc)
+*/
+function defineSingleParagraph() {
+	return withPriority$1(definePlugin(new Plugin({
+		key: singleParagraphPluginKey,
+		props: { handleTextInput(view, from, to, text) {
+			view.dispatch(view.state.tr.insertText(text, from, to));
+			return true;
+		} },
+		appendTransaction(transactions, _oldState, state) {
+			if (!transactions.some((transaction) => transaction.docChanged)) return;
+			const markdown = docToParagraphMarkdown(state.doc);
+			if (state.doc.childCount === 1 && isNodeOfType(state.doc.child(0), "paragraph") && state.doc.child(0).textContent === markdown) return;
+			const doc = paragraphMarkdownToDoc(markdown, getNodeBuildersForSchema(state.schema));
+			const position = Math.min(state.selection.head, doc.content.size - 1);
+			const transaction = state.tr.replaceWith(0, state.doc.content.size, doc.content);
+			return transaction.setSelection(TextSelection.create(transaction.doc, Math.max(1, position)));
+		}
+	})), Priority$1.highest);
+}
+
 //#endregion
 //#region src/extensions/inline-mark-plugin.ts
 const META_KEY = "inline-marks-applied";
@@ -5195,7 +4685,7 @@ function createInlineMarkPlugin(getOptions) {
 			const touchesRange = pos <= range.to && pos + node.nodeSize >= range.from;
 			const dependsOnChange = cached == null || setsIntersect(cached.referencedKeys, changedKeys);
 			if (!touchesRange && !dependsOnChange) return false;
-			const nodeChunks = chunksForTextblock(node, pos + 1, state.schema, options, references, changedKeys, isReferenceDefinitionNode(node, parent, index));
+			const nodeChunks = chunksForTextblock(node, pos + 1, state.schema, options, references, changedKeys, !singleParagraphPluginKey.get(state) && isReferenceDefinitionNode(node, parent, index));
 			if (nodeChunks.length > 0) chunks.push(...nodeChunks);
 			const updated = chunkCache.get(node);
 			if (updated != null) processed.push({
@@ -5217,29 +4707,43 @@ function createInlineMarkPlugin(getOptions) {
 			if (node?.isTextblock) chunkCache.set(node, cached);
 		}
 	}
+	function collectReferences(doc, external, state) {
+		const local = singleParagraphPluginKey.get(state) ? {
+			nodes: /* @__PURE__ */ new Set(),
+			definitions: /* @__PURE__ */ new Map()
+		} : collectReferenceDefinitions(doc);
+		return external ? {
+			nodes: local.nodes,
+			definitions: new Map([...external, ...local.definitions])
+		} : local;
+	}
 	return new Plugin({
 		key: pluginKey,
 		state: {
 			init(_config, state) {
 				return {
-					references: collectReferenceDefinitions(state.doc),
+					externalDefinitions: getOptions?.(state)?.referenceDefinitions,
+					references: collectReferences(state.doc, getOptions?.(state)?.referenceDefinitions, state),
 					pendingReferenceKeys: emptyReferenceKeys
 				};
 			},
-			apply(transaction, value, _oldState, newState) {
+			apply(transaction, value, oldState, newState) {
 				if (transaction.getMeta(RESTYLE_KEY) === true) return value.pendingReferenceKeys.size === 0 ? value : {
-					references: value.references,
+					...value,
 					pendingReferenceKeys: emptyReferenceKeys
 				};
 				if (transaction.getMeta(META_KEY)) return value;
-				const references = updateReferenceDefinitions(value.references, transaction, newState.doc);
+				const externalDefinitions = getOptions?.(oldState)?.referenceDefinitions;
+				const references = singleParagraphPluginKey.get(oldState) || externalDefinitions !== value.externalDefinitions || externalDefinitions && transaction.docChanged ? collectReferences(newState.doc, externalDefinitions, newState) : updateReferenceDefinitions(value.references, transaction, newState.doc);
 				if (references === value.references) return value;
 				const changedKeys = getChangedReferenceKeys(value.references.definitions, references.definitions);
 				if (changedKeys.size === 0) return {
+					externalDefinitions,
 					references,
 					pendingReferenceKeys: value.pendingReferenceKeys
 				};
 				return {
+					externalDefinitions,
 					references,
 					pendingReferenceKeys: mergeReferenceKeys(value.pendingReferenceKeys, changedKeys)
 				};
@@ -7171,6 +6675,12 @@ function definePendingReplacementHandler(handler) {
 	} }) }));
 }
 
+//#endregion
+//#region src/extensions/readonly.ts
+function defineReadonly(getReadonly = () => true) {
+	return definePlugin(new Plugin({ props: { editable: (state) => !getReadonly(state) } }));
+}
+
 //#endregion
 //#region src/utils/caret-coords.ts
 /**
@@ -7845,6 +7355,46 @@ function getNodeBuildersForSchema(schema) {
 	return builders;
 }
 
+//#endregion
+//#region src/converters/ast-to-pm.ts
+/**
+* Build nodes with the caller's schema; Markdown inline syntax remains literal text.
+*/
+function astToDoc(node, nodes = getNodeBuilders()) {
+	const children = node.children?.map((child) => astToDoc(child, nodes)) || [];
+	switch (node.type) {
+		case "document": return nodes.doc(node.frontmatter == null ? {} : { frontmatter: node.frontmatter }, children);
+		case "paragraph": return nodes.paragraph(node.value);
+		case "heading": return nodes.heading({
+			level: node.level,
+			setextUnderline: node.setextUnderline ?? null,
+			closingHashes: node.closingHashes ?? null
+		}, node.value);
+		case "blockquote": return nodes.blockquote(children);
+		case "listItem": return nodes.list({
+			kind: node.kind,
+			order: node.order ?? null,
+			checked: node.checked,
+			collapsed: node.collapsed,
+			marker: node.marker ?? null,
+			taskMarker: node.taskMarker,
+			markerGap: node.markerGap
+		}, children);
+		case "codeBlock": return nodes.codeBlock({
+			language: node.language,
+			fenceStyle: node.fenceStyle ?? null,
+			fenceLength: node.fenceLength ?? null
+		}, node.value);
+		case "horizontalRule": return nodes.horizontalRule({ marker: node.marker ?? null });
+		case "htmlComment": return nodes.htmlComment({ content: node.value });
+		case "table": return nodes.table(children);
+		case "tableRow": return nodes.tableRow(children);
+		case "tableCell": return node.header ? nodes.tableHeaderCell({ align: node.align ?? null }, children) : nodes.tableCell({ align: node.align ?? null }, children);
+		case "text": return nodes.text(node.value);
+		case "ignored": throw new Error("Cannot reconstruct an unsupported editor node from Markdown");
+	}
+}
+
 //#endregion
 //#region src/converters/md-to-pm.ts
 /**
@@ -7862,658 +7412,7 @@ function getNodeBuildersForSchema(schema) {
 * inline-code characters survive verbatim.
 */
 function markdownToDoc(markdown, options = {}) {
-	const { nodes = getNodeBuilders(), frontmatter = false } = options;
-	let frontmatterBody;
-	let rest = markdown;
-	if (frontmatter) {
-		const [body, matchLength] = matchFrontmatter(markdown);
-		frontmatterBody = body;
-		if (matchLength) rest = markdown.slice(matchLength);
-	}
-	const blocks = collectBlocks(nodes, gfmBlockOnlyParser.parse(rest).cursor(), rest, 0, rest !== markdown);
-	return nodes.doc(frontmatterBody === void 0 ? {} : { frontmatter: frontmatterBody }, blocks);
-}
-/**
-* Matches a leading YAML frontmatter block: a `---` fence at offset 0, a body,
-* and a closing `---` fence, each fence being exactly three dashes followed by
-* optional spaces or tabs. Returns the body (the lines between the fences,
-* joined by `\n`, without a trailing newline) and the length of the matched
-* region, or undefined when there is no terminated frontmatter block (a lone `---`
-* with no closing fence stays a thematic break).
-*/
-const FRONTMATTER_RE = /^---[ \t]*\r?\n([\s\S]*?\n)?---[ \t]*(?:\r?\n|$)/;
-function matchFrontmatter(markdown) {
-	const match = FRONTMATTER_RE.exec(markdown);
-	if (!match) return [];
-	return [(match[1] ?? "").replace(/\r?\n$/, ""), match[0].length];
-}
-/**
-* Walk the document's children, converting each block-level child and
-* flattening any node converter that returns multiple siblings (lists are the
-* main case). Blank lines before the first block and after the last one are
-* content too, one empty paragraph each; when a frontmatter block was peeled
-* off ahead of `text`, the first leading blank line is that block's separator.
-*/
-function collectBlocks(nodes, cursor, text, column, afterFrontmatter) {
-	const out = [];
-	if (!cursor.firstChild()) {
-		appendEmptyParagraphs(out, nodes, Math.max(1, countNewlines(text, 0, text.length)));
-		return out;
-	}
-	appendEmptyParagraphs(out, nodes, countNewlines(text, 0, cursor.from) - (afterFrontmatter ? 1 : 0));
-	let previousTo;
-	do {
-		if (previousTo != null) appendGapParagraphs(out, nodes, text, previousTo, cursor.from);
-		previousTo = cursor.to;
-		appendBlocks(out, nodes, convertBlock(nodes, cursor, text, column));
-	} while (cursor.nextSibling());
-	cursor.parent();
-	const end = text.endsWith("\n") ? text.length - 1 : text.length;
-	appendEmptyParagraphs(out, nodes, countNewlines(text, previousTo, end));
-	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
-* (indent, blockquote `>`), so counting newlines is enough - the gap has K+1
-* of them (the previous block's own terminator plus one per blank line).
-*/
-function appendGapParagraphs(out, nodes, text, gapFrom, gapTo) {
-	appendEmptyParagraphs(out, nodes, countNewlines(text, gapFrom, gapTo) - 2);
-}
-function appendEmptyParagraphs(out, nodes, count) {
-	for (let i = 0; i < count; i++) out.push(nodes.paragraph());
-}
-function countNewlines(text, from, to) {
-	let count = 0;
-	for (let i = from; i < to; i++) if (text.charCodeAt(i) === 10) count++;
-	return count;
-}
-function convertBlock(nodes, cursor, text, column) {
-	switch (cursor.type.id) {
-		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, column)];
-		case LEZER_NODE_IDS.Blockquote: return [convertBlockquote(nodes, cursor, text)];
-		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)];
-		case LEZER_NODE_IDS.HorizontalRule: {
-			const marker = text.slice(cursor.from, cursor.to).trimEnd();
-			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, 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, column)];
-	}
-}
-function convertHeading(nodes, cursor, text, column, level, isSetext) {
-	const headingFrom = cursor.from;
-	let contentStart = cursor.from;
-	let contentEnd = cursor.to;
-	let trailingMarkFrom = -1;
-	let trailingMarkTo = -1;
-	if (cursor.firstChild()) {
-		if (cursor.type.id === LEZER_NODE_IDS.HeaderMark && cursor.from === headingFrom) contentStart = cursor.to;
-		let lastId = -1;
-		let lastFrom = -1;
-		let lastTo = -1;
-		do {
-			lastId = cursor.type.id;
-			lastFrom = cursor.from;
-			lastTo = cursor.to;
-		} while (cursor.nextSibling());
-		if (lastId === LEZER_NODE_IDS.HeaderMark && lastFrom > contentStart) {
-			contentEnd = isSetext ? text.lastIndexOf("\n", lastFrom - 1) : lastFrom;
-			trailingMarkFrom = lastFrom;
-			trailingMarkTo = lastTo;
-		}
-		cursor.parent();
-	}
-	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({
-		level,
-		setextUnderline,
-		closingHashes
-	}, 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) {
-	if (from < 0) return 0;
-	let count = 0;
-	for (let i = from; i < to; i++) {
-		const code = text.charCodeAt(i);
-		if (code === 61 || code === 45) count++;
-	}
-	return count;
-}
-/**
-* Count the `#` characters between `from` and `to`.
-*/
-function countHashChars(text, from, to) {
-	if (from < 0) return 0;
-	let count = 0;
-	for (let i = from; i < to; i++) if (text.charCodeAt(i) === 35) count++;
-	return count;
-}
-/**
-* The column at which content begins on the line containing `from` (i.e. the
-* enclosing container's content column). Columns count a tab as a CommonMark
-* tab stop of 4 (`4 - col % 4`), matching how lezer measures indentation.
-*/
-function measureContentColumn(text, from) {
-	const lineStart = text.lastIndexOf("\n", from - 1) + 1;
-	let col = 0;
-	for (let index = lineStart; index < from; index++) col += text.charCodeAt(index) === 9 ? 4 - col % 4 : 1;
-	return col;
-}
-/**
-* 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 (col < column) {
-		const code = line.charCodeAt(index);
-		if (code === 32) col += 1;
-		else if (code === 9) {
-			const width = 4 - col % 4;
-			if (col + width > column) break;
-			col += width;
-		} else return line;
-		index++;
-	}
-	return line.slice(index);
-}
-/**
-* Strip a leaf block's structural continuation indent.
-*
-* lezer keeps the indent of a multi-line block's continuation lines inside the
-* source span (its `scrub` pads each line's container prefix to equal-width
-* whitespace to preserve positions). CommonMark and lezer require every
-* continuation line to be indented to the same content `column`, which equals
-* the block's first-line column. The first line is already past its indent, so
-* only lines 2..n are dedented. Returns `content` untouched at column 0 (a
-* top-level block) or when there is no continuation line.
-*/
-function dedentContinuation(content, column) {
-	if (column === 0 || !content.includes("\n")) return content;
-	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
-* `whitespace: 'pre'` keeps a DOM re-read from folding it to a space.
-*/
-function buildParagraph(nodes, content, column) {
-	return nodes.paragraph(dedentContinuation(content, 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
-* (delimiters included) is kept verbatim on the node's `content` attribute;
-* 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, 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.
-*
-* Blank quote lines before the first block and after the last one are empty
-* paragraphs, like the document's own edges. The quote's range ends on its last
-* line rather than after it, so every newline in the trailing slice is a blank
-* line, and a quote made of markers only has one more line than newlines.
-*/
-function convertBlockquote(nodes, cursor, text) {
-	const content = [];
-	const from = cursor.from;
-	const to = cursor.to;
-	let previousTo;
-	if (cursor.firstChild()) {
-		do {
-			if (cursor.type.id === LEZER_NODE_IDS.QuoteMark) continue;
-			if (previousTo == null) appendEmptyParagraphs(content, nodes, countNewlines(text, from, cursor.from));
-			else appendGapParagraphs(content, nodes, text, previousTo, cursor.from);
-			previousTo = cursor.to;
-			appendBlocks(content, nodes, convertBlock(nodes, cursor, text, 0));
-		} while (cursor.nextSibling());
-		cursor.parent();
-	}
-	appendEmptyParagraphs(content, nodes, previousTo == null ? countNewlines(text, from, to) + 1 : countNewlines(text, previousTo, to));
-	return nodes.blockquote(content);
-}
-function convertList(nodes, cursor, text, column, kind) {
-	const out = [];
-	if (cursor.firstChild()) {
-		let previousContentEnd;
-		do {
-			if (cursor.type.id !== LEZER_NODE_IDS.ListItem) continue;
-			if (previousContentEnd != null) appendGapParagraphs(out, nodes, text, previousContentEnd, cursor.from);
-			const [item, contentEnd] = convertListItem(nodes, cursor, text, column, kind);
-			out.push(item);
-			previousContentEnd = contentEnd;
-		} while (cursor.nextSibling());
-		cursor.parent();
-	}
-	return out;
-}
-/**
-* The marker style at `cursor`, plus the start number of an ordered item.
-*/
-function readListMark(cursor, text, kind) {
-	if (kind === "ordered") {
-		const delimiterCode = text.charCodeAt(cursor.to - 1);
-		let marker;
-		if (delimiterCode === 41) marker = ")";
-		else if (delimiterCode === 46) marker = ".";
-		const number = Number.parseInt(text.slice(cursor.from, cursor.to), 10);
-		return {
-			marker,
-			order: Number.isFinite(number) ? number : 1
-		};
-	}
-	const code = text.charCodeAt(cursor.from);
-	return {
-		marker: code === 42 ? "*" : code === 43 ? "+" : "-",
-		order: void 0
-	};
-}
-/**
-* 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, column) {
-	let taskStart = cursor.from;
-	const taskEnd = cursor.to;
-	let checked = false;
-	let taskMarker;
-	if (cursor.firstChild()) {
-		if (cursor.type.id === LEZER_NODE_IDS.TaskMarker) {
-			const taskMarkerCode = text.charCodeAt(cursor.from + 1);
-			if (taskMarkerCode === 120) {
-				checked = true;
-				taskMarker = "x";
-			} else if (taskMarkerCode === 88) {
-				checked = true;
-				taskMarker = "X";
-			}
-			taskStart = cursor.to;
-		}
-		cursor.parent();
-	}
-	if (isSpaceChar(text.charCodeAt(taskStart))) taskStart += 1;
-	const paragraph = buildParagraph(nodes, readLeafText(cursor, text, taskStart, taskEnd), column);
-	return {
-		checked,
-		taskMarker,
-		paragraph
-	};
-}
-/**
-* The gap between a list marker ending at `markTo` and the item's first content
-* at `contentFrom`. Only content that opens on the marker's own line measures a
-* gap; an item whose content starts on the next line takes the canonical single
-* space, the column its own continuation lines are indented to. A gap of 5+ is
-* indented code (a different node, so the content's column would be the code
-* block's), and 1 is the canonical default; only a 2-4 space gap is a faithful,
-* content-preserving variation.
-*/
-function measureMarkerGap(text, contentFrom, markTo, markEndColumn) {
-	const gap = markTo != null && text.lastIndexOf("\n", contentFrom - 1) < markTo ? measureContentColumn(text, contentFrom) - markEndColumn : 1;
-	return gap >= 2 && gap <= 4 ? gap : 1;
-}
-function convertListItem(nodes, cursor, text, column, kind) {
-	const content = [];
-	let taskChecked;
-	let taskMarker;
-	let order;
-	let marker;
-	let markWidth = 1;
-	let markTo;
-	let markEndColumn = 0;
-	let markerGap = 1;
-	let contentColumn = column + markWidth + markerGap;
-	let previousTo;
-	if (cursor.firstChild()) {
-		do {
-			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 (previousTo == null) {
-				markerGap = measureMarkerGap(text, cursor.from, markTo, markEndColumn);
-				contentColumn = column + markWidth + markerGap;
-			} else appendGapParagraphs(content, nodes, text, previousTo, cursor.from);
-			previousTo = cursor.to;
-			if (kind === "bullet" && cursor.type.id === LEZER_NODE_IDS.Task) {
-				const task = convertTaskItem(nodes, cursor, text, contentColumn);
-				taskChecked = task.checked;
-				taskMarker = task.taskMarker;
-				content.push(task.paragraph);
-				continue;
-			}
-			appendBlocks(content, nodes, convertBlock(nodes, cursor, text, contentColumn));
-		} while (cursor.nextSibling());
-		cursor.parent();
-	}
-	const isTask = taskChecked != null;
-	const collapsed = !isTask && kind === "bullet" && marker === "+";
-	const attrs = {
-		kind: isTask ? "task" : kind,
-		order: kind === "ordered" ? order ?? 1 : null,
-		checked: taskChecked ?? false,
-		collapsed,
-		marker: collapsed ? null : marker,
-		taskMarker,
-		markerGap
-	};
-	return [nodes.list(attrs, content), previousTo ?? cursor.to];
-}
-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 {
-			code += uncoveredCode(text, pos, cursor.from);
-			pos = cursor.to;
-			switch (cursor.type.id) {
-				case LEZER_NODE_IDS.CodeMark:
-					if (sawOpeningMark) break;
-					sawOpeningMark = true;
-					if (text.charCodeAt(cursor.from) === 126) fenceStyle = "tilde";
-					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());
-		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,
-		fenceLength
-	}, 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.
-*/
-function convertBlockMath(nodes, cursor, text) {
-	let code = "";
-	if (cursor.firstChild()) {
-		do
-			if (cursor.type.id === LEZER_NODE_IDS.CodeText) code += text.slice(cursor.from, cursor.to);
-		while (cursor.nextSibling());
-		cursor.parent();
-	}
-	return nodes.codeBlock({
-		language: "math",
-		fenceStyle: "dollar",
-		fenceLength: null
-	}, code);
-}
-function convertTable(nodes, cursor, text) {
-	let aligns = [];
-	if (cursor.firstChild()) {
-		do
-			if (cursor.type.id === LEZER_NODE_IDS.TableDelimiter) aligns = parseDelimiterAligns(text.slice(cursor.from, cursor.to));
-		while (cursor.nextSibling());
-		cursor.parent();
-	}
-	const rows = [];
-	let columnCount = aligns.length;
-	if (cursor.firstChild()) {
-		do {
-			const id = cursor.type.id;
-			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.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) => {
-		const left = segment.startsWith(":");
-		const right = segment.endsWith(":");
-		if (left && right) return "center";
-		if (left) return "left";
-		if (right) return "right";
-		return null;
-	});
-}
-/**
-* 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) {
-	let end = text.length;
-	while (end > 0 && text.charCodeAt(end - 1) === 10) end--;
-	return text.slice(0, end);
-}
-/**
-* Classify how `markdown` survives the editor's parse-then-serialize round trip.
-*/
-function checkRoundTrip(markdown, options = {}) {
-	const { frontmatter } = options;
-	const doc = markdownToDoc(markdown, { frontmatter });
-	let serialized = docToMarkdown(doc, { frontmatter });
-	if (markdown === serialized) return "exact";
-	markdown = trimTrailingNewlines(markdown);
-	serialized = trimTrailingNewlines(serialized);
-	if (markdown === serialized) return "exact";
-	markdown = removeMarkdownStructure(markdown);
-	serialized = removeMarkdownStructure(serialized);
-	if (markdown === serialized) return "normalizing";
-	markdown = removeNumberZeroPrefix(markdown);
-	serialized = removeNumberZeroPrefix(serialized);
-	if (markdown === serialized) return "normalizing";
-	markdown = removeMathCodeBlockLanguage(markdown);
-	serialized = removeMathCodeBlockLanguage(serialized);
-	if (markdown === serialized) return "normalizing";
-	return "lossy";
-}
-function removeMarkdownStructure(markdown) {
-	return markdown.replaceAll(/[-+=_:|\\/[\]<>()`~$*#\s!]+/gu, "");
-}
-function removeNumberZeroPrefix(markdown) {
-	return markdown.replaceAll(/0+/gu, "");
-}
-function removeMathCodeBlockLanguage(markdown) {
-	return markdown.replaceAll(/math|latex/giu, "");
+	return astToDoc(parseMarkdownAst(markdown, options), options.nodes);
 }
 
 //#endregion
@@ -9176,4 +8075,4 @@ function getVirtualElementFromRange(view, range) {
 }
 
 //#endregion
-export { EDITOR_KEY_BINDINGS, Priority, buildFileMarkdown, checkRoundTrip, codeBlockLanguages, collectReferenceDefinitions, defaultResolveImageUrl, defaultResolveXPost, defaultResolveYouTubeVideo, defineBulletAfterHeading, defineCodeBlockPreviewPlugin, defineCodeBlockSyntaxHighlight, defineEditorExtension, defineEmbedPaste, defineExitBoundaryHandler, defineFileClickHandler, defineFilePaste, defineFileView, defineFollowLinkHandler, defineHTMLComment, defineImage, defineImageClickHandler, defineLinkClickHandler, defineLinkCommands, defineLinkEditKeymap, defineLinkHoverHandler, defineLinkPaste, defineMath, definePendingReplacementHandler, definePlaceholder, defineReadonly, defineSearchStatusHandler, defineSubstitution, defineTagClickHandler, defineViewAttributes, defineVirtualCaret, defineWikilinkClickHandler, defineWikilinkHoverHandler, defineWikilinkTrigger, defineXPostMediaClickHandler, defineYouTubeVideoClickHandler, dismissLinkHover, docToMarkdown, formatFileSize, formatSizedWikiEmbed, getCodeTokens, getEditorConfig, getFileKind, getIsComposing, getLinkText, getLinkUnitAt, getMarkBuilders, getPendingReplacement, getSearchStatus, getSelectedText, getTableColumnAlign, getTextblockDisplayText, getVirtualElementFromRange, inlineTextToMarkChunks, inlineTextToMarkChunksWithContext, insertLink, isCodeBlockPreviewHiddenDecoration, isLinkTextForHref, isMarkOfType, isModEvent, isNodeOfType, isReferenceDefinitionNode, isSelectionInTableCell, loadKaTeX, markdownToDoc, normalizeHref, parsePostEmbedSnapshot, parseWikiEmbed, removeLink, renderMathInto, updateEditorConfig, updateLink, wikiEmbedBasename, withPriority };
+export { EDITOR_KEY_BINDINGS, Priority, buildFileMarkdown, checkRoundTrip, codeBlockLanguages, collectReferenceDefinitions, defaultResolveImageUrl, defaultResolveXPost, defaultResolveYouTubeVideo, defineBulletAfterHeading, defineCodeBlockPreviewPlugin, defineCodeBlockSyntaxHighlight, defineEditorExtension, defineEmbedPaste, defineExitBoundaryHandler, defineFileClickHandler, defineFilePaste, defineFileView, defineFollowLinkHandler, defineHTMLComment, defineImage, defineImageClickHandler, defineLinkClickHandler, defineLinkCommands, defineLinkEditKeymap, defineLinkHoverHandler, defineLinkPaste, defineMath, definePendingReplacementHandler, definePlaceholder, defineReadonly, defineSearchStatusHandler, defineSingleParagraph, defineSubstitution, defineTagClickHandler, defineViewAttributes, defineVirtualCaret, defineWikilinkClickHandler, defineWikilinkHoverHandler, defineWikilinkTrigger, defineXPostMediaClickHandler, defineYouTubeVideoClickHandler, dismissLinkHover, docToMarkdown, docToParagraphMarkdown, formatFileSize, formatSizedWikiEmbed, getCodeTokens, getEditorConfig, getFileKind, getIsComposing, getLinkText, getLinkUnitAt, getMarkBuilders, getPendingReplacement, getSearchStatus, getSelectedText, getTableColumnAlign, getTextblockDisplayText, getVirtualElementFromRange, inlineTextToMarkChunks, inlineTextToMarkChunksWithContext, insertLink, isCodeBlockPreviewHiddenDecoration, isLinkTextForHref, isMarkOfType, isModEvent, isNodeOfType, isReferenceDefinitionNode, isSelectionInTableCell, loadKaTeX, markdownToDoc, normalizeHref, paragraphMarkdownToDoc, parsePostEmbedSnapshot, parseWikiEmbed, removeLink, renderMathInto, updateEditorConfig, updateLink, wikiEmbedBasename, withPriority };