@segnavia/markdown-editor 0.44.0 → 0.46.0

package/dist/markdown-rich-extensions.js

@@ -1,11 +1,180 @@
 import { LockedBlock } from "./markdown-rich-locked.js";
-import { Extension, getSchema } from "@tiptap/core";
+import { rawInline } from "./markdown-rich-raw-inline.js";
+import { listSourceAttributes, sourceFormStarterExtensions, sourceListAttrs, tableRowSourceAttributes, tableSourceExtension, taskItemSourceExtension } from "./markdown-rich-source-forms.js";
+import { Extension, getExtensionField, getSchema } from "@tiptap/core";
 import Image from "@tiptap/extension-image";
-import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { BulletList, OrderedList, TaskItem, TaskList } from "@tiptap/extension-list";
 import { TableKit } from "@tiptap/extension-table";
 import { MarkdownManager } from "@tiptap/markdown";
 import StarterKit from "@tiptap/starter-kit";
+import { Marked } from "marked";
 //#region src/markdown-rich-extensions.ts
+const listAttributes = { loose: {
+	default: false,
+	parseHTML: (element) => element.getAttribute("data-loose") === "true",
+	renderHTML: (attrs) => attrs.loose ? { "data-loose": "true" } : {}
+} };
+const listSeparator = (node) => node.attrs?.loose ? "\n\n" : "\n";
+const listItemPattern = /^(\s*)([-+*]|\d+[.)])(\s+)(?:\[[ xX]\]\s+)?/;
+const indentWidth = (value) => value.replace(/\t/g, "    ").length;
+const lineIndent = (line) => indentWidth(/^\s*/.exec(line)?.[0] ?? "");
+const itemContentIndent = (match) => indentWidth(match[1] ?? "") + (match[2]?.length ?? 0) + indentWidth(match[3] ?? "");
+function updateListContext(match, indent, state) {
+	if (match && indent === state.baseIndent) {
+		state.contentIndent = itemContentIndent(match);
+		state.nestedIndent = void 0;
+	} else if (match && indent >= state.contentIndent && state.nestedIndent === void 0) state.nestedIndent = indent;
+}
+function consumeFence(line, indent, state) {
+	const match = /^(\s*)(`{3,}|~{3,})/.exec(line);
+	if (!match || indent < state.contentIndent || state.nestedIndent !== void 0) return false;
+	const marker = match[2]?.[0] ?? "";
+	const length = match[2]?.length ?? 0;
+	if (!state.fence) state.fence = {
+		marker,
+		length,
+		indent
+	};
+	else if (marker === state.fence.marker && length >= state.fence.length && indent <= state.fence.indent) state.fence = void 0;
+	return true;
+}
+function nextNonblank(lines, index) {
+	return lines.slice(index + 1).find((line) => !/^\s*$/.test(line));
+}
+function blankLineIsLoose(lines, index, state) {
+	const nextLine = nextNonblank(lines, index);
+	if (nextLine === void 0) return false;
+	const nextItem = listItemPattern.exec(nextLine);
+	const nextIndent = lineIndent(nextLine);
+	if (nextItem && nextIndent === state.baseIndent) return true;
+	if (state.nestedIndent !== void 0) {
+		if (nextIndent > state.nestedIndent || nextItem && nextIndent === state.nestedIndent) return false;
+		state.nestedIndent = void 0;
+	}
+	return nextIndent >= state.contentIndent;
+}
+function listLineIsLoose(lines, index, state) {
+	const line = lines[index] ?? "";
+	const match = listItemPattern.exec(line);
+	const indent = lineIndent(line);
+	updateListContext(match, indent, state);
+	if (consumeFence(line, indent, state)) return false;
+	return /^\s*$/.test(line) && state.fence === void 0 && blankLineIsLoose(lines, index, state);
+}
+function listIsLoose(raw) {
+	const lines = raw.split("\n");
+	const firstMatch = listItemPattern.exec(lines.find((line) => listItemPattern.test(line)) ?? "");
+	if (!firstMatch) return false;
+	const state = {
+		baseIndent: indentWidth(firstMatch[1] ?? ""),
+		contentIndent: itemContentIndent(firstMatch)
+	};
+	for (let index = 0; index < lines.length; index++) if (listLineIsLoose(lines, index, state)) return true;
+	return false;
+}
+const LooseBulletList = BulletList.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			...listAttributes,
+			...listSourceAttributes
+		};
+	},
+	parseMarkdown(token, helpers) {
+		if (token.type !== "list" || token.ordered) return [];
+		return {
+			type: "bulletList",
+			attrs: {
+				loose: listIsLoose(token.raw ?? ""),
+				...sourceListAttrs(token.raw ?? "")
+			},
+			content: helpers.parseChildren(token.items ?? [])
+		};
+	},
+	renderMarkdown(node, helpers) {
+		return node.content ? helpers.renderChildren(node.content, listSeparator(node)) : "";
+	}
+});
+const LooseOrderedList = OrderedList.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			...listAttributes,
+			...listSourceAttributes
+		};
+	},
+	parseMarkdown(token, helpers) {
+		if (token.type !== "list" || !token.ordered) return [];
+		return {
+			type: "orderedList",
+			attrs: {
+				start: token.start || 1,
+				type: token.typeMarker ?? null,
+				loose: listIsLoose(token.raw ?? ""),
+				...sourceListAttrs(token.raw ?? "", true)
+			},
+			content: helpers.parseChildren(token.items ?? [])
+		};
+	},
+	renderMarkdown(node, helpers) {
+		if (!node.content) return "";
+		const recorded = node.attrs?.sourceOrderedNumbers;
+		const keepsWrittenNumbers = Array.isArray(recorded) && recorded.length === node.content.length && node.content.every((item, index) => item.attrs?.sourceNumber === recorded[index]);
+		const content = node.content.map((item) => ({
+			...item,
+			attrs: {
+				...item.attrs,
+				sourceKeepWrittenNumbers: keepsWrittenNumbers
+			}
+		}));
+		return helpers.renderChildren(content, listSeparator(node));
+	}
+});
+const LooseTaskList = TaskList.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			...listAttributes,
+			...listSourceAttributes
+		};
+	},
+	parseMarkdown(token, helpers) {
+		return helpers.createNode("taskList", {
+			loose: listIsLoose(token.raw ?? ""),
+			...sourceListAttrs(token.raw ?? "")
+		}, helpers.parseChildren(token.items ?? []));
+	},
+	renderMarkdown(node, helpers) {
+		return node.content ? helpers.renderChildren(node.content, listSeparator(node)) : "";
+	},
+	markdownTokenizer: {
+		name: "taskList",
+		level: "block",
+		start: (src) => src.search(/^\s*[-+*]\s+\[[ xX]\]\s+/m),
+		tokenize(src, _tokens, lexer) {
+			const token = new Marked().lexer(src)[0];
+			if (token?.type !== "list" || token.ordered || !token.items?.every((item) => item.task)) return void 0;
+			const items = token.items.map((item) => {
+				const lines = item.text.split("\n");
+				const mainContent = lines.shift() ?? "";
+				const nested = lines.join("\n").trim();
+				return {
+					type: "taskItem",
+					raw: item.raw,
+					checked: item.checked ?? false,
+					text: mainContent,
+					tokens: lexer.inlineTokens(mainContent),
+					nestedTokens: nested ? lexer.blockTokens(`${nested}\n`) : []
+				};
+			});
+			return {
+				type: "taskList",
+				raw: token.raw,
+				items
+			};
+		}
+	}
+});
 const directionalBlocks = Extension.create({
 	name: "directionalBlocks",
 	addGlobalAttributes() {
@@ -30,32 +199,66 @@ const directionalBlocks = Extension.create({
 		}];
 	}
 });
-function richExtensions() {
+function richExtensions(definitionLabels = /* @__PURE__ */ new Set()) {
+	const starter = StarterKit.configure({
+		trailingNode: false,
+		link: { openOnClick: false },
+		bulletList: false,
+		orderedList: false
+	});
+	const starterChildren = getExtensionField(starter, "addExtensions", {
+		name: starter.name,
+		options: starter.options,
+		storage: starter.storage
+	})?.() ?? [];
+	const tables = TableKit.configure();
+	const tableChildren = getExtensionField(tables, "addExtensions", {
+		name: tables.name,
+		options: tables.options,
+		storage: tables.storage
+	})?.() ?? [];
 	return [
-		StarterKit.configure({
-			trailingNode: false,
-			link: { openOnClick: false }
+		...sourceFormStarterExtensions(starterChildren),
+		LooseBulletList,
+		LooseOrderedList,
+		...tableChildren.map((extension) => {
+			if (extension.name === "tableRow") return extension.extend({ addAttributes() {
+				return {
+					...this.parent?.(),
+					...tableRowSourceAttributes
+				};
+			} });
+			return tableSourceExtension(extension);
 		}),
-		TableKit,
-		TaskList,
-		TaskItem.configure({ nested: true }),
+		LooseTaskList,
+		taskItemSourceExtension(TaskItem.configure({ nested: true })),
 		Image.configure({ inline: true }),
 		directionalBlocks,
-		LockedBlock
+		LockedBlock,
+		rawInline(definitionLabels)
 	];
 }
 let manager;
+const isolatedMarked = () => new Marked();
 function richMarkdownManager() {
 	manager ??= new MarkdownManager({
+		marked: isolatedMarked(),
 		extensions: richExtensions(),
 		markedOptions: { gfm: true }
 	});
 	return manager;
 }
+function scopedRichMarkdownManager(definitionLabels) {
+	return new MarkdownManager({
+		marked: isolatedMarked(),
+		extensions: richExtensions(definitionLabels),
+		markedOptions: { gfm: true }
+	});
+}
 let schema;
 function richSchema() {
 	schema ??= getSchema(richExtensions());
 	return schema;
 }
 //#endregion
-export { richExtensions, richMarkdownManager, richSchema };
+export { listIsLoose, richExtensions, richMarkdownManager, richSchema, scopedRichMarkdownManager };

package/dist/markdown-rich-locked.js

@@ -2,6 +2,26 @@ import { isDiagramFence, isGithubAlertBlock } from "@segnavia/html";
 import { Node } from "@tiptap/core";
 //#region src/markdown-rich-locked.ts
 const LOCKED_BLOCK_NAME = "lockedBlock";
+const FOOTNOTE_OPENING = /^ {0,3}\[\^/m;
+function matchFootnoteDefinition(src) {
+	const opening = FOOTNOTE_OPENING.exec(src);
+	if (opening?.index !== 0) return void 0;
+	const rest = /^[^\]\n]+\]:[^\n]*(?:\n|$)/.exec(src.slice(opening[0].length))?.[0];
+	const first = rest === void 0 ? void 0 : opening[0] + rest;
+	if (!first) return void 0;
+	let end = first.length;
+	while (end < src.length) {
+		const continuation = /^(?: {4,}|\t)[^\n]*(?:\n|$)/.exec(src.slice(end))?.[0];
+		if (continuation) {
+			end += continuation.length;
+			continue;
+		}
+		const blanks = /^(?:[ \t]*\n)+/.exec(src.slice(end))?.[0];
+		if (!blanks || !/^(?: {4,}|\t)\S/.test(src.slice(end + blanks.length))) break;
+		end += blanks.length;
+	}
+	return src.slice(0, end);
+}
 function lockedFenceLabel(lockedFences, language) {
 	return lockedFences[language?.toLowerCase() ?? ""];
 }
@@ -27,7 +47,7 @@ function isHtmlComment(raw) {
 	return /^<!--[\s\S]*-->$/.test(raw.replace(/\n+$/, ""));
 }
 function isLockedToken(token, lockedFences = {}) {
-	if (token.type === "frontmatter" || token.type === "directive") return true;
+	if (token.type === "frontmatter" || token.type === "directive" || token.type === "footnoteDefinition") return true;
 	if (token.type === "code" && (isDiagramFence(token.lang) || Boolean(lockedFenceLabel(lockedFences, token.lang)))) return true;
 	if (token.type === "blockquote" && isGithubAlertBlock(token.raw)) return true;
 	return token.type === "html" && !isHtmlComment(token.raw);
@@ -75,7 +95,8 @@ const LockedBlock = Node.create({
 		name: "lockedFence",
 		level: "block",
 		start(src) {
-			return src.startsWith("---") || src.startsWith(":::") ? 0 : -1;
+			if (src.startsWith("---") || src.startsWith(":::")) return 0;
+			return FOOTNOTE_OPENING.exec(src)?.index ?? -1;
 		},
 		tokenize(src, tokens) {
 			if (tokens.length === 0) {
@@ -85,6 +106,11 @@ const LockedBlock = Node.create({
 					raw: frontmatter
 				};
 			}
+			const footnote = matchFootnoteDefinition(src);
+			if (footnote) return {
+				type: "footnoteDefinition",
+				raw: footnote
+			};
 			const directive = matchDirectiveContainer(src);
 			return directive ? {
 				type: "directive",

package/dist/markdown-rich-raw-inline.js

@@ -0,0 +1,123 @@
+import { Node } from "@tiptap/core";
+//#region src/markdown-rich-raw-inline.ts
+const RAW_INLINE_NAME = "rawInline";
+const RAW_INLINE_ATTRIBUTE = "data-raw-inline";
+const RAW_INLINE_SOURCE_ATTRIBUTE = "data-raw-source";
+const RAW_INLINE_DISPLAY_ATTRIBUTE = "data-raw-display";
+const ASCII_PUNCTUATION = String.raw`[!-/:-@\[-` + "{-~]";
+const escapePattern = new RegExp(`^\\\\${ASCII_PUNCTUATION}`);
+const entityPattern = /^&(?:[A-Za-z][A-Za-z0-9]+|#[0-9]+|#[xX][0-9A-Fa-f]+);/;
+const footnotePattern = /^\[\^[^\]\n]+\]/;
+const inlineHtmlPattern = /^(?:<!--[\s\S]*?-->|<\/?[A-Za-z](?:[^<>"']|"[^"]*"|'[^']*')*?>)/;
+const bracketContent = String.raw`(?:\\.|[^\[\]\\]|\[(?:\\.|[^\[\]\\])*\])*`;
+const referencePattern = new RegExp(`^(!?)\\[(${bracketContent})\\](?:\\[(${bracketContent})\\])?`);
+function normalizeReferenceLabel(label) {
+	return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function referenceSource(src, labels) {
+	const match = referencePattern.exec(src);
+	if (!match) return void 0;
+	const raw = match[0];
+	const firstLabel = match[2] ?? "";
+	const secondLabel = match[3];
+	if (secondLabel === void 0 && src[raw.length] === "(") return void 0;
+	const label = secondLabel === void 0 || secondLabel === "" ? firstLabel : secondLabel;
+	return labels.has(normalizeReferenceLabel(label)) ? raw : void 0;
+}
+function rawSource(src, labels) {
+	const escaped = escapePattern.exec(src)?.[0];
+	if (escaped) return {
+		source: escaped,
+		display: escaped.slice(1)
+	};
+	const entity = entityPattern.exec(src)?.[0];
+	if (entity) return {
+		source: entity,
+		display: entity
+	};
+	const footnote = footnotePattern.exec(src)?.[0];
+	if (footnote) return {
+		source: footnote,
+		display: footnote
+	};
+	const reference = referenceSource(src, labels);
+	if (reference) return {
+		source: reference,
+		display: reference
+	};
+	const html = inlineHtmlPattern.exec(src)?.[0];
+	return html && (!html.startsWith("<!") ? !/\n[ \t]*\n/.test(html) : true) ? {
+		source: html,
+		display: html
+	} : void 0;
+}
+function rawInline(labels = /* @__PURE__ */ new Set()) {
+	return Node.create({
+		name: RAW_INLINE_NAME,
+		group: "inline",
+		inline: true,
+		atom: true,
+		selectable: true,
+		draggable: false,
+		addAttributes() {
+			return {
+				source: {
+					default: "",
+					parseHTML: (element) => element.getAttribute("data-raw-source") ?? "",
+					renderHTML: (attrs) => ({ [RAW_INLINE_SOURCE_ATTRIBUTE]: attrs.source })
+				},
+				display: {
+					default: "",
+					parseHTML: (element) => element.getAttribute("data-raw-display") ?? "",
+					renderHTML: (attrs) => ({ [RAW_INLINE_DISPLAY_ATTRIBUTE]: attrs.display })
+				}
+			};
+		},
+		parseHTML() {
+			return [{ tag: `span[${RAW_INLINE_ATTRIBUTE}]` }];
+		},
+		renderHTML({ HTMLAttributes }) {
+			return ["span", {
+				...HTMLAttributes,
+				[RAW_INLINE_ATTRIBUTE]: "",
+				dir: "auto"
+			}];
+		},
+		parseMarkdown(token) {
+			return {
+				type: RAW_INLINE_NAME,
+				attrs: {
+					source: token.source,
+					display: token.display
+				}
+			};
+		},
+		renderMarkdown(node) {
+			return typeof node.attrs?.source === "string" ? node.attrs.source : "";
+		},
+		markdownTokenizer: {
+			name: RAW_INLINE_NAME,
+			level: "inline",
+			start(src) {
+				const candidates = labels.size ? /\\|&|!?\[|</g : /\\|&|\[\^|</g;
+				for (const match of src.matchAll(candidates)) {
+					if (match.index === void 0) continue;
+					if (rawSource(src.slice(match.index), labels)) return match.index;
+				}
+				return -1;
+			},
+			tokenize(src) {
+				const raw = rawSource(src, labels);
+				return raw ? {
+					type: RAW_INLINE_NAME,
+					raw: raw.source,
+					source: raw.source,
+					display: raw.display
+				} : void 0;
+			}
+		}
+	});
+}
+const RawInline = rawInline();
+//#endregion
+export { RAW_INLINE_ATTRIBUTE, RAW_INLINE_DISPLAY_ATTRIBUTE, RAW_INLINE_NAME, RAW_INLINE_SOURCE_ATTRIBUTE, RawInline, normalizeReferenceLabel, rawInline };

package/dist/markdown-rich-save.js

@@ -1,5 +1,7 @@
 import { isLockedToken, isSilentToken, lockedFenceLabel, lockedNode } from "./markdown-rich-locked.js";
-import { richMarkdownManager, richSchema } from "./markdown-rich-extensions.js";
+import { normalizeReferenceLabel } from "./markdown-rich-raw-inline.js";
+import { meaningfulAttributes, withoutRecordedSourceAttrs } from "./markdown-rich-source-attrs.js";
+import { richMarkdownManager, richSchema, scopedRichMarkdownManager } from "./markdown-rich-extensions.js";
 import { Node } from "@tiptap/pm/model";
 //#region src/markdown-rich-save.ts
 let cachedOriginal;
@@ -39,15 +41,24 @@ const dropTrailingEmptyParagraph = (nodes) => {
 	return last && isEmptyParagraph(last) ? nodes.slice(0, -1) : nodes;
 };
 const restoreAmpersands = (markdown) => markdown.replace(/&(?![a-zA-Z][a-zA-Z0-9]*;)/g, "&");
-function parseBlock(token, raw, lockedFences) {
+function parseBlock(manager, token, raw, lockedFences) {
 	if (isSilentToken(token)) return [];
 	if (isLockedToken(token, lockedFences)) return [lockedNode(raw, lockedFenceLabel(lockedFences, token.lang))];
-	const parsed = richMarkdownManager().parse(raw);
+	const parsed = manager.parse(raw);
 	return Node.fromJSON(richSchema(), parsed).toJSON().content ?? [];
 }
-function blocks(markdown, lockedFences = {}) {
+function definitionLabels(tokens) {
+	const labels = /* @__PURE__ */ new Set();
+	for (const token of tokens) {
+		const definition = token.type === "def" ? /^ {0,3}\[([^\]]+)\]:/.exec(token.raw)?.[1] : void 0;
+		if (definition !== void 0) labels.add(normalizeReferenceLabel(definition));
+	}
+	return labels;
+}
+function blocks(markdown, labels, lockedFences = {}) {
 	const out = [];
-	const tokens = richMarkdownManager().instance.lexer(markdown);
+	const manager = scopedRichMarkdownManager(labels);
+	const tokens = manager.instance.lexer(markdown);
 	let at = 0;
 	let prevEnd = 0;
 	for (const token of tokens) {
@@ -55,7 +66,7 @@ function blocks(markdown, lockedFences = {}) {
 		at += token.raw.length;
 		if (token.type === "space") continue;
 		const raw = token.raw.replace(/\n+$/, "");
-		const nodes = parseBlock(token, raw, lockedFences);
+		const nodes = parseBlock(manager, token, raw, lockedFences);
 		out.push({
 			raw,
 			sep: markdown.slice(prevEnd, start),
@@ -73,7 +84,9 @@ function originalEntry(original, options) {
 	const nextFencesKey = fencesKey(options.lockedFences);
 	if (cachedOriginal?.original === original && cachedOriginal.fencesKey === nextFencesKey && cachedOriginal.bodyTransform === options.bodyTransform) return cachedOriginal;
 	const split = options.bodyTransform?.split(original);
-	const editableBlocks = blocks(split?.editable ?? original, options.lockedFences);
+	const editable = split?.editable ?? original;
+	const labels = definitionLabels(richMarkdownManager().instance.lexer(editable));
+	const editableBlocks = blocks(editable, labels, options.lockedFences);
 	const nodes = editableBlocks.flatMap((block) => block.nodes);
 	const keys = editableBlocks.flatMap((block) => block.keys);
 	const indicesByFirstKey = /* @__PURE__ */ new Map();
@@ -92,7 +105,8 @@ function originalEntry(original, options) {
 		blocks: editableBlocks,
 		nodes,
 		keys,
-		indicesByFirstKey
+		indicesByFirstKey,
+		definitionLabels: labels
 	};
 	return cachedOriginal;
 }
@@ -106,11 +120,115 @@ function firstAtOrAfter(indices, minimum) {
 	}
 	return indices[low] ?? -1;
 }
-function serializeNodes(nodes) {
-	return restoreAmpersands(richMarkdownManager().serialize({
+function semantic(value, attrNodeType) {
+	if (Array.isArray(value)) {
+		const values = value.map((item) => semantic(item));
+		const merged = [];
+		for (const item of values) {
+			const previous = merged.at(-1);
+			if (isRecord(item) && item.type === "text" && typeof item.text === "string" && isRecord(previous) && previous.type === "text" && typeof previous.text === "string" && JSON.stringify(previous.marks) === JSON.stringify(item.marks)) previous.text += item.text;
+			else merged.push(item);
+		}
+		return merged;
+	}
+	if (!isRecord(value)) return value;
+	if (value.type === "rawInline" && isRecord(value.attrs) && /^\\(?:\[|\])$/.test(String(value.attrs.source))) return {
+		type: "text",
+		text: value.attrs.display
+	};
+	return meaningfulAttributes(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, semantic(item, key === "attrs" ? value.type : void 0)])), {}, attrNodeType);
+}
+function sameDocument(markdown, nodes, manager) {
+	const parsed = Node.fromJSON(richSchema(), manager.parse(markdown)).toJSON().content ?? [];
+	return JSON.stringify(semantic(parsed)) === JSON.stringify(semantic(nodes));
+}
+function chooseBracketEscapes(markdown, readsSame, dangerousOffsets) {
+	if (!/\\(?:\[|\])/.test(markdown)) return {
+		markdown,
+		same: readsSame(markdown)
+	};
+	const all = markdown.replace(/\\(\[|\])/g, "$1");
+	if (readsSame(all)) return {
+		markdown: all,
+		same: true
+	};
+	let selective = all;
+	for (const offset of dangerousOffsets(all).sort((left, right) => right - left)) selective = `${selective.slice(0, offset)}\\${selective.slice(offset)}`;
+	if (selective !== all && readsSame(selective)) return {
+		markdown: selective,
+		same: true
+	};
+	return {
+		markdown,
+		same: readsSame(markdown)
+	};
+}
+function dangerousBracketOffsets(markdown, manager) {
+	const sources = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [manager.instance.lexer(markdown)];
+	while (pending.length) {
+		const value = pending.pop();
+		if (!value || typeof value !== "object" || seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			pending.push(...[...value].reverse());
+			continue;
+		}
+		const token = value;
+		const raw = typeof token.raw === "string" ? token.raw : "";
+		const type = token.type;
+		const source = typeof token.source === "string" ? token.source : raw;
+		if ((type === "link" || type === "image" || type === "rawInline") && source.includes("[")) {
+			sources.push(raw || source);
+			continue;
+		}
+		const children = Object.entries(token).filter(([key]) => key !== "raw" && key !== "text" && key !== "source").map(([, child]) => child).reverse();
+		pending.push(...children);
+	}
+	const offsets = [];
+	let cursor = 0;
+	for (const source of sources) {
+		const at = markdown.indexOf(source, cursor);
+		const bracket = source.indexOf("[");
+		if (at < 0 || bracket < 0) continue;
+		offsets.push(at + bracket);
+		cursor = at + source.length;
+	}
+	return offsets;
+}
+function serializeNodes(nodes, definitionLabels) {
+	const json = nodes.map(asJson);
+	let marker = "raw-inline-amp";
+	const source = JSON.stringify(json);
+	while (source.includes(marker)) marker += "-";
+	const openMarker = `${marker}open`;
+	const closeMarker = `${marker}close`;
+	let textMarkerCode = 57600;
+	while (source.includes(String.fromCodePoint(textMarkerCode)) || source.includes(String.fromCodePoint(textMarkerCode + 1))) textMarkerCode += 2;
+	const textOpenMarker = String.fromCodePoint(textMarkerCode);
+	const textCloseMarker = String.fromCodePoint(textMarkerCode + 1);
+	const restoreProtected = (value) => value.replaceAll(openMarker, "\\[").replaceAll(closeMarker, "\\]").replaceAll(marker, "&");
+	const protect = (node) => ({
+		...node,
+		text: node.type === "text" && typeof node.text === "string" && !node.marks?.some((mark) => mark.type === "link") ? node.text.replaceAll("[", textOpenMarker).replaceAll("]", textCloseMarker) : node.text,
+		attrs: node.type === "rawInline" && typeof node.attrs?.source === "string" ? {
+			...node.attrs,
+			source: node.attrs.source.replaceAll("&", marker).replaceAll("\\[", openMarker).replaceAll("\\]", closeMarker)
+		} : node.attrs,
+		content: node.content?.map(protect)
+	});
+	const manager = scopedRichMarkdownManager(definitionLabels);
+	const render = (content) => restoreAmpersands(manager.serialize({
 		type: "doc",
-		content: nodes.map(asJson)
-	}).trim());
+		content: content.map(protect)
+	}).replace(/^\n+|\n+$/g, "")).replaceAll(textOpenMarker, "\\[").replaceAll(textCloseMarker, "\\]");
+	const meaningful = (candidate) => {
+		return chooseBracketEscapes(candidate, (value) => sameDocument(restoreProtected(value), json, manager), (value) => dangerousBracketOffsets(value, manager));
+	};
+	let result = meaningful(render(json));
+	if (!result.same) result = meaningful(render(json.map(withoutRecordedSourceAttrs)));
+	return restoreProtected(result.markdown);
 }
 function matchingBlockIndex(entry, keys, keyIndex, blockIndex) {
 	const currentKey = keys[keyIndex];
@@ -133,7 +251,7 @@ function stitch(entry, edited, keys) {
 	const pending = [];
 	const emitNew = () => {
 		if (!pending.length) return;
-		out += (out ? "\n\n" : bs[blockIndex]?.sep ?? "") + serializeNodes(pending.splice(0));
+		out += (out ? "\n\n" : bs[blockIndex]?.sep ?? "") + serializeNodes(pending.splice(0), entry.definitionLabels);
 		last = -1;
 	};
 	const emitOld = (hit) => {
@@ -179,4 +297,4 @@ function saveRichDocument(original, edited, options = {}) {
 	return entry.split && options.bodyTransform ? options.bodyTransform.join(saved, entry.split.retained) : saved;
 }
 //#endregion
-export { parseRichDocument, saveRichDocument };
+export { chooseBracketEscapes, parseRichDocument, saveRichDocument };

package/dist/markdown-rich-source-attrs.js

@@ -0,0 +1,32 @@
+import "./markdown-rich-raw-inline.js";
+//#region src/markdown-rich-source-attrs.ts
+function isRecordedSourceAttr(key, nodeType) {
+	return key.startsWith("source") && !(nodeType === "rawInline" && key === "source");
+}
+function meaningfulAttributes(value, options = {}, attrNodeType) {
+	if (Array.isArray(value)) return value.map((item) => meaningfulAttributes(item, options));
+	if (!value || typeof value !== "object") return value;
+	const record = value;
+	const nodeType = record.type ?? attrNodeType;
+	const out = {};
+	for (const [key, item] of Object.entries(record)) {
+		if (key === "dir" || isRecordedSourceAttr(key, nodeType) || item === null || item === void 0) continue;
+		if (!options.keepEmptyArrays && Array.isArray(item) && item.length === 0) continue;
+		if (options.omitDefaultTableSpans && (key === "colspan" || key === "rowspan") && item === 1) continue;
+		const next = meaningfulAttributes(item, options, key === "attrs" ? nodeType : void 0);
+		if (next && typeof next === "object" && !Array.isArray(next) && Object.keys(next).length === 0) continue;
+		out[key] = next;
+	}
+	return out;
+}
+function withoutRecordedSourceAttrs(value) {
+	const attrs = value.attrs ? Object.fromEntries(Object.entries(value.attrs).filter(([key]) => !isRecordedSourceAttr(key, value.type))) : value.attrs;
+	return {
+		...value,
+		attrs,
+		marks: value.marks?.map((mark) => withoutRecordedSourceAttrs(mark)),
+		content: value.content?.map(withoutRecordedSourceAttrs)
+	};
+}
+//#endregion
+export { isRecordedSourceAttr, meaningfulAttributes, withoutRecordedSourceAttrs };