@stll/folio-core 0.32.2 → 0.33.1

package/dist/pdf/writePdf.js

@@ -0,0 +1,345 @@
+import { getShaper } from "../shaping/shaper.js";
+import { collectResources, renderContentStream } from "./contentStream.js";
+import { prepareFonts } from "./fonts.js";
+import { decodeImage } from "./images.js";
+import { createPdfDocument, pdfArray, pdfAsciiString, pdfDict, pdfFlateStream, pdfName, pdfNull, pdfNumber, pdfNumberArray, pdfStream, pdfTextString } from "./objects.js";
+import { displayPointToPdf, pxToPt } from "./pageSpace.js";
+import { collectUsage, paintPage } from "./paint.js";
+import { Result, TaggedError } from "better-result";
+import { createHash } from "node:crypto";
+//#region src/pdf/writePdf.ts
+/**
+* The PDF backend's entry point.
+*
+* Two calls with the same display list and the same timestamp produce the
+* same bytes. That is a hard requirement rather than a nicety: it is what
+* makes an export diffable, cacheable and comparable against a golden file,
+* and every design decision below that looks fussy (one number formatter,
+* resource names from sorted keys, a `/ID` hashed from the body, a fixed
+* deflate level) exists to keep it true. Nothing here reads a clock or a
+* random source.
+*/
+var WritePdfError = class extends TaggedError("WritePdfError") {};
+const DEFAULT_PRODUCER = "folio";
+/** How many code points the strict-coverage refusal names before counting. */
+const UNENCODABLE_SAMPLE = 5;
+const HEX_DIGITS = 4;
+const formatCodePoint = (codePoint) => `U+${codePoint.toString(16).toUpperCase().padStart(HEX_DIGITS, "0")}`;
+const describeUnencodable = (points) => {
+	const named = points.slice(0, UNENCODABLE_SAMPLE).map(({ codePoint }) => formatCodePoint(codePoint)).join(", ");
+	const rest = points.length - Math.min(points.length, UNENCODABLE_SAMPLE);
+	const suffix = rest === 0 ? "" : `, and ${String(rest)} more`;
+	return `no supplied face can encode ${String(points.length)} code point${points.length === 1 ? "" : "s"}: ${named}${suffix}`;
+};
+/** Every `/ProcSet` folio's own output can need. */
+const PROC_SET = [
+	"PDF",
+	"Text",
+	"ImageB",
+	"ImageC",
+	"ImageI"
+];
+const pad = (value, width) => String(value).padStart(width, "0");
+const YEAR_DIGITS = 4;
+const FIELD_DIGITS = 2;
+/**
+* `D:YYYYMMDDHHmmSS+00'00'`. The instant is written in UTC whatever offset
+* the caller's ISO string carried: one instant has one representation here,
+* so two callers who name the same moment get the same bytes.
+*/
+const formatPdfDate = (timestamp) => {
+	const milliseconds = Date.parse(timestamp);
+	if (Number.isNaN(milliseconds)) return Result.err(new WritePdfError({ message: `timestamp is not an ISO-8601 instant: ${timestamp}` }));
+	const date = new Date(milliseconds);
+	return Result.ok(`D:${pad(date.getUTCFullYear(), YEAR_DIGITS)}${pad(date.getUTCMonth() + 1, FIELD_DIGITS)}${pad(date.getUTCDate(), FIELD_DIGITS)}${pad(date.getUTCHours(), FIELD_DIGITS)}${pad(date.getUTCMinutes(), FIELD_DIGITS)}${pad(date.getUTCSeconds(), FIELD_DIGITS)}+00'00'`);
+};
+/**
+* A `/URI` is a byte string, so anything above ASCII is percent-encoded as
+* UTF-8 rather than written raw.
+*/
+const asciiUri = (href) => {
+	const LAST_ASCII = 126;
+	let out = "";
+	for (const character of href) out += (character.codePointAt(0) ?? 0) <= LAST_ASCII ? character : encodeURIComponent(character);
+	return out;
+};
+const buildImageObject = (document, samples) => {
+	const alphaRef = samples.alpha === void 0 ? void 0 : document.add(pdfFlateStream([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNumber(samples.widthPx)],
+		["Height", pdfNumber(samples.heightPx)],
+		["ColorSpace", pdfName("DeviceGray")],
+		["BitsPerComponent", pdfNumber(samples.alpha.bitsPerComponent)]
+	], samples.alpha.data));
+	const entries = [
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNumber(samples.widthPx)],
+		["Height", pdfNumber(samples.heightPx)],
+		["ColorSpace", samples.colorSpace],
+		["BitsPerComponent", pdfNumber(samples.bitsPerComponent)],
+		["Decode", samples.decode === void 0 ? void 0 : pdfNumberArray(samples.decode)],
+		["SMask", alphaRef]
+	];
+	return samples.encoding === "jpeg" ? document.add(pdfStream(pdfDict([...entries, ["Filter", pdfName("DCTDecode")]]), samples.data)) : document.add(pdfFlateStream(entries, samples.data));
+};
+const buildResources = ({ resources, fontRefs, imageRefs }) => {
+	const fontEntries = [...resources.fontNames].map(([resourceIndex, name]) => [name, fontRefs.get(resourceIndex)]);
+	const imageEntries = [...resources.imageNames].map(([imageIndex, name]) => [name, imageRefs.get(imageIndex)]);
+	const stateEntries = [...resources.extGStateNames].map(([alpha, name]) => [name, pdfDict([
+		["Type", pdfName("ExtGState")],
+		["ca", pdfNumber(Number(alpha))],
+		["CA", pdfNumber(Number(alpha))]
+	])]);
+	return pdfDict([
+		["ProcSet", pdfArray(PROC_SET.map(pdfName))],
+		["Font", fontEntries.length === 0 ? void 0 : pdfDict(fontEntries)],
+		["XObject", imageEntries.length === 0 ? void 0 : pdfDict(imageEntries)],
+		["ExtGState", stateEntries.length === 0 ? void 0 : pdfDict(stateEntries)]
+	]);
+};
+/**
+* `/XYZ` with a null x and zoom: the reader scrolls the point to the top of
+* the window and leaves the horizontal position and magnification alone.
+*/
+const buildDestination = ({ pageRefs, pages, pageIndex, yPx }) => {
+	const pageRef = pageRefs[pageIndex];
+	const page = pages[pageIndex];
+	if (pageRef === void 0 || page === void 0) return Result.err(new WritePdfError({ message: `destination names page ${String(pageIndex)}, which does not exist` }));
+	const point = displayPointToPdf(page.heightPx, 0, yPx);
+	return Result.ok(pdfArray([
+		pageRef,
+		pdfName("XYZ"),
+		pdfNull,
+		pdfNumber(point.y),
+		pdfNull
+	]));
+};
+const buildAnnotation = ({ document, link, page, pages, pageRefs }) => {
+	const topLeft = displayPointToPdf(page.heightPx, link.rect.xPx, link.rect.yPx);
+	const bottomRight = displayPointToPdf(page.heightPx, link.rect.xPx + link.rect.widthPx, link.rect.yPx + link.rect.heightPx);
+	let action;
+	let destination;
+	switch (link.target.kind) {
+		case "external":
+			action = pdfDict([["S", pdfName("URI")], ["URI", pdfAsciiString(asciiUri(link.target.href))]]);
+			break;
+		case "page": {
+			const built = buildDestination({
+				pageRefs,
+				pages,
+				pageIndex: link.target.pageIndex,
+				yPx: link.target.yPx
+			});
+			if (built.isErr()) return Result.err(built.error);
+			destination = built.value;
+			break;
+		}
+		default: {
+			const unreachable = link.target;
+			return Result.err(new WritePdfError({ message: `unhandled link target: ${JSON.stringify(unreachable)}` }));
+		}
+	}
+	return Result.ok(document.add(pdfDict([
+		["Type", pdfName("Annot")],
+		["Subtype", pdfName("Link")],
+		["Rect", pdfNumberArray([
+			Math.min(topLeft.x, bottomRight.x),
+			Math.min(topLeft.y, bottomRight.y),
+			Math.max(topLeft.x, bottomRight.x),
+			Math.max(topLeft.y, bottomRight.y)
+		])],
+		["Border", pdfNumberArray([
+			0,
+			0,
+			0
+		])],
+		["Contents", link.tooltip === void 0 ? void 0 : pdfTextString(link.tooltip)],
+		["A", action],
+		["Dest", destination]
+	])));
+};
+const buildOutlineTree = (entries, document) => {
+	const roots = [];
+	const ancestors = [];
+	for (const entry of entries) {
+		const node = {
+			entry,
+			children: [],
+			ref: document.allocate()
+		};
+		while ((ancestors.at(-1)?.entry.level ?? -1) >= entry.level) ancestors.pop();
+		const parent = ancestors.at(-1);
+		if (parent === void 0) roots.push(node);
+		else parent.children.push(node);
+		ancestors.push(node);
+	}
+	return roots;
+};
+/** Every node is open, so a node's `/Count` is its whole subtree. */
+const openDescendantCount = (nodes) => nodes.reduce((total, node) => total + 1 + openDescendantCount(node.children), 0);
+const defineOutlineNodes = ({ document, nodes, parentRef, pages, pageRefs }) => {
+	for (const [index, node] of nodes.entries()) {
+		const destination = buildDestination({
+			pageRefs,
+			pages,
+			pageIndex: node.entry.pageIndex,
+			yPx: node.entry.yPx
+		});
+		if (destination.isErr()) return destination.error;
+		const childCount = openDescendantCount(node.children);
+		document.define(node.ref, pdfDict([
+			["Title", pdfTextString(node.entry.title)],
+			["Parent", parentRef],
+			["Prev", nodes[index - 1]?.ref],
+			["Next", nodes[index + 1]?.ref],
+			["First", node.children.at(0)?.ref],
+			["Last", node.children.at(-1)?.ref],
+			["Count", childCount === 0 ? void 0 : pdfNumber(childCount)],
+			["Dest", destination.value]
+		]));
+		const error = defineOutlineNodes({
+			document,
+			nodes: node.children,
+			parentRef: node.ref,
+			pages,
+			pageRefs
+		});
+		if (error !== null) return error;
+	}
+	return null;
+};
+/**
+* Writes the display list as a PDF.
+*
+* Asynchronous for one reason: a run in a script that shapes needs the shaper,
+* and the shaper is fetched the first time a document actually contains one. A
+* document in Latin, Cyrillic or Greek never awaits anything but the resolved
+* promise this returns.
+*/
+const writePdf = async (list, options) => {
+	if (list.pages.length === 0) return Result.err(new WritePdfError({ message: "a PDF needs at least one page" }));
+	const stamp = formatPdfDate(options.timestamp);
+	if (stamp.isErr()) return Result.err(stamp.error);
+	const usage = collectUsage(list.pages, list.fonts.length, list.images.length);
+	if (usage.isErr()) return Result.err(new WritePdfError({
+		message: usage.error.message,
+		cause: usage.error
+	}));
+	const document = createPdfDocument();
+	const catalogRef = document.allocate();
+	const pagesRef = document.allocate();
+	const infoRef = document.allocate();
+	const pageRefs = list.pages.map(() => document.allocate());
+	const shaper = usage.value.shapedRunsByFont.size === 0 ? null : await getShaper();
+	const { byFontIndex, fontRefByResourceIndex, substitutions, unencodable } = prepareFonts({
+		document,
+		faces: list.fonts,
+		usedCodePoints: usage.value.codePointsByFont,
+		shapedRuns: usage.value.shapedRunsByFont,
+		shaper,
+		source: options.fonts
+	});
+	if (options.strictGlyphCoverage === true && unencodable.length > 0) return Result.err(new WritePdfError({ message: describeUnencodable(unencodable) }));
+	const imageRefs = /* @__PURE__ */ new Map();
+	for (const imageIndex of [...usage.value.imageIndices].sort((left, right) => left - right)) {
+		const source = list.images[imageIndex];
+		if (source === void 0) return Result.err(new WritePdfError({ message: `image ${String(imageIndex)} is outside the image table` }));
+		const decoded = decodeImage(source);
+		if (decoded.isErr()) return Result.err(new WritePdfError({
+			message: `image ${String(imageIndex)} could not be decoded: ${decoded.error.message}`,
+			cause: decoded.error
+		}));
+		imageRefs.set(imageIndex, buildImageObject(document, decoded.value));
+	}
+	const outlineRoots = buildOutlineTree(list.outline, document);
+	const outlineRef = outlineRoots.length === 0 ? void 0 : document.allocate();
+	for (const [pageIndex, page] of list.pages.entries()) {
+		const pageRef = pageRefs[pageIndex];
+		if (pageRef === void 0) return Result.err(new WritePdfError({ message: `page ${String(pageIndex)} lost its object` }));
+		const parts = paintPage({
+			page,
+			fonts: byFontIndex
+		});
+		const resources = collectResources(parts);
+		const contentRef = document.add(pdfFlateStream([], new TextEncoder().encode(renderContentStream(parts, resources))));
+		const annotationRefs = [];
+		for (const link of page.links) {
+			const annotation = buildAnnotation({
+				document,
+				link,
+				page,
+				pages: list.pages,
+				pageRefs
+			});
+			if (annotation.isErr()) return Result.err(annotation.error);
+			annotationRefs.push(annotation.value);
+		}
+		document.define(pageRef, pdfDict([
+			["Type", pdfName("Page")],
+			["Parent", pagesRef],
+			["MediaBox", pdfNumberArray([
+				0,
+				0,
+				pxToPt(page.widthPx),
+				pxToPt(page.heightPx)
+			])],
+			["Resources", buildResources({
+				resources,
+				fontRefs: fontRefByResourceIndex,
+				imageRefs
+			})],
+			["Contents", contentRef],
+			["Annots", annotationRefs.length === 0 ? void 0 : pdfArray(annotationRefs)]
+		]));
+	}
+	if (outlineRef !== void 0) {
+		const error = defineOutlineNodes({
+			document,
+			nodes: outlineRoots,
+			parentRef: outlineRef,
+			pages: list.pages,
+			pageRefs
+		});
+		if (error !== null) return Result.err(error);
+		document.define(outlineRef, pdfDict([
+			["Type", pdfName("Outlines")],
+			["First", outlineRoots.at(0)?.ref],
+			["Last", outlineRoots.at(-1)?.ref],
+			["Count", pdfNumber(openDescendantCount(outlineRoots))]
+		]));
+	}
+	document.define(pagesRef, pdfDict([
+		["Type", pdfName("Pages")],
+		["Kids", pdfArray(pageRefs)],
+		["Count", pdfNumber(pageRefs.length)]
+	]));
+	document.define(catalogRef, pdfDict([
+		["Type", pdfName("Catalog")],
+		["Pages", pagesRef],
+		["Outlines", outlineRef],
+		["PageMode", outlineRef === void 0 ? void 0 : pdfName("UseOutlines")]
+	]));
+	const { metadata } = list;
+	document.define(infoRef, pdfDict([
+		["Title", metadata.title === void 0 ? void 0 : pdfTextString(metadata.title)],
+		["Author", metadata.author === void 0 ? void 0 : pdfTextString(metadata.author)],
+		["Subject", metadata.subject === void 0 ? void 0 : pdfTextString(metadata.subject)],
+		["Keywords", metadata.keywords === void 0 ? void 0 : pdfTextString(metadata.keywords)],
+		["Producer", pdfTextString(options.producer ?? DEFAULT_PRODUCER)],
+		["CreationDate", pdfAsciiString(stamp.value)],
+		["ModDate", pdfAsciiString(stamp.value)]
+	]));
+	return Result.ok({
+		bytes: document.serialize({
+			rootRef: catalogRef,
+			infoRef,
+			idHex: (body) => createHash("sha256").update(body).digest("hex").toUpperCase()
+		}),
+		substitutions,
+		unencodable
+	});
+};
+//#endregion
+export { WritePdfError, writePdf };

package/dist/prosemirror/commands/comments.js

@@ -4,9 +4,11 @@ import { markStructuralChange } from "../extensions/features/ParagraphChangeTrac
 import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { TableMap, removeRow } from "prosemirror-tables";
+import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Add a comment mark to the current selection.
@@ -150,10 +152,36 @@ function resolveChange(from, to, mode, revisionIds) {
 					continue;
 				}
 				const joinPos = mappedPos + paragraph.nodeSize;
-				if (joinPos >= tr.doc.content.size) continue;
+				const nextNode = joinPos < tr.doc.content.size ? tr.doc.nodeAt(joinPos) : null;
+				if (!(nextNode?.type.name === paragraph.type.name && !(carriesSection(paragraph) && carriesSection(nextNode)))) {
+					const resolved = tr.doc.resolve(mappedPos);
+					const previous = resolved.nodeBefore;
+					const sectionCanMoveBack = !carriesSection(paragraph) || previous?.type.name === paragraph.type.name && !carriesSection(previous);
+					const endsItsContainer = resolved.index() === resolved.parent.childCount - 1;
+					const canGo = op.markWasAdded || !endsItsContainer;
+					if (sectionCanMoveBack && holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
+						if (carriesSection(paragraph) && previous) tr.setNodeMarkup(mappedPos - previous.nodeSize, void 0, {
+							...previous.attrs,
+							sectionBreakType: paragraph.attrs["sectionBreakType"],
+							_sectionProperties: paragraph.attrs["_sectionProperties"]
+						});
+						tr.delete(mappedPos, mappedPos + paragraph.nodeSize);
+						continue;
+					}
+					tr.setNodeAttribute(mappedPos, "pPrMark", null);
+					continue;
+				}
+				const formattingOwner = holdsNoContent(paragraph) ? nextNode : paragraph;
+				const sectionOwner = carriesSection(paragraph) ? paragraph : nextNode;
+				const joinedAttrs = {
+					...formattingOwner.attrs,
+					pPrMark: nextNode.attrs["pPrMark"],
+					sectionBreakType: sectionOwner.attrs["sectionBreakType"],
+					_sectionProperties: sectionOwner.attrs["_sectionProperties"]
+				};
 				try {
 					tr.join(joinPos);
-					tr.setNodeAttribute(mappedPos, "pPrMark", null);
+					tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
 				} catch {}
 			}
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
@@ -164,6 +192,12 @@ function resolveChange(from, to, mode, revisionIds) {
 				if (!row || row.type.name !== "tableRow") continue;
 				if (op.action === "clear") {
 					tr.setNodeAttribute(mappedPos, op.attrName, null);
+					clearTableRowContentMarks({
+						tr,
+						rowPos: mappedPos,
+						markType: keepType,
+						revision: op.revision
+					});
 					resolvedTableRowStructure = true;
 					continue;
 				}
@@ -229,7 +263,8 @@ function collectTableRowStructuralOp(node, rowPos, mode, revisionSet) {
 		return {
 			rowPos,
 			attrName,
-			action: attrName === "trIns" === (mode === "accept") ? "clear" : "remove"
+			action: attrName === "trIns" === (mode === "accept") ? "clear" : "remove",
+			revision: marker
 		};
 	}
 	return null;
@@ -237,6 +272,43 @@ function collectTableRowStructuralOp(node, rowPos, mode, revisionSet) {
 function isTableRowRevisionAttr(value) {
 	return typeof value === "object" && value !== null && "revisionId" in value && typeof value.revisionId === "number";
 }
+/**
+* Whether an inline revision mark inside a row belongs to that row's own
+* structural revision. Folio writes both halves under one id; Word mints a
+* fresh `w:id` per element, so an author + timestamp match counts too. A third
+* party's edit inside the same row matches neither and survives untouched.
+*/
+function markBelongsToRowRevision(mark, revision) {
+	if (mark.attrs["revisionId"] === revision.revisionId) return true;
+	return revision.author !== void 0 && mark.attrs["author"] === revision.author && (mark.attrs["date"] ?? null) === (revision.date ?? null);
+}
+/**
+* Clear the run-level revision marks a row's structural revision wrote.
+*
+* A tracked row insertion or deletion is marked twice — on the row and around
+* every run in its cells — so resolving one half and leaving the other would
+* hand back a row whose text still reads as inserted (or struck through) after
+* the change was accepted. Both halves resolve in the caller's transaction.
+*/
+function clearTableRowContentMarks({ tr, rowPos, markType, revision }) {
+	const row = tr.doc.nodeAt(rowPos);
+	if (!row || !markType) return;
+	const contentFrom = rowPos + 1;
+	const removals = [];
+	row.descendants((node, offset) => {
+		if (!node.isInline) return true;
+		for (const mark of node.marks) if (mark.type === markType && markBelongsToRowRevision(mark, revision)) {
+			const from = contentFrom + offset;
+			removals.push({
+				from,
+				to: from + node.nodeSize,
+				mark
+			});
+		}
+		return false;
+	});
+	for (const removal of removals) tr.removeMark(removal.from, removal.to, removal.mark);
+}
 function collectTableCellStructuralOps(node, cellPos, mode, revisionSet) {
 	const operations = [];
 	const marker = node.attrs["cellMarker"];
@@ -317,9 +389,11 @@ function collectPPrMarkOp(node, pos, from, to, mode, revisionSet) {
 	const pPrMark = node.attrs["pPrMark"];
 	if (!isPPrMarkAttr(pPrMark)) return null;
 	if (revisionSet !== null && !revisionSet.has(pPrMark.info.id)) return null;
+	const markWasAdded = paragraphMarkWasAdded(pPrMark.kind);
 	return {
 		paragraphPos: pos,
-		action: pPrMark.kind === "ins" === (mode === "accept") ? "clear" : "join"
+		action: markWasAdded === (mode === "accept") ? "clear" : "join",
+		markWasAdded
 	};
 }
 function rangeCoversParagraphBoundary(from, to, pos, node) {
@@ -374,10 +448,26 @@ function isPPrMarkAttr(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const kind = value.kind;
 	const info = value.info;
-	if (kind !== "ins" && kind !== "del") return false;
+	if (!PARAGRAPH_MARK_CHANGE_KINDS.some((allowed) => allowed === kind)) return false;
 	if (typeof info !== "object" || info === null) return false;
 	return typeof info.id === "number";
 }
+/**
+* Whether the mark says the paragraph break was ADDED. A relocation's
+* destination break was added exactly as an insertion's was, and its source
+* break went exactly as a deletion's did; the kinds differ so a reader is told
+* the two ends belong together, not because they resolve differently.
+*/
+const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
+/**
+* Whether the paragraph's mark carries a section's properties.
+*
+* A section break lives on a paragraph mark, so the paragraph is where the
+* section ends. Removing it removes the section: a document that had two ends
+* up with one, and every setting the dropped section carried — page size,
+* margins, its header and footer references — goes with it.
+*/
+const carriesSection = (paragraph) => paragraph.attrs["sectionBreakType"] != null || paragraph.attrs["_sectionProperties"] != null;
 function readRevisionInfo(info) {
 	const revision = {};
 	if (typeof info?.author === "string") revision.author = info.author;
@@ -417,7 +507,7 @@ function findParagraphBoundaryChangeAtPosition(state, pos) {
 	if (node.type.name !== "paragraph") return null;
 	const paragraphPos = $pos.before($pos.depth);
 	const pPrMark = node.attrs["pPrMark"];
-	if (isPPrMarkAttr(pPrMark)) return toParagraphBoundaryChange(node, paragraphPos, pPrMark.kind === "ins" ? "insertion" : "deletion", pPrMark.info);
+	if (isPPrMarkAttr(pPrMark)) return toParagraphBoundaryChange(node, paragraphPos, paragraphMarkWasAdded(pPrMark.kind) ? "insertion" : "deletion", pPrMark.info);
 	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 	if (!Array.isArray(propertyChanges)) return null;
 	for (const change of propertyChanges) {

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -666,25 +666,26 @@ function paragraphAttrsToFormatting(attrs) {
 	return f;
 }
 function createTrackedRunWrapper(type, info, child) {
+	const content = child ? [child] : [];
 	if (type === "insertion") return {
 		type,
 		info,
-		content: [child]
+		content
 	};
 	if (type === "deletion") return {
 		type,
 		info,
-		content: [child]
+		content
 	};
 	if (type === "moveFrom") return {
 		type,
 		info,
-		content: [child]
+		content
 	};
 	return {
 		type,
 		info,
-		content: [child]
+		content
 	};
 }
 function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false) {
@@ -824,16 +825,19 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			const trackedChangeKey = `${type}:${JSON.stringify(info)}`;
 			if (linkMark) {
 				const linkKey = getLinkKey(linkMark);
-				if (!currentTrackedChange || currentTrackedChange.key !== trackedChangeKey || currentTrackedChange.hyperlinkKey !== linkKey) {
+				if (!currentTrackedChange || currentTrackedChange.type !== "hyperlink" || currentTrackedChange.key !== trackedChangeKey || currentTrackedChange.hyperlinkKey !== linkKey) {
 					const hyperlink = createHyperlink(linkMark);
 					const wrapper = createTrackedRunWrapper(type, info, hyperlink);
 					content.push(wrapper);
 					currentTrackedChange = {
+						type: "hyperlink",
 						key: trackedChangeKey,
+						wrapper,
 						hyperlink,
 						hyperlinkKey: linkKey
 					};
 				}
+				if (currentTrackedChange.type !== "hyperlink") panic("A tracked hyperlink lost its serialization parent");
 				if (node.type.name === "bookmarkBoundary") {
 					addNodeToHyperlink({
 						hyperlink: currentTrackedChange.hyperlink,
@@ -850,13 +854,43 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				if (run) currentTrackedChange.hyperlink.children.push(run);
 				return;
 			}
-			currentTrackedChange = void 0;
+			if (!currentTrackedChange || currentTrackedChange.type !== "direct" || currentTrackedChange.key !== trackedChangeKey) {
+				const wrapper = createTrackedRunWrapper(type, info);
+				content.push(wrapper);
+				currentTrackedChange = {
+					type: "direct",
+					key: trackedChangeKey,
+					wrapper
+				};
+			}
+			if (node.type.name === "bookmarkBoundary") {
+				const attrs = expectBookmarkBoundaryAttrs(node);
+				const boundary = attrs.type === "start" ? {
+					type: "bookmarkStart",
+					id: attrs.id,
+					name: attrs.name,
+					...attrs.colFirst !== void 0 ? { colFirst: attrs.colFirst } : {},
+					...attrs.colLast !== void 0 ? { colLast: attrs.colLast } : {}
+				} : {
+					type: "bookmarkEnd",
+					id: attrs.id
+				};
+				currentTrackedChange.wrapper.content.push(boundary);
+				return;
+			}
+			if (node.type.name === "field" || node.type.name === "structuredField") {
+				currentTrackedChange.wrapper.content.push(createFieldFromNode(node, {
+					marks: otherMarks,
+					textBoxAnchorMarkers
+				}));
+				return;
+			}
 			const run = createTrackedChangeRun({
 				inheritedFormatting,
 				marks: otherMarks,
 				node
 			});
-			if (run) content.push(createTrackedRunWrapper(type, info, run));
+			if (run) currentTrackedChange.wrapper.content.push(run);
 			return;
 		}
 		if (noteRefMark && !linkMark) {