@portabletext/markdown 2.1.0 → 2.2.0

package/dist/index.js

@@ -1,11 +1,36 @@
+import { cleanupEfficiency, makeDiff } from "@sanity/diff-match-patch";
 import { compileSchema, defineSchema, isSpan, isTextBlock, isTypedObject } from "@portabletext/schema";
 import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextSpan, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
 import LinkifyIt from "linkify-it";
-import { alert } from "@mdit/plugin-alert";
 import markdownit from "markdown-it";
+import { alert } from "@mdit/plugin-alert";
 function defaultKeyGenerator() {
 	return randomKey(12);
 }
+/**
+* Wraps a caller-supplied key generator so one conversion can never
+* mint the same key twice. Keys attach content to its identity at
+* creation time (a span's `marks` entry points at the mark definition
+* minted with the same key), so a generator that repeats a key does
+* not just violate sibling uniqueness, it makes ownership ambiguous in
+* a way no later pass can repair: two definitions sharing a key leave
+* every referencing span attributable to either. Bounded retries, then
+* deterministic suffixing, mirroring how sibling-uniqueness repair
+* treats a generator that keeps returning claimed keys.
+*/
+function uniqueKeyGenerator(generator) {
+	let mintedKeys = /* @__PURE__ */ new Set();
+	return () => {
+		let candidate = generator();
+		for (let attempt = 0; attempt < 3 && mintedKeys.has(candidate); attempt++) candidate = generator();
+		if (mintedKeys.has(candidate)) {
+			let base = candidate, suffix = 2;
+			for (; mintedKeys.has(`${base}-${suffix}`);) suffix++;
+			candidate = `${base}-${suffix}`;
+		}
+		return mintedKeys.add(candidate), candidate;
+	};
+}
 const getByteHexTable = (() => {
 	let table;
 	return () => {
@@ -670,10 +695,10 @@ function isHtmlShaped(value) {
 * @public
 */
 const DefaultImageRenderer = (options) => {
-	if (!isImageShaped(options.value)) return DefaultUnknownTypeRenderer(options);
+	if (!isImageShaped(options.value) || !linkValidator(options.value.src)) return DefaultUnknownTypeRenderer(options);
 	let alt = escapeImageAndLinkText(options.value.alt ?? ""), title = options.value.title ? ` "${escapeImageAndLinkTitle(options.value.title)}"` : "";
 	return `![${alt}](${options.value.src}${title})`;
-};
+}, linkValidator = new markdownit().validateLink;
 function isImageShaped(value) {
 	let image = value;
 	return typeof image?.src == "string" && (image.alt == null || typeof image.alt == "string") && (image.title == null || typeof image.title == "string");
@@ -715,12 +740,23 @@ const DefaultTableRenderer = (options) => {
 function renderTable(value, renderNode) {
 	let rows = value.rows, alignment = Array.isArray(value.alignment) ? value.alignment : void 0, headerRow = rows.at(0);
 	if (!headerRow) return "";
-	let getCellText = (cellBlocks) => cellBlocks.map((block, index) => renderNode({
-		node: block,
-		index,
-		isInline: !1,
-		renderNode
-	})).join(" ").trim(), lines = [], columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0), renderCells = (texts) => {
+	let getCellText = (cellBlocks) => cellBlocks.map((block, index) => {
+		let rendered = renderNode({
+			node: block,
+			index,
+			isInline: !1,
+			renderNode
+		}), rendererOptions = {
+			value: block,
+			isInline: !1,
+			index,
+			renderNode
+		};
+		return rendered === DefaultUnknownTypeRenderer(rendererOptions) ? DefaultUnknownTypeRenderer({
+			...rendererOptions,
+			isInline: !0
+		}) : rendered;
+	}).join(" ").trim(), lines = [], columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0), renderCells = (texts) => {
 		let padded = [...texts];
 		for (; padded.length < columnCount;) padded.push("");
 		return `| ${padded.join(" | ")} |`;
@@ -753,7 +789,7 @@ const DefaultCalloutRenderer = (options) => {
 		index,
 		isInline: !1,
 		renderNode
-	})).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+	})).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
 	return `> [!${options.value.tone.toUpperCase()}]\n${prefixed}`;
 };
 function isCalloutShaped(value) {
@@ -780,20 +816,29 @@ const DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content
 	index,
 	isInline: !1,
 	renderNode
-})).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n"), DefaultListRenderer = ({ value, renderNode }) => {
-	let itemSeparator = value.items.some((item) => item.content.filter((block) => block._type !== "list").length > 1) ? "\n\n" : "\n";
-	return value.items.map((item, itemIndex) => {
-		let marker = getListMarker(value.kind, itemIndex, item.checked), indentWidth = value.kind === "task" ? 2 : marker.length, indent = " ".repeat(indentWidth), [first, ...rest] = item.content.map((block, blockIndex) => (blockIndex === 0 && isPortableTextBlock(block) && markListItemFirstBlock(block), {
-			isNestedList: block._type === "list",
-			text: renderNode({
+})).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n"), DefaultListRenderer = ({ value, renderNode }) => {
+	let renderedItems = value.items.map((item) => {
+		let markerLineSettled = !1;
+		return item.content.map((block, blockIndex) => {
+			let isNestedList = block._type === "list", isTextBlock = !isNestedList && isPortableTextBlock(block);
+			!markerLineSettled && isTextBlock && markListItemFirstBlock(block);
+			let text = renderNode({
 				node: block,
 				index: blockIndex,
 				isInline: !1,
 				renderNode
-			})
-		})), head = `${marker}${first?.text ?? ""}`.trimEnd();
+			});
+			return text !== "" && (markerLineSettled = !0), {
+				isNestedList,
+				isTextBlock,
+				text
+			};
+		});
+	}), itemSeparator = renderedItems.some((renderedBlocks) => renderedBlocks.filter((rendered) => !rendered.isNestedList && rendered.text !== "").length > 1) ? "\n\n" : "\n";
+	return value.items.map((item, itemIndex) => {
+		let marker = getListMarker(value.kind, itemIndex, item.checked), indentWidth = value.kind === "task" ? 2 : marker.length, indent = " ".repeat(indentWidth), indentLines = (text) => text.split("\n").map((line) => line === "" ? "" : `${indent}${line}`).join("\n"), nonEmptyBlocks = (renderedItems[itemIndex] ?? []).filter((rendered) => rendered.text !== ""), markerLineCandidate = nonEmptyBlocks[0], promoted = markerLineCandidate && !markerLineCandidate.isNestedList && (value.kind !== "task" || markerLineCandidate.isTextBlock) ? markerLineCandidate : void 0, rest = promoted ? nonEmptyBlocks.slice(1) : nonEmptyBlocks, [promotedFirstLine = "", ...promotedRestLines] = (promoted?.text ?? "").split("\n"), head = [`${marker}${promotedFirstLine}`, ...promotedRestLines.length > 0 ? [indentLines(promotedRestLines.join("\n"))] : []].join("\n").trimEnd();
 		return rest.length === 0 ? head : `${head}${rest.map((rendered) => {
-			let indented = rendered.text.split("\n").map((line) => line === "" ? "" : `${indent}${line}`).join("\n");
+			let indented = indentLines(rendered.text);
 			return rendered.isNestedList ? `\n${indented}` : `\n\n${indented}`;
 		}).join("")}`;
 	}).join(itemSeparator);
@@ -853,7 +898,7 @@ function portableTextToMarkdown(blocks, options = {}) {
 			...options.marks
 		},
 		types: {
-			...defaultRenderers.types,
+			...gateDefaultTypeRenderers(defaultRenderers.types, options.schema, options.unknownType ?? defaultRenderers.unknownType),
 			...options.types
 		},
 		hardBreak: options.hardBreak ?? defaultRenderers.hardBreak,
@@ -861,22 +906,26 @@ function portableTextToMarkdown(blocks, options = {}) {
 		unknownBlockStyle: options.unknownBlockStyle ?? defaultRenderers.unknownBlockStyle,
 		unknownListItem: options.unknownListItem ?? defaultRenderers.unknownListItem,
 		unknownMark: options.unknownMark ?? defaultRenderers.unknownMark
-	}, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, { listIndexMap, listDepthMap } = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap, listDepthMap);
-	return blocks.map((node, index) => {
-		let renderedNode = renderNode({
+	}, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, { listIndexMap, listDepthMap } = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap, listDepthMap), renderedBlocks = blocks.map((node, index) => ({
+		node,
+		rendered: renderNode({
 			node,
 			index,
 			isInline: !1,
 			renderNode
-		});
-		if (index === blocks.length - 1) return renderedNode;
-		let nextNode = blocks.at(index + 1);
-		return nextNode ? `${renderedNode}${renderBlockSpacing({
+		})
+	})).filter(({ rendered }) => rendered !== "");
+	return renderedBlocks.map(({ node, rendered }, index) => {
+		let nextBlock = renderedBlocks.at(index + 1);
+		return nextBlock ? `${rendered}${renderBlockSpacing({
 			current: node,
-			next: nextNode
-		}) ?? "\n\n"}` : renderedNode;
+			next: nextBlock.node
+		}) ?? "\n\n"}` : rendered;
 	}).join("");
 }
+function gateDefaultTypeRenderers(defaultTypeRenderers, schema, resolvedUnknownType) {
+	return schema ? Object.fromEntries(Object.entries(defaultTypeRenderers).map(([typeName, renderer]) => [typeName, (rendererOptions) => (rendererOptions.isInline ? schema.inlineObjects : schema.blockObjects).some((item) => item.name === typeName) && renderer ? renderer(rendererOptions) : resolvedUnknownType(rendererOptions)])) : defaultTypeRenderers;
+}
 /********************
 * Default style definitions
 ********************/
@@ -1254,7 +1303,7 @@ function buildDegradationMessage(degradations) {
 function markdownToPortableText(markdown, options) {
 	let consolidatedOptions = {
 		schema: options?.schema ?? defaultSchema,
-		keyGenerator: options?.keyGenerator ?? defaultKeyGenerator,
+		keyGenerator: uniqueKeyGenerator(options?.keyGenerator ?? defaultKeyGenerator),
 		html: { inline: options?.html?.inline ?? "skip" },
 		marks: {
 			...defaultOptions.marks,
@@ -1857,12 +1906,15 @@ function markdownToPortableText(markdown, options) {
 				});
 				let demotedInlineImages = [];
 				for (let block of cellBlocks) if (block._type === "block" && "children" in block && Array.isArray(block.children)) for (let child of block.children) typeof child == "object" && child && demotedTableImages.has(child) && demotedInlineImages.push(child);
-				let firstBlock = cellBlocks[0], liftedImage;
+				let firstBlock = cellBlocks[0], liftedObject;
 				if (cellBlocks.length === 1 && firstBlock && firstBlock._type === "block" && "children" in firstBlock && Array.isArray(firstBlock.children) && firstBlock.children.length === 1) {
 					let onlyChild = firstBlock.children[0];
-					typeof onlyChild == "object" && onlyChild && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name && onlyChild._type === "image" && (cellBlocks[0] = onlyChild, liftedImage = onlyChild);
+					if (typeof onlyChild == "object" && onlyChild && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name) {
+						let declaredInline = consolidatedOptions.schema.inlineObjects.some((inlineObject) => inlineObject.name === onlyChild._type), declaredBlock = consolidatedOptions.schema.blockObjects.some((blockObject) => blockObject.name === onlyChild._type);
+						declaredInline && !declaredBlock || (cellBlocks[0] = onlyChild, liftedObject = onlyChild);
+					}
 				}
-				for (let demotedImage of demotedInlineImages) if (demotedImage !== liftedImage) {
+				for (let demotedImage of demotedInlineImages) if (demotedImage !== liftedObject) {
 					let { alt, src } = demotedImage;
 					report({
 						type: "image-block-to-inline",
@@ -2234,6 +2286,828 @@ function parseJsonObjectFence(code) {
 	let objectValue = parsed;
 	if (typeof objectValue._type == "string" && objectValue._type.length !== 0) return objectValue;
 }
-export { DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, markdownToPortableText, portableTextToMarkdown };
+/**
+* Deliberately high pending calibration against real agent edit
+* traces: a wrong match moves anchors onto unrelated text, a fresh
+* key resets one block.
+*/
+const MIN_BLOCK_SIMILARITY = .8, MAX_SIMILARITY_PAIRS = 2500;
+/**
+* Converts edited markdown to Portable Text, restores stored keys, and
+* restores fields the markdown dialect cannot express (dropped by
+* serialization, so the edit could not have touched them); a field
+* markdown does express follows the edit. The same rule covers a
+* custom style or decorator markdown has no syntax for, coerced to a
+* built-in on the round trip. An empty or whitespace-only text block
+* is the same case taken to the whole block: markdown has no form for
+* either, so it is restored next to its surviving neighbor and
+* dropped along with that neighbor if the neighbor does not survive.
+* Keys aim for what the
+* same edit would have produced in an editor:
+* unchanged, moved, and rewritten-in-place content keeps its keys
+* (rewriting a paragraph in place keeps its identity, like typing over
+* it), a split keeps the key on its first non-empty fragment, a merge
+* keeps the first source block's key, and a `json:object` payload keeps
+* the key it carries, unless reconciliation matches it to stored
+* content, which takes the stored key even over a differing key in the
+* payload. When an insertion or deletion makes positions ambiguous,
+* only clear similarity evidence adopts a key and everything else gets
+* a new one; gathering that evidence is time-capped, so on very large
+* ambiguous edits the set of adopted keys can differ across machine
+* speeds, degrading toward fresh keys.
+* Output keys are unique among siblings. The function does not mutate
+* `storedPortableText` and returns a value, not patches. The `schema`
+* is taken once and governs both directions; pass the same `serialize`
+* options that produced the markdown that was edited. A throwing or
+* stateful custom matcher or renderer propagates or degrades matching
+* respectively.
+* Reconciliation never merges concurrent edits: compare the stored
+* field against the live document before writing the result back.
+* The trades in one line: same-position replacement inherits identity,
+* a count-preserving rewrite pairs positionally (block-level and
+* sibling-level alike), and evidence gathering is capped, degrading to
+* fresh keys.
+*
+* @public
+*/
+function applyMarkdownEdit(storedPortableText, editedMarkdown, options) {
+	let onReconciliation = options?.onReconciliation, recorder = onReconciliation ? {
+		preservationBasis: /* @__PURE__ */ new WeakMap(),
+		renamePreviousKey: /* @__PURE__ */ new WeakMap(),
+		annotationKeyConflicts: [],
+		ambiguousRegionGroups: [],
+		skipReason: void 0
+	} : void 0, result = structuredClone(markdownToPortableText(editedMarkdown, {
+		...options?.deserialize,
+		schema: options?.schema
+	})), canonical = canonicalizeStored(storedPortableText, options), originOf = traceOrigins(nonEmptyBlocks(storedPortableText, options), canonical, recorder), adoptedNodes = /* @__PURE__ */ new WeakSet();
+	if (originOf) {
+		let alignment = alignBlocks(canonical, result, recorder);
+		if (alignment) {
+			adoptAnchors(alignment.anchors, originOf, result, adoptedNodes, recorder);
+			let gaps = adoptMoves(alignment.gaps, canonical, result, originOf, adoptedNodes, recorder);
+			for (let gap of gaps) resolveGap(gap.storedIndexes, gap.editedIndexes, canonical, result, originOf, adoptedNodes, recorder);
+			reinsertEmptyRuns(storedPortableText, result, adoptedNodes, options, recorder);
+		}
+	}
+	return enforceSiblingKeyUniqueness(result, options?.deserialize?.keyGenerator ?? defaultKeyGenerator, adoptedNodes, recorder), recorder && onReconciliation && onReconciliation(buildReconciliationReport(result, recorder)), result;
+}
+/**
+* Re-expresses the stored value in the parser's dialect by serializing
+* it and parsing it right back: the parser merges same-mark sibling
+* spans, reorders marks, collapses list levels, and fills defaults, so
+* content the edit never touched only deep-equals its parsed
+* counterpart after both sides have been through the same round trip.
+* The replacement keys are positional (`__canonical_<n>`), so a match
+* against canonical node `n` can be traded back for stored node `n`'s
+* real `_key`.
+*/
+function canonicalizeStored(stored, options) {
+	let storedMarkdown = portableTextToMarkdown(structuredClone(stored), {
+		...options?.serialize,
+		schema: options?.schema
+	}), { onDegradation, ...canonicalDeserializeOptions } = options?.deserialize ?? {}, canonicalKeyCounter = 0;
+	return markdownToPortableText(storedMarkdown, {
+		...canonicalDeserializeOptions,
+		schema: options?.schema,
+		keyGenerator: () => `__canonical_${canonicalKeyCounter++}`
+	});
+}
+/**
+* Positional pairing between `stored` and `canonical` is only
+* trustworthy when serialization preserved the node count and the
+* type sequence; when it did not (heading hard-break splits, lossy
+* table normalization), no key can be traced back to its owner, so
+* nothing adopts. `stored` is already the non-empty subsequence: empty
+* text blocks have no markdown form, so `canonical` never carries them
+* either, and `reinsertEmptyRuns` restores them afterward.
+*/
+function traceOrigins(stored, canonical, recorder) {
+	if (canonical.length !== stored.length) {
+		recorder && (recorder.skipReason = "round-trip-mismatch");
+		return;
+	}
+	for (let index = 0; index < stored.length; index++) if (stored[index]._type !== canonical[index]?._type) {
+		recorder && (recorder.skipReason = "round-trip-mismatch");
+		return;
+	}
+	for (let index = 0; index < stored.length; index++) {
+		let storedNode = stored[index], canonicalNode = canonical[index];
+		if (isTextBlock$1(storedNode) && isTextBlock$1(canonicalNode) && blockText(storedNode).trim() !== blockText(canonicalNode).trim()) {
+			recorder && (recorder.skipReason = "round-trip-mismatch");
+			return;
+		}
+	}
+	return (canonicalIndex) => stored[canonicalIndex];
+}
+/**
+* Equal runs become anchor pairs (so repeated content pairs
+* first-to-first when adopted), and the delete/insert runs between
+* them form the gaps.
+*/
+function alignBlocks(canonical, result, recorder) {
+	let tokenByNeutral = /* @__PURE__ */ new Map(), tokenOf = (node) => {
+		let neutral = neutralForm(node), token = tokenByNeutral.get(neutral);
+		return token === void 0 && (token = String.fromCharCode(tokenByNeutral.size + 1), tokenByNeutral.set(neutral, token)), token;
+	}, canonicalTokens = canonical.map(tokenOf).join(""), resultTokens = result.map(tokenOf).join("");
+	if (tokenByNeutral.size > 55e3) {
+		recorder && (recorder.skipReason = "document-too-large");
+		return;
+	}
+	let diffs = makeDiff(canonicalTokens, resultTokens, { checkLines: !1 }), anchors = [], gaps = [], gap = {
+		storedIndexes: [],
+		editedIndexes: []
+	}, flushGap = () => {
+		(gap.storedIndexes.length > 0 || gap.editedIndexes.length > 0) && (gaps.push(gap), gap = {
+			storedIndexes: [],
+			editedIndexes: []
+		});
+	}, canonicalIndex = 0, resultIndex = 0;
+	for (let [operation, text] of diffs) if (operation === 0) {
+		flushGap();
+		for (let offset = 0; offset < text.length; offset++) anchors.push({
+			canonicalIndex,
+			resultIndex
+		}), canonicalIndex++, resultIndex++;
+	} else if (operation === -1) for (let offset = 0; offset < text.length; offset++) gap.storedIndexes.push(canonicalIndex++);
+	else for (let offset = 0; offset < text.length; offset++) gap.editedIndexes.push(resultIndex++);
+	return flushGap(), {
+		anchors,
+		gaps
+	};
+}
+function adoptAnchors(anchors, originOf, result, adoptedNodes, recorder) {
+	for (let anchor of anchors) result[anchor.resultIndex] = adoptVerbatim(originOf(anchor.canonicalIndex), result[anchor.resultIndex], adoptedNodes, "content-unchanged", recorder);
+}
+/**
+* An anchor or a unique exact leftover pairs a canonical block against
+* a parsed one that share the same neutral form (that is what put them
+* in the same equal-diff run or the same neutral-form bucket), so
+* everything the dialect can express is untouched and everything it
+* cannot express was invisible to the edit. The stored subtree is the
+* truth at every depth, spans, marks, markDefs, and any field the
+* dialect drops, so adoption replaces the whole node rather than
+* reconciling into the parsed shape (which would otherwise, for
+* instance, keep a parser-side span merge that collapsed an
+* unmappable mark boundary the edit never touched). `restoreFields`
+* and per-child reconciliation are skipped entirely: a verbatim clone
+* of the stored node is already complete.
+*/
+function adoptVerbatim(original, target, adoptedNodes, basis, recorder) {
+	let clone = structuredClone(original);
+	return fillMissingKeysFromTarget(clone, target), markSubtreeAdopted(clone, adoptedNodes), recorder && (tagSubtreePreserved(clone, recorder), basis !== "content-unchanged" && typeof clone._key == "string" && recorder.preservationBasis.set(clone, basis)), clone;
+}
+/**
+* A stored node practically always carries its own `_key`; when it
+* genuinely does not, there is nothing to adopt, so the clone keeps
+* whatever key the plain parse already minted at the corresponding
+* position, the same key adoption would have left in place. The walk
+* follows both trees positionally (not by content matching, which is
+* exactly what an exact-signature match already guarantees agrees at
+* every position the two sides both still have).
+*/
+function fillMissingKeysFromTarget(clone, target) {
+	typeof clone._key != "string" && typeof target._key == "string" && (clone._key = target._key);
+	for (let field of Object.keys(clone)) {
+		let cloneValue = clone[field], targetValue = target[field];
+		if (isTypedObjectArray(cloneValue) && isTypedObjectArray(targetValue)) {
+			let length = Math.min(cloneValue.length, targetValue.length);
+			for (let index = 0; index < length; index++) fillMissingKeysFromTarget(cloneValue[index], targetValue[index]);
+		} else typeof cloneValue == "object" && cloneValue && !Array.isArray(cloneValue) && typeof targetValue == "object" && targetValue && !Array.isArray(targetValue) && fillMissingKeysFromTarget(cloneValue, targetValue);
+	}
+}
+/**
+* Every keyed node in a verbatim clone is adopted, not only its root:
+* the sibling-key-uniqueness pass recurses into every nested keyed
+* array, and an adopted-first ordering there only favors a clone's
+* descendants if they are themselves marked adopted.
+*/
+function markSubtreeAdopted(node, adoptedNodes) {
+	adoptedNodes.add(node);
+	for (let value of Object.values(node)) if (Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0) for (let child of value) markSubtreeAdopted(child, adoptedNodes);
+	else typeof value == "object" && value && markSubtreeAdopted(value, adoptedNodes);
+}
+/**
+* Moves: content that left one gap and reappeared in another. Unique
+* exact pairs across all gaps adopt before any gap-local pairing can
+* consume the keys they need.
+*/
+function adoptMoves(gaps, canonical, result, originOf, adoptedNodes, recorder) {
+	let consumedStored = /* @__PURE__ */ new Set(), consumedEdited = /* @__PURE__ */ new Set(), storedLeftovers = gaps.flatMap((g) => g.storedIndexes), editedLeftovers = gaps.flatMap((g) => g.editedIndexes), storedByNeutral = /* @__PURE__ */ new Map();
+	for (let index of storedLeftovers) {
+		let neutral = neutralForm(canonical[index]);
+		storedByNeutral.set(neutral, [...storedByNeutral.get(neutral) ?? [], index]);
+	}
+	let editedByNeutral = /* @__PURE__ */ new Map();
+	for (let index of editedLeftovers) {
+		let neutral = neutralForm(result[index]);
+		editedByNeutral.set(neutral, [...editedByNeutral.get(neutral) ?? [], index]);
+	}
+	for (let [neutral, storedIndexes] of storedByNeutral) {
+		let editedIndexes = editedByNeutral.get(neutral);
+		if (storedIndexes.length !== 1 || !editedIndexes || editedIndexes.length !== 1) continue;
+		consumedStored.add(storedIndexes[0]), consumedEdited.add(editedIndexes[0]);
+		let clone = adoptVerbatim(originOf(storedIndexes[0]), result[editedIndexes[0]], adoptedNodes, "content-moved", recorder);
+		result[editedIndexes[0]] = clone;
+	}
+	return gaps.map((currentGap) => ({
+		storedIndexes: currentGap.storedIndexes.filter((index) => !consumedStored.has(index)),
+		editedIndexes: currentGap.editedIndexes.filter((index) => !consumedEdited.has(index))
+	}));
+}
+/**
+* Gap policy, in order: split/merge survivor (the first fragment or
+* first source block keeps the key, matching what pressing enter or
+* backspace does in the editor), positional zip for equal counts
+* (typing over a paragraph keeps its identity), similarity for
+* unequal counts (an insertion or deletion shifted positions, so
+* position lies and only mutual unique best evidence adopts).
+*/
+function resolveGap(storedIndexes, editedIndexes, canonical, result, originOf, adoptedNodes, recorder) {
+	let remainingStored = new Set(storedIndexes), remainingEdited = new Set(editedIndexes), withinConcatenationCap = storedIndexes.length * editedIndexes.length <= MAX_SIMILARITY_PAIRS;
+	if (withinConcatenationCap) for (let storedIndex of storedIndexes) {
+		if (!remainingStored.has(storedIndex)) continue;
+		let storedBlock = canonical[storedIndex];
+		if (!isTextBlock$1(storedBlock)) continue;
+		let fragments = findConcatenation(blockText(storedBlock), editedIndexes.filter((index) => remainingEdited.has(index)), result);
+		if (fragments) {
+			remainingStored.delete(storedIndex);
+			for (let fragment of fragments) remainingEdited.delete(fragment);
+			let survivor = fragments.find((fragment) => blockText(result[fragment]).length > 0) ?? fragments[0];
+			adoptNode(originOf(storedIndex), canonical[storedIndex], result[survivor], adoptedNodes, "content-split", recorder);
+		}
+	}
+	if (withinConcatenationCap) for (let editedIndex of editedIndexes) {
+		if (!remainingEdited.has(editedIndex)) continue;
+		let editedBlock = result[editedIndex];
+		if (!isTextBlock$1(editedBlock)) continue;
+		let sources = findConcatenation(blockText(editedBlock), storedIndexes.filter((index) => remainingStored.has(index)), canonical);
+		if (sources) {
+			remainingEdited.delete(editedIndex);
+			for (let source of sources) remainingStored.delete(source);
+			adoptNode(originOf(sources[0]), canonical[sources[0]], result[editedIndex], adoptedNodes, "content-merged", recorder);
+		}
+	}
+	let storedRest = [...remainingStored], editedRest = [...remainingEdited];
+	if (storedRest.length === editedRest.length) {
+		for (let offset = 0; offset < storedRest.length; offset++) {
+			let storedBlock = canonical[storedRest[offset]], editedBlock = result[editedRest[offset]];
+			storedBlock._type === editedBlock._type && adoptNode(originOf(storedRest[offset]), canonical[storedRest[offset]], editedBlock, adoptedNodes, "same-position", recorder);
+		}
+		return;
+	}
+	if (storedRest.length * editedRest.length > MAX_SIMILARITY_PAIRS) {
+		recorder && recorder.ambiguousRegionGroups.push(editedRest.map((editedIndex) => result[editedIndex]));
+		return;
+	}
+	let scores = /* @__PURE__ */ new Map();
+	for (let storedIndex of storedRest) for (let editedIndex of editedRest) {
+		let score = blockSimilarity(canonical[storedIndex], result[editedIndex]);
+		score >= MIN_BLOCK_SIMILARITY && scores.set(`${storedIndex}:${editedIndex}`, score);
+	}
+	for (let storedIndex of storedRest) {
+		let best = uniqueBest(editedRest, (editedIndex) => scores.get(`${storedIndex}:${editedIndex}`));
+		best !== void 0 && uniqueBest(storedRest, (otherStoredIndex) => scores.get(`${otherStoredIndex}:${best}`)) === storedIndex && adoptNode(originOf(storedIndex), canonical[storedIndex], result[best], adoptedNodes, "similar-content", recorder);
+	}
+}
+/**
+* Fragments join with nothing or a single space, since a markdown
+* merge is often a soft-wrap join that inserts one ("alpha\nbeta"
+* parses to "alpha beta").
+*/
+function findConcatenation(wholeText, candidateIndexes, nodes) {
+	if (wholeText.length !== 0) for (let joiner of ["", " "]) for (let start = 0; start < candidateIndexes.length; start++) {
+		let concatenated = "", used = [];
+		for (let position = start; position < candidateIndexes.length; position++) {
+			let index = candidateIndexes[position];
+			if (position > start && candidateIndexes[position - 1] !== index - 1 || !isTextBlock$1(nodes[index]) || (concatenated = used.length === 0 ? blockText(nodes[index]) : concatenated + joiner + blockText(nodes[index]), used.push(index), concatenated.length > wholeText.length)) break;
+			if (concatenated === wholeText && used.length > 1) return used;
+		}
+	}
+}
+/**
+* Adopts the original node's `_key`, its markdown-inexpressible
+* fields, then its `markDefs` before its other keyed children, since
+* `span.marks` references need the adopted `markDefs` keys already in
+* place.
+*/
+function adoptNode(original, canonicalCounterpart, target, adoptedNodes, basis, recorder) {
+	adoptedNodes.add(target), typeof original._key == "string" && (target._key = original._key, recorder?.preservationBasis.set(target, basis)), restoreFields(original, canonicalCounterpart, target), rewriteMarkReferences(target, adoptMarkDefs(original, canonicalCounterpart, target, recorder));
+	for (let field of Object.keys(target)) {
+		if (field === "markDefs") continue;
+		let originalChildren = original[field], targetChildren = target[field];
+		if (!isTypedObjectArray(originalChildren) || !isTypedObjectArray(targetChildren)) continue;
+		let canonicalChildren = canonicalChildArray(canonicalCounterpart, field, originalChildren), matchedOriginal = /* @__PURE__ */ new Set(), matchedTarget = /* @__PURE__ */ new Set(), originalGroups = groupByNeutralForm(originalChildren, matchedOriginal, buildAliasMap(original)), targetGroups = groupByNeutralForm(targetChildren, matchedTarget, buildAliasMap(target));
+		for (let [neutral, originalIndexes] of originalGroups) {
+			let targetIndexes = targetGroups.get(neutral);
+			originalIndexes.length !== 1 || !targetIndexes || targetIndexes.length !== 1 || (matchedOriginal.add(originalIndexes[0]), matchedTarget.add(targetIndexes[0]), adoptNode(originalChildren[originalIndexes[0]], canonicalChildren?.[originalIndexes[0]], targetChildren[targetIndexes[0]], adoptedNodes, "content-unchanged", recorder));
+		}
+		field === "children" && originalChildren.length * targetChildren.length <= MAX_SIMILARITY_PAIRS && adoptMergedSpans(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder), adoptResidualZip(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder);
+	}
+}
+/**
+* The container-level counterpart of `traceOrigins`'s guard: a
+* child's canonical form is only trustworthy when the canonical
+* container holds the same field as the same typed object array,
+* equal in length and `_type` sequence to the original's, so pairing
+* by index (original child `i` to canonical child `i`) means the same
+* content on both sides.
+*/
+function canonicalChildArray(canonicalCounterpart, field, originalChildren) {
+	if (!canonicalCounterpart) return;
+	let candidate = canonicalCounterpart[field];
+	if (!(!isTypedObjectArray(candidate) || candidate.length !== originalChildren.length)) {
+		for (let index = 0; index < originalChildren.length; index++) if (originalChildren[index]._type !== candidate[index]._type) return;
+		return candidate;
+	}
+}
+/**
+* Restores fields the markdown dialect dropped or altered: present on
+* the original, unchanged by the edit (the target still agrees with
+* the original's own canonical round trip), and different on that
+* round trip from the original (so the parse, left to itself, could
+* never have produced the original's value). Absence counts as a
+* value under both comparisons, which is what folds a wholly dropped
+* field (no markdown form at all) and a coerced one (a custom style
+* or decorator markdown silently maps to its closest built-in) into
+* one rule. Structural child arrays (`children`, `markDefs`, and
+* typed object arrays generally) are excluded: their elements adopt
+* individually through the recursive per-child walk instead, except
+* when the target has no such element to walk at all: a typed-object
+* array field the dialect drops entirely leaves nothing on the target
+* side for that walk to reconcile, so it falls through to the same
+* absent-on-target, absent-on-canonical oracle as every scalar field,
+* restored verbatim rather than left missing. Restored values are
+* cloned, since the sibling-key-uniqueness pass may rewrite `_key`s
+* inside a restored array of objects, and the original must stay
+* untouched.
+*/
+function restoreFields(original, canonicalCounterpart, target) {
+	if (canonicalCounterpart) for (let field of Object.keys(original)) {
+		if (field === "_key" || field === "_type" || field === "markDefs" || field === "children") continue;
+		if (isTypedObjectArray(original[field])) {
+			target[field] === void 0 && canonicalCounterpart[field] === void 0 && (target[field] = structuredClone(original[field]));
+			continue;
+		}
+		let canonicalValue = canonicalCounterpart[field];
+		valuesEqual(target[field], canonicalValue) && (valuesEqual(canonicalValue, original[field]) || (target[field] = structuredClone(original[field])));
+	}
+}
+/**
+* Deep equality for restoration's before/after comparison: the
+* `encodeNeutral` encoding without alias rewriting, so it compares
+* `marks` arrays (and any other array or nested object) by value
+* rather than by identity. Absent (`undefined`) encodes to the same
+* string on both sides, so two absent fields count as equal.
+*/
+function valuesEqual(a, b) {
+	return encodeNeutral(a, void 0) === encodeNeutral(b, void 0);
+}
+/**
+* A span in the edited output can be the merge of several stored
+* spans: the parser merges adjacent same-mark spans, and an edit that
+* removes formatting merges across the old mark boundary too. Matching
+* is by text alone, and the first contributor's key survives, matching
+* the editor's own span-merge normalization.
+*/
+function adoptMergedSpans(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder) {
+	for (let targetIndex = 0; targetIndex < targetChildren.length; targetIndex++) {
+		if (matchedTarget.has(targetIndex)) continue;
+		let targetSpan = targetChildren[targetIndex], targetText = targetSpan.text;
+		if (typeof targetText == "string") for (let start = 0; start < originalChildren.length; start++) {
+			if (matchedOriginal.has(start)) continue;
+			let concatenated = "", used = [];
+			for (let index = start; index < originalChildren.length && !matchedOriginal.has(index); index++) {
+				let originalSpan = originalChildren[index];
+				if (typeof originalSpan.text != "string" || (concatenated += originalSpan.text, used.push(index), concatenated.length > targetText.length)) break;
+				if (concatenated === targetText && used.length > 1) {
+					matchedTarget.add(targetIndex);
+					for (let usedIndex of used) matchedOriginal.add(usedIndex);
+					adoptNode(originalChildren[used[0]], canonicalChildren?.[used[0]], targetSpan, adoptedNodes, "content-merged", recorder);
+					break;
+				}
+			}
+			if (matchedTarget.has(targetIndex)) break;
+		}
+	}
+}
+/**
+* The equal-count residual rule, mirroring `resolveGap`'s positional
+* zip: elements left unmatched after neutral-form (and, for
+* `children`, span-merge) matching are treated as in-place edits when
+* both sides leave the same count, position being the same evidence
+* the block-level zip already trusts, and the trade is the same too:
+* a reorder-plus-edit with balanced counts mispairs. Unequal counts
+* adopt nothing, since position no longer lines up.
+*/
+function adoptResidualZip(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder) {
+	let originalRest = originalChildren.map((node, index) => ({
+		node,
+		index
+	})).filter(({ index }) => !matchedOriginal.has(index)), targetRest = targetChildren.filter((_, index) => !matchedTarget.has(index));
+	if (originalRest.length === targetRest.length) for (let offset = 0; offset < originalRest.length; offset++) {
+		let originalNode = originalRest[offset].node, targetNode = targetRest[offset];
+		originalNode._type === targetNode._type && adoptNode(originalNode, canonicalChildren?.[originalRest[offset].index], targetNode, adoptedNodes, "same-position", recorder);
+	}
+}
+/**
+* Matches `markDefs` by definition content, `_key` excluded. Returns
+* the mapping from the target's fresh keys to the adopted stored
+* keys, for rewriting `span.marks` references.
+*/
+function adoptMarkDefs(original, canonicalCounterpart, target, recorder) {
+	let keyMap = /* @__PURE__ */ new Map(), originalDefs = original.markDefs, targetDefs = target.markDefs;
+	if (!isTypedObjectArray(originalDefs) || !isTypedObjectArray(targetDefs)) return keyMap;
+	let canonicalDefs = canonicalChildArray(canonicalCounterpart, "markDefs", originalDefs), matchedOriginal = /* @__PURE__ */ new Set(), matchedTarget = /* @__PURE__ */ new Set(), originalGroups = groupByNeutralForm(originalDefs.map((def, index) => canonicalDefs?.[index] ?? def), matchedOriginal), targetGroups = groupByNeutralForm(targetDefs, matchedTarget), adoptDef = (originalDef, canonicalDef, targetDef, basis) => {
+		if (restoreFields(originalDef, canonicalDef, targetDef), typeof originalDef._key == "string" && typeof targetDef._key == "string") {
+			let adoptedKey = originalDef._key;
+			if (targetDefs.some((def) => def !== targetDef && def._key === adoptedKey)) {
+				recorder?.annotationKeyConflicts.push(targetDef);
+				return;
+			}
+			keyMap.set(targetDef._key, adoptedKey), targetDef._key = adoptedKey, recorder?.preservationBasis.set(targetDef, basis);
+		}
+	};
+	for (let [neutral, originalIndexes] of originalGroups) {
+		let targetIndexes = targetGroups.get(neutral);
+		if (!(!targetIndexes || targetIndexes.length !== originalIndexes.length)) for (let offset = 0; offset < originalIndexes.length; offset++) matchedOriginal.add(originalIndexes[offset]), matchedTarget.add(targetIndexes[offset]), adoptDef(originalDefs[originalIndexes[offset]], canonicalDefs?.[originalIndexes[offset]], targetDefs[targetIndexes[offset]], originalIndexes.length === 1 ? "content-unchanged" : "same-position");
+	}
+	let originalRest = originalDefs.map((node, index) => ({
+		node,
+		index
+	})).filter(({ index }) => !matchedOriginal.has(index)), targetRest = targetDefs.filter((_, index) => !matchedTarget.has(index));
+	return originalRest.length === 1 && targetRest.length === 1 && originalRest[0].node._type === targetRest[0]._type && adoptDef(originalRest[0].node, canonicalDefs?.[originalRest[0].index], targetRest[0], "same-position"), keyMap;
+}
+function rewriteMarkReferences(block, keyMap) {
+	if (keyMap.size === 0) return;
+	let children = block.children;
+	if (isTypedObjectArray(children)) for (let child of children) {
+		let marks = child.marks;
+		Array.isArray(marks) && (child.marks = marks.map((mark) => typeof mark == "string" && keyMap.has(mark) ? keyMap.get(mark) : mark));
+	}
+}
+function groupByNeutralForm(nodes, exclude, aliasByKey) {
+	let groups = /* @__PURE__ */ new Map();
+	for (let index = 0; index < nodes.length; index++) {
+		if (exclude.has(index)) continue;
+		let neutral = aliasByKey ? encodeNeutral(nodes[index], aliasByKey) : neutralForm(nodes[index]), group = groups.get(neutral);
+		group ? group.push(index) : groups.set(neutral, [index]);
+	}
+	return groups;
+}
+/**
+* A canonical JSON encoding that erases identity: `_key` properties
+* are dropped, object properties are sorted, and annotation `_key`
+* references inside `span.marks` are rewritten to the definition's
+* position in `markDefs` (dropping `_key` alone would compare the
+* stored annotation key against the fresh one and reject an unchanged
+* link).
+*/
+function neutralForm(node) {
+	return encodeNeutral(node, buildAliasMap(node));
+}
+/**
+* Aliases each `markDefs` key to a key-independent spelling of the
+* definition itself, so `span.marks` references compare by what the
+* annotation is rather than which key it carries. The spelling is the
+* definition's own neutral form, not its array position: aliasing by
+* position made every annotated sibling span's neutral form shift when
+* a definition was inserted or removed before its own, so adding one
+* link re-keyed unrelated annotated spans. Identical definitions (the
+* same link twice) are disambiguated by occurrence order among
+* identical forms only, which no unrelated insertion can shift.
+*/
+function buildAliasMap(node) {
+	let markDefs = node.markDefs;
+	if (!isTypedObjectArray(markDefs)) return;
+	let aliasByKey = /* @__PURE__ */ new Map(), occurrenceByForm = /* @__PURE__ */ new Map();
+	for (let definition of markDefs) {
+		let key = definition._key;
+		if (typeof key != "string") continue;
+		let form = encodeNeutral(definition, void 0), occurrence = occurrenceByForm.get(form) ?? 0;
+		occurrenceByForm.set(form, occurrence + 1), aliasByKey.set(key, `@annotation:${occurrence}:${form}`);
+	}
+	return aliasByKey;
+}
+function encodeNeutral(value, aliasByKey) {
+	return Array.isArray(value) ? `[${value.map((item) => encodeNeutral(item, aliasByKey)).join(",")}]` : typeof value == "object" && value ? `{${Object.entries(value).filter(([field]) => field !== "_key").sort(([a], [b]) => a < b ? -1 : +(a > b)).map(([field, fieldValue]) => {
+		if (field === "marks" && aliasByKey && Array.isArray(fieldValue)) {
+			let aliased = fieldValue.map((mark) => typeof mark == "string" && aliasByKey.has(mark) ? aliasByKey.get(mark) : mark);
+			return `${JSON.stringify(field)}:${JSON.stringify(aliased)}`;
+		}
+		return `${JSON.stringify(field)}:${encodeNeutral(fieldValue, aliasByKey)}`;
+	}).join(",")}}` : JSON.stringify(value) ?? "undefined";
+}
+/**
+* The block's comparison text: concatenated span text with inline
+* objects as sentinels. Marks are ignored, since a formatting-only
+* edit does not change textual identity.
+*/
+function blockText(block) {
+	let children = block.children;
+	return isTypedObjectArray(children) ? children.map((child) => typeof child.text == "string" ? child.text : "").join("") : "";
+}
+/**
+* Text similarity in `[0, 1]`, gated to `0` unless the block shells
+* agree and the inline objects are compatible: however alike the
+* prose, blocks that disagree on structure are not the same block.
+* The length prescreen skips the diff when the size difference alone
+* puts the score under `MIN_BLOCK_SIMILARITY`.
+*/
+function blockSimilarity(canonicalBlock, resultBlock) {
+	if (!shellEquals(canonicalBlock, resultBlock) || !inlineObjectsCompatible(canonicalBlock, resultBlock)) return 0;
+	let canonicalText = blockText(canonicalBlock), resultText = blockText(resultBlock);
+	if (canonicalText.length === 0 || resultText.length === 0) return 0;
+	let longer = Math.max(canonicalText.length, resultText.length);
+	return 1 - Math.abs(canonicalText.length - resultText.length) / longer < MIN_BLOCK_SIMILARITY ? 0 : 1 - levenshteinFromDiffs(cleanupEfficiency(makeDiff(canonicalText, resultText, { timeout: .05 }))) / longer;
+}
+/**
+* The distance derivation from diff runs: insertions and deletions
+* between equality runs accumulate as the larger of the two, so a
+* delete-plus-insert counts as one substitution.
+*/
+function levenshteinFromDiffs(diffs) {
+	let distance = 0, insertions = 0, deletions = 0;
+	for (let [operation, text] of diffs) operation === 1 ? insertions += text.length : operation === -1 ? deletions += text.length : (distance += Math.max(insertions, deletions), insertions = 0, deletions = 0);
+	return distance + Math.max(insertions, deletions);
+}
+/**
+* The block minus its content: `_type`, `style`, `listItem`, `level`,
+* and any custom fields must agree before text similarity means
+* anything.
+*/
+function shellEquals(a, b) {
+	let shellOf = (node) => encodeNeutral(Object.fromEntries(Object.entries(node).filter(([field]) => field !== "children" && field !== "markDefs")), void 0);
+	return shellOf(a) === shellOf(b);
+}
+/**
+* Inline objects are opaque content: two blocks whose objects differ
+* are different blocks no matter how similar their prose is.
+*/
+function inlineObjectsCompatible(a, b) {
+	let objectsOf = (node) => {
+		let children = node.children;
+		return isTypedObjectArray(children) ? children.filter((child) => typeof child.text != "string") : [];
+	}, aObjects = objectsOf(a), bObjects = objectsOf(b);
+	return aObjects.length === bObjects.length && aObjects.every((aObject, index) => {
+		let bObject = bObjects[index];
+		return aObject._type === bObject._type ? typeof aObject._key == "string" && aObject._key === bObject._key || neutralForm(aObject) === neutralForm(bObject) : !1;
+	});
+}
+/**
+* The highest-scoring candidate, or `undefined` on a tie: a tie is
+* ambiguity, and ambiguity refuses adoption rather than guessing.
+*/
+function uniqueBest(candidates, scoreOf) {
+	let best, bestScore = 0, tied = !1;
+	for (let candidate of candidates) {
+		let score = scoreOf(candidate);
+		score !== void 0 && (score > bestScore ? (best = candidate, bestScore = score, tied = !1) : score === bestScore && best !== void 0 && (tied = !0));
+	}
+	return tied ? void 0 : best;
+}
+/**
+* Deliberately loose: any node with a `children` array reconciles like
+* a text block, custom block types included.
+*/
+function isTextBlock$1(node) {
+	return Array.isArray(node.children);
+}
+/**
+* A text block the round trip drops. Whether a whitespace-only block
+* survives serialize→parse depends on the converters, not on
+* structure: a heading renders `## ` and survives, a custom style
+* falls back to a plain paragraph and vanishes, and a non-breaking
+* space renders "blank-looking" output the parser still keeps (JS
+* `trim` folds NBSP, CommonMark does not), so any string check here is
+* a hand-written mirror of one converter or the other that drifts. The
+* block's own render-then-reparse is the authority, the same round
+* trip `canonicalizeStored` performs, so this predicate cannot
+* disagree with the canonical node count. The JS-trim pre-check only
+* keeps the per-block round trip off paths that cannot qualify: it
+* over-admits candidates (NBSP text passes it), and the reparse then
+* decides.
+*/
+function isEmptyTextBlock(node, options) {
+	if (!(isTextBlock$1(node) && blockText(node).trim() === "")) return !1;
+	let rendered = portableTextToMarkdown([structuredClone(node)], {
+		...options?.serialize,
+		schema: options?.schema
+	});
+	if (rendered === "") return !0;
+	let { onDegradation: _onDegradation, ...deserializeOptions } = options?.deserialize ?? {}, probeKeyCounter = 0;
+	return markdownToPortableText(rendered, {
+		...deserializeOptions,
+		schema: options?.schema,
+		keyGenerator: () => `empty-probe-${probeKeyCounter++}`
+	}).length === 0;
+}
+/**
+* Blank lines are markdown's block separator, so an empty text block
+* has no serialized form: `canonicalizeStored`'s round trip drops it,
+* the same way `markdownToPortableText` would if it were parsed back
+* from `editedMarkdown`. Tracing origins and aligning blocks over this
+* subsequence keeps both sides the same length; `reinsertEmptyRuns`
+* restores the dropped blocks afterward.
+*/
+function nonEmptyBlocks(stored, options) {
+	return stored.filter((node) => !isEmptyTextBlock(node, options));
+}
+function isTypedObjectArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item == "object" && !!item && typeof item._type == "string");
+}
+/**
+* Maximal runs of empty text blocks, each paired with the surviving
+* neighbor its restoration hangs off: a run with a preceding block
+* anchors to it (insert after); a run at the document's start, with
+* none, anchors to the block that follows it (insert before). A run
+* with neither (the whole document is empty blocks) has nothing to
+* anchor to and is dropped.
+*/
+function findEmptyRuns(stored, options) {
+	let runs = [], index = 0;
+	for (; index < stored.length;) {
+		if (!isEmptyTextBlock(stored[index], options)) {
+			index++;
+			continue;
+		}
+		let runStart = index;
+		for (; index < stored.length && isEmptyTextBlock(stored[index], options);) index++;
+		let precedingBlock = runStart > 0 ? stored[runStart - 1] : void 0, followingBlock = index < stored.length ? stored[index] : void 0, anchor = precedingBlock ?? followingBlock;
+		anchor && typeof anchor._key == "string" && runs.push({
+			anchorKey: anchor._key,
+			insertAfter: precedingBlock !== void 0,
+			blocks: stored.slice(runStart, index)
+		});
+	}
+	return runs;
+}
+/**
+* Restores each empty run next to the result node that adopted its
+* anchor's key, found by `_key` since positions have already shifted
+* under insertion, deletion, and move. An anchor whose key did not
+* survive into `result` (its region was rewritten or deleted) drops
+* the run with it, consistent with rewrite semantics elsewhere in this
+* module. Runs are cloned and marked adopted, the same authoritative
+* status as every other restored key, so a collision resolves in
+* their favor like `enforceSiblingKeyUniqueness` already does for
+* `json:object` duplicates.
+*/
+function reinsertEmptyRuns(stored, result, adoptedNodes, options, recorder) {
+	for (let run of findEmptyRuns(stored, options)) {
+		let adoptedAnchorIndex = result.findIndex((node) => node._key === run.anchorKey && adoptedNodes.has(node)), anchorIndex = adoptedAnchorIndex === -1 ? result.findIndex((node) => node._key === run.anchorKey) : adoptedAnchorIndex;
+		if (anchorIndex === -1) continue;
+		let clones = run.blocks.map((block) => structuredClone(block));
+		for (let clone of clones) adoptedNodes.add(clone), recorder && tagSubtreePreserved(clone, recorder);
+		result.splice(run.insertAfter ? anchorIndex + 1 : anchorIndex, 0, ...clones);
+	}
+}
+/**
+* Every keyed node in a reinserted empty run is the stored value
+* verbatim, at every depth, so key resolution reporting tags the
+* whole subtree `content-unchanged` rather than only the run's top
+* block.
+*/
+function tagSubtreePreserved(node, recorder) {
+	typeof node._key == "string" && recorder.preservationBasis.set(node, "content-unchanged");
+	for (let value of Object.values(node)) if (Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0) for (let child of value) tagSubtreePreserved(child, recorder);
+	else typeof value == "object" && value && tagSubtreePreserved(value, recorder);
+}
+/**
+* `json:object` payloads transport their `_key` verbatim, so a
+* copy-pasted fence puts the same key on two siblings, and everything
+* downstream (patches, anchors, editor normalization) assumes sibling
+* keys are unique. Adopted keys are authoritative, so a duplicate that
+* was adopted from the stored value wins and the other occurrences are
+* regenerated.
+*/
+function enforceSiblingKeyUniqueness(nodes, keyGenerator, adoptedNodes, recorder, onKeyRewritten) {
+	let usedKeys = /* @__PURE__ */ new Set(), claim = (node) => {
+		let key = node._key;
+		if (typeof key == "string") {
+			if (usedKeys.has(key)) {
+				let freshKey;
+				for (let attempt = 0; attempt < 3; attempt++) {
+					let candidate = keyGenerator();
+					if (!usedKeys.has(candidate)) {
+						freshKey = candidate;
+						break;
+					}
+				}
+				if (freshKey === void 0) {
+					let suffix = 1, candidate = `${key}_${suffix}`;
+					for (; usedKeys.has(candidate);) suffix++, candidate = `${key}_${suffix}`;
+					freshKey = candidate;
+				}
+				node._key = freshKey, usedKeys.add(freshKey), onKeyRewritten?.(key, freshKey), recorder?.renamePreviousKey.set(node, key);
+				return;
+			}
+			usedKeys.add(key);
+		}
+	}, adopted = nodes.filter((node) => adoptedNodes.has(node)), rest = nodes.filter((node) => !adoptedNodes.has(node));
+	for (let node of [...adopted, ...rest]) claim(node);
+	for (let node of nodes) enforceNestedSiblingKeyUniqueness(node, keyGenerator, adoptedNodes, recorder);
+}
+function enforceNestedSiblingKeyUniqueness(node, keyGenerator, adoptedNodes, recorder) {
+	for (let [field, value] of Object.entries(node)) Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0 ? enforceSiblingKeyUniqueness(value, keyGenerator, adoptedNodes, recorder, field === "markDefs" ? buildMarkDefKeyRewriter(node) : void 0) : typeof value == "object" && value && enforceNestedSiblingKeyUniqueness(value, keyGenerator, adoptedNodes, recorder);
+}
+/**
+* A colliding `keyGenerator` can mint the identical string for two
+* `markDefs` entries, which means the block's spans already reference
+* that shared string ambiguously before any rewrite happens: a
+* blanket find-and-replace of the old key would move every span's
+* reference, including the one that was never renamed. The
+* `markDefs` array and each span's `marks` are walked in the same
+* fixed document order, so the Nth occurrence of a given key in one
+* lines up with the Nth occurrence in the other; the first occurrence
+* is always the survivor (`enforceSiblingKeyUniqueness` only renames
+* on collision, never the first sighting of a key), so each rename
+* event retargets the next occurrence in that shared order instead of
+* every occurrence.
+*/
+function buildMarkDefKeyRewriter(block) {
+	let children = block.children;
+	if (!isTypedObjectArray(children)) return () => {};
+	let occurrencesByKey = /* @__PURE__ */ new Map();
+	for (let child of children) {
+		let marks = child.marks;
+		if (Array.isArray(marks)) for (let markIndex = 0; markIndex < marks.length; markIndex++) {
+			let mark = marks[markIndex];
+			if (typeof mark != "string") continue;
+			let occurrences = occurrencesByKey.get(mark) ?? [];
+			occurrences.push({
+				child,
+				markIndex
+			}), occurrencesByKey.set(mark, occurrences);
+		}
+	}
+	let consumedByKey = /* @__PURE__ */ new Map();
+	return (oldKey, newKey) => {
+		let occurrences = occurrencesByKey.get(oldKey), index = consumedByKey.get(oldKey) ?? 1;
+		consumedByKey.set(oldKey, index + 1);
+		let target = occurrences?.[index];
+		if (!target) return;
+		let marks = target.child.marks;
+		Array.isArray(marks) && (marks[target.markIndex] = newKey);
+	};
+}
+/**
+* Materializes the public report from the recorder's node-identity
+* decisions, walking the settled result tree once so every `key` and
+* `path` matches the returned value exactly: key resolution records
+* decisions before the sibling-uniqueness pass can still rewrite a
+* key, so keys and paths are only trustworthy read back from the
+* final tree, not from the moment a decision was made.
+*/
+function buildReconciliationReport(result, recorder) {
+	let preservedKeys = [], renamedKeys = [], pathByNode = /* @__PURE__ */ new WeakMap(), walk = (node, path) => {
+		pathByNode.set(node, path);
+		let key = node._key;
+		if (typeof key == "string") {
+			let basis = recorder.preservationBasis.get(node), previousKey = recorder.renamePreviousKey.get(node);
+			basis && previousKey === void 0 && preservedKeys.push({
+				basis,
+				key,
+				path
+			}), previousKey !== void 0 && renamedKeys.push({
+				previousKey,
+				key,
+				path
+			});
+		}
+		for (let [field, value] of Object.entries(node)) Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0 ? value.forEach((child, index) => {
+			let childKey = child._key;
+			walk(child, [
+				...path,
+				field,
+				typeof childKey == "string" ? { _key: childKey } : index
+			]);
+		}) : typeof value == "object" && value && walk(value, [...path, field]);
+	};
+	if (result.forEach((block, index) => {
+		let key = block._key;
+		walk(block, [typeof key == "string" ? { _key: key } : index]);
+	}), recorder.skipReason) return {
+		keyMatching: "skipped",
+		reason: recorder.skipReason,
+		renamedKeys
+	};
+	let keyFallbacks = [];
+	for (let group of recorder.ambiguousRegionGroups) keyFallbacks.push({
+		type: "ambiguous-region-too-large",
+		keys: group.map((node) => node._key).filter((key) => typeof key == "string")
+	});
+	for (let node of recorder.annotationKeyConflicts) keyFallbacks.push({
+		type: "annotation-key-conflict",
+		path: pathByNode.get(node)
+	});
+	return {
+		keyMatching: "performed",
+		preservedKeys,
+		keyFallbacks,
+		renamedKeys
+	};
+}
+export { DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, applyMarkdownEdit, markdownToPortableText, portableTextToMarkdown };
 
 //# sourceMappingURL=index.js.map