@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/replacedAnnotations.js

@@ -0,0 +1,183 @@
+import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
+import { COMMENT_REFERENCE_NODE_NAME } from "./extensions/nodes/CommentReferenceExtension.js";
+import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBoundaryExtension.js";
+import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
+import { TEXT_BOX_ANCHOR_NODE_NAME } from "./extensions/nodes/TextBoxAnchorExtension.js";
+import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { Fragment, Mark } from "prosemirror-model";
+//#region src/prosemirror/replacedAnnotations.ts
+/**
+* What survives when an edit replaces a span of inline content.
+*
+* ProseMirror gives a replacement the marks it inherits at the boundary, and
+* drops any mark declared `inclusive: false` once the span reaches the end of
+* what that mark covers. For formatting that is right. For a mark that names
+* something outside itself — the comment this text is commented by, the
+* address this text links to — it is not: the target survives the edit, and
+* only the mark saying so is lost. A comment loses the range start that lived
+* on the replaced text, so the save emits a `commentRangeEnd` with no
+* `commentRangeStart`, invalid OOXML and a comment anchored to nothing; a
+* hyperlink simply stops being a link. Zero-width anchors fare worse still: a
+* plain replace deletes them outright.
+*
+* Word moves a range start that sits inside a replaced span to the beginning
+* of the replacement and lets the range keep covering the new text; it keeps
+* a link across a replacement of its display text. A range wholly inside the
+* span collapses onto the replacement, and disappears only when every
+* character it covered is gone. One rule per marker kind, and that is the
+* whole contract:
+*
+* - `comment` mark: the replacement carries every comment the span covered, so
+*   a range that started inside it starts at the replacement instead.
+* - `hyperlink` mark: the replacement carries the first link the span held, so
+*   replacing a link's display text leaves the link on the new text. A span
+*   crossing two links keeps the one it opens in, because the mark excludes
+*   itself and a replacement is one run of text with one address.
+* - `footnoteRef` mark (footnotes and endnotes alike): not carried. It marks
+*   the reference's own number, not prose around it, and it serializes as a
+*   bare `w:footnoteReference` run, so carrying it onto a replacement would
+*   discard the new text. Replacing a reference's text deletes the reference,
+*   as deleting that text does.
+* - `runIdentity` mark: not carried. It is one authored run's identity and the
+*   markup that run carried, not a target. A replacement is characters the
+*   session named by its `w:rsidR` did not write, so carrying it would fuse
+*   the replacement into a run it was never part of and stamp it with an
+*   editing session it did not belong to.
+* - tracked-change marks (`insertion`, `deletion`, `runPropertyChange`): not
+*   carried. The applier decides them per edit mode and writes them itself.
+* - `inlineWrapper` mark: not carried. Every wrapper kind states something
+*   about the text under it and names nothing outside itself, so boundary
+*   inheritance is the right rule: a replacement inside a bidirectional
+*   override is still inside it, and one that replaces the whole of it is not.
+* - `commentReference` node: kept after the replacement, where the comment's
+*   last covered position now is.
+* - `rangeAnchor` node: kept after the replacement. A comment or move range
+*   that spans no content has no mark to carry, so replacing the words around
+*   a point comment would otherwise delete the comment outright.
+* - `moveRangeBoundary` node: a start kept before the replacement, an end
+*   after it, so replacing a moved span keeps that range's identity and scope.
+* - `bookmarkBoundary` node: a start kept before the replacement, an end after
+*   it, so the bookmark still covers the new text.
+* - `textBoxAnchor` node: kept after the replacement; the shape it anchors
+*   outlives the sentence it was typed into.
+* - `renderedPageBreak` node: dropped with the text. It is Word's cached
+*   pagination, re-derived on layout, and nothing else names it.
+* - every other mark: formatting, and left to boundary inheritance, which
+*   already gives the replacement the formatting of the text it replaces.
+*
+* Deleting the whole of a comment's span leaves it no mark anywhere, so
+* `CommentReferenceExtension` drops the orphan reference and the save drops
+* the comment: the one case where a range is meant to disappear.
+*/
+/**
+* What a replacement does with each mark the schema declares
+* `inclusive: false`. Boundary inheritance already handles every other mark,
+* so this table is exactly the set that needs a decision; a new
+* non-inclusive mark that is missing from it fails
+* `replacedAnnotations.test.ts` rather than silently following the text.
+*/
+const NON_INCLUSIVE_MARK_DISPOSITION = {
+	comment: "carry",
+	hyperlink: "carry",
+	footnoteRef: "followsTheText",
+	runIdentity: "followsTheText",
+	insertion: "followsTheText",
+	deletion: "followsTheText",
+	runPropertyChange: "followsTheText",
+	inlineWrapper: "followsTheText"
+};
+/** The mark names in the schema that a replacement must not silently drop. */
+const nonInclusiveMarkNames = (schema) => Object.entries(schema.marks).filter(([, type]) => type.spec.inclusive === false).map(([name]) => name);
+const isCarried = (mark) => NON_INCLUSIVE_MARK_DISPOSITION[mark.type.name] === "carry";
+/** Anchors an edit must put back, and where relative to the replacement. */
+const ANCHOR_PLACEMENT = {
+	[COMMENT_REFERENCE_NODE_NAME]: "after",
+	[RANGE_ANCHOR_NODE_NAME]: "after",
+	[TEXT_BOX_ANCHOR_NODE_NAME]: "after",
+	[BOOKMARK_BOUNDARY_NODE_NAME]: "byBoundaryType",
+	[MOVE_RANGE_BOUNDARY_NODE_NAME]: "byMoveBoundaryType"
+};
+const anchorPlacement = (node) => ANCHOR_PLACEMENT[node.type.name];
+const opensRange = (node, placement) => {
+	if (placement === "byBoundaryType") return node.attrs["type"] === "start";
+	if (placement !== "byMoveBoundaryType") return false;
+	const marker = readMoveRangeBoundaryAttrs(node);
+	return marker.ok && marker.value.type.endsWith("Start");
+};
+const NOTHING_REPLACED = {
+	carried: [],
+	leading: [],
+	trailing: []
+};
+const hasReplacedAnnotations = ({ carried, leading, trailing }) => carried.length > 0 || leading.length > 0 || trailing.length > 0;
+/**
+* The annotations carried by `[from, to)`. An anchor counts only when the
+* range covers it whole: a partially covered atom is not deleted by the
+* replacement either.
+*/
+const surveyReplacedAnnotations = (doc, from, to) => {
+	if (to <= from) return NOTHING_REPLACED;
+	const carried = [];
+	const leading = [];
+	const trailing = [];
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isInline) return true;
+		for (const mark of node.marks) if (isCarried(mark) && !alreadyCarried(mark, carried)) carried.push(mark);
+		const placement = anchorPlacement(node);
+		if (placement === void 0 || position < from || position + node.nodeSize > to) return false;
+		(opensRange(node, placement) ? leading : trailing).push(node);
+		return false;
+	});
+	return {
+		carried,
+		leading,
+		trailing
+	};
+};
+/**
+* Whether the span already contributed this mark, or one the mark would evict.
+* Comments do not exclude each other, so every comment is collected; a
+* hyperlink excludes its own type, so the first address in the span wins
+* rather than the last silently overwriting it.
+*/
+const alreadyCarried = (mark, carried) => carried.some((other) => other.eq(mark) || mark.type.excludes(other.type));
+const anchorsSize = (anchors) => {
+	let size = 0;
+	for (const node of anchors) size += node.nodeSize;
+	return size;
+};
+/** `marks` with the carried marks added, each type's exclusions respected. */
+const addCarriedMarks = (marks, carried) => {
+	let next = marks;
+	for (const mark of carried) next = mark.addToSet(next);
+	return next;
+};
+const withCarriedMarks = (node, carried) => node.mark(addCarriedMarks(node.marks, carried));
+/** `content` with the surveyed marks on it and the surveyed anchors around it. */
+const annotatedReplacement = ({ annotations: { carried, leading, trailing }, content }) => {
+	const inline = [];
+	content.forEach((child) => {
+		inline.push(carried.length === 0 ? child : withCarriedMarks(child, carried));
+	});
+	const fragment = Fragment.fromArray([
+		...leading,
+		...inline,
+		...trailing
+	]);
+	const leadingSize = anchorsSize(leading);
+	return {
+		fragment,
+		leadingSize,
+		contentSize: fragment.size - leadingSize - anchorsSize(trailing)
+	};
+};
+/**
+* The marks a replacement inherits at `[from, to)`, exactly as
+* `Transaction.insertText` would compute them.
+*/
+const inheritedReplacementMarks = (doc, from, to) => {
+	const $from = doc.resolve(from);
+	return (to === from ? $from.marks() : $from.marksAcross(doc.resolve(to))) ?? Mark.none;
+};
+//#endregion
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };

package/dist/prosemirror/revisionCarriers.d.ts

@@ -1,6 +1,76 @@
 import { Node } from "prosemirror-model";
+import { PropertyRevisionKind } from "@stll/docx-core/model";
 //#region src/prosemirror/revisionCarriers.d.ts
-type FolioNodeRevisionKind = "paragraphMarkInserted" | "paragraphMarkDeleted" | "paragraphPropertiesChanged" | "sectionPropertiesChanged" | "tablePropertiesChanged" | "rowPropertiesChanged" | "cellPropertiesChanged";
+declare const PROPERTY_REVISION_SITES: {
+  readonly runPropertyChange: {
+    readonly kind: "runPropertyChange";
+    readonly resolution: "inline-mark";
+  };
+  readonly paragraphPropertyChange: {
+    readonly kind: "paragraphPropertyChange";
+    readonly resolution: "paragraph-pass";
+    readonly nodeTypes: readonly ["paragraph"];
+    readonly path: readonly ["_propertyChanges"];
+    readonly carrier: "paragraphPropertiesChanged";
+    readonly range: "paragraph-boundary";
+  };
+  readonly sectionPropertyChange: {
+    readonly kind: "sectionPropertyChange";
+    readonly resolution: "paragraph-pass";
+    readonly nodeTypes: readonly ["paragraph"];
+    readonly path: readonly ["_sectionProperties", "propertyChanges"];
+    readonly carrier: "sectionPropertiesChanged";
+    readonly range: "paragraph-boundary";
+  };
+  readonly tablePropertyChange: {
+    readonly kind: "tablePropertyChange";
+    readonly resolution: "node-attrs";
+    readonly nodeTypes: readonly ["table"];
+    readonly attr: "tblPrChange";
+    readonly carrier: "tablePropertiesChanged";
+    readonly range: "whole-node";
+  };
+  readonly tablePropertyExceptionChange: {
+    readonly kind: "tablePropertyExceptionChange";
+    readonly resolution: "node-attrs";
+    readonly nodeTypes: readonly ["tableRow"];
+    readonly attr: "tblPrExChange";
+    readonly carrier: "tablePropertyExceptionsChanged";
+    readonly range: "whole-node";
+  };
+  readonly tableRowPropertyChange: {
+    readonly kind: "tableRowPropertyChange";
+    readonly resolution: "node-attrs";
+    readonly nodeTypes: readonly ["tableRow"];
+    readonly attr: "trPrChange";
+    readonly carrier: "rowPropertiesChanged";
+    readonly range: "whole-node";
+  };
+  readonly tableCellPropertyChange: {
+    readonly kind: "tableCellPropertyChange";
+    readonly resolution: "node-attrs";
+    readonly nodeTypes: readonly ["tableCell", "tableHeader"];
+    readonly attr: "tcPrChange";
+    readonly carrier: "cellPropertiesChanged";
+    readonly range: "whole-node";
+  };
+};
+type SiteOf<TKind extends PropertyRevisionKind> = (typeof PROPERTY_REVISION_SITES)[TKind];
+/** One property revision carried on a node's attrs rather than on a mark. */
+type NodePropertyRevisionSite = Extract<SiteOf<PropertyRevisionKind>, {
+  carrier: string;
+}>;
+/** The sites the shared node-attr pass resolves, and therefore must patch. */
+type NodeAttrsPropertyRevisionSite = Extract<NodePropertyRevisionSite, {
+  resolution: "node-attrs";
+}>;
+/** The kinds that pass resolves. */
+type NodeAttrsPropertyRevisionKind = NodeAttrsPropertyRevisionSite["kind"];
+/** The reviewer-facing name of a property revision carried on a node. */
+type PropertyRevisionCarrier = NodePropertyRevisionSite["carrier"];
+type FolioNodeRevisionKind = "paragraphMarkInserted" | "paragraphMarkDeleted" | PropertyRevisionCarrier;
+/** The property revisions a PM node of this type can carry, in element order. */
+declare const nodePropertyRevisionSites: (nodeTypeName: string) => NodePropertyRevisionSite[];
 type FolioNodeRevisionCarrier = {
   id: number;
   type: FolioNodeRevisionKind;
@@ -10,10 +80,24 @@ type FolioNodeRevisionCarrier = {
   from: number;
   to: number;
 };
+type RevisionMetadata = Pick<FolioNodeRevisionCarrier, "id" | "author" | "date">;
+/** The `w:id`, author and date a stored revision's `info` carries, or null. */
+declare const propertyRevisionMetadata: (value: unknown) => RevisionMetadata | null;
+/**
+ * A stored property-revision record as ProseMirror attrs carry it. The
+ * previous property set is whatever the site's own element stores, which the
+ * reject patch filed under that kind narrows.
+ */
+type StoredPropertyRevision = {
+  info?: unknown;
+  previousFormatting?: unknown;
+};
+/** The record array a site names, walked from a node's attrs. */
+declare const propertyRevisionRecords: (node: Node, site: NodePropertyRevisionSite) => StoredPropertyRevision[];
 /**
  * Read revision records stored on ProseMirror node attributes and return the
  * exact range the shared accept/reject command requires for each carrier.
  */
 declare const getFolioNodeRevisionCarriers: (node: Node, nodePos: number) => FolioNodeRevisionCarrier[];
 //#endregion
-export { FolioNodeRevisionCarrier, FolioNodeRevisionKind, getFolioNodeRevisionCarriers };
+export { FolioNodeRevisionCarrier, FolioNodeRevisionKind, NodeAttrsPropertyRevisionKind, NodeAttrsPropertyRevisionSite, NodePropertyRevisionSite, PROPERTY_REVISION_SITES, PropertyRevisionCarrier, StoredPropertyRevision, getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords };

package/dist/prosemirror/revisionCarriers.js

@@ -1,6 +1,62 @@
-import { expectParagraphAttrs } from "./attrs/index.js";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 //#region src/prosemirror/revisionCarriers.ts
+const PROPERTY_REVISION_SITES = {
+	runPropertyChange: {
+		kind: "runPropertyChange",
+		resolution: "inline-mark"
+	},
+	paragraphPropertyChange: {
+		kind: "paragraphPropertyChange",
+		resolution: "paragraph-pass",
+		nodeTypes: ["paragraph"],
+		path: ["_propertyChanges"],
+		carrier: "paragraphPropertiesChanged",
+		range: "paragraph-boundary"
+	},
+	sectionPropertyChange: {
+		kind: "sectionPropertyChange",
+		resolution: "paragraph-pass",
+		nodeTypes: ["paragraph"],
+		path: ["_sectionProperties", "propertyChanges"],
+		carrier: "sectionPropertiesChanged",
+		range: "paragraph-boundary"
+	},
+	tablePropertyChange: {
+		kind: "tablePropertyChange",
+		resolution: "node-attrs",
+		nodeTypes: ["table"],
+		attr: "tblPrChange",
+		carrier: "tablePropertiesChanged",
+		range: "whole-node"
+	},
+	tablePropertyExceptionChange: {
+		kind: "tablePropertyExceptionChange",
+		resolution: "node-attrs",
+		nodeTypes: ["tableRow"],
+		attr: "tblPrExChange",
+		carrier: "tablePropertyExceptionsChanged",
+		range: "whole-node"
+	},
+	tableRowPropertyChange: {
+		kind: "tableRowPropertyChange",
+		resolution: "node-attrs",
+		nodeTypes: ["tableRow"],
+		attr: "trPrChange",
+		carrier: "rowPropertiesChanged",
+		range: "whole-node"
+	},
+	tableCellPropertyChange: {
+		kind: "tableCellPropertyChange",
+		resolution: "node-attrs",
+		nodeTypes: ["tableCell", "tableHeader"],
+		attr: "tcPrChange",
+		carrier: "cellPropertiesChanged",
+		range: "whole-node"
+	}
+};
+const NODE_PROPERTY_REVISION_SITES = Object.values(PROPERTY_REVISION_SITES).flatMap((site) => site.resolution === "inline-mark" ? [] : [site]);
+/** The property revisions a PM node of this type can carry, in element order. */
+const nodePropertyRevisionSites = (nodeTypeName) => NODE_PROPERTY_REVISION_SITES.filter(({ nodeTypes }) => nodeTypes.some((name) => name === nodeTypeName));
 /**
 * Which carrier each paragraph-mark kind reports as. A relocation's break
 * resolves as the insertion or deletion it is; the kind exists so a reader is
@@ -17,7 +73,8 @@ const PARAGRAPH_MARK_KIND_CARRIERS = {
 };
 const isParagraphMarkChangeKind = (value) => PARAGRAPH_MARK_CHANGE_KINDS.some((kind) => kind === value);
 const isObjectRecord = (value) => typeof value === "object" && value !== null;
-const revisionMetadata = (value) => {
+/** The `w:id`, author and date a stored revision's `info` carries, or null. */
+const propertyRevisionMetadata = (value) => {
 	if (!isObjectRecord(value) || typeof value["id"] !== "number") return null;
 	return {
 		id: value["id"],
@@ -25,12 +82,21 @@ const revisionMetadata = (value) => {
 		date: typeof value["date"] === "string" ? value["date"] : null
 	};
 };
+/** The record array a site names, walked from a node's attrs. */
+const propertyRevisionRecords = (node, site) => {
+	const path = site.resolution === "node-attrs" ? [site.attr] : site.path;
+	let value = node.attrs;
+	for (const key of path) {
+		if (!isObjectRecord(value)) return [];
+		value = value[key];
+	}
+	return Array.isArray(value) ? value.filter(isObjectRecord) : [];
+};
 const appendPropertyCarriers = ({ carriers, changes, type, node, from, to }) => {
-	if (!Array.isArray(changes)) return;
 	let text = null;
 	for (const change of changes) {
 		if (!isObjectRecord(change)) continue;
-		const metadata = revisionMetadata(change["info"]);
+		const metadata = propertyRevisionMetadata(change["info"]);
 		if (!metadata) continue;
 		text ??= node.textContent;
 		carriers.push({
@@ -49,76 +115,36 @@ const appendPropertyCarriers = ({ carriers, changes, type, node, from, to }) =>
 const getFolioNodeRevisionCarriers = (node, nodePos) => {
 	const carriers = [];
 	if (node.type.name === "paragraph") {
-		const from = nodePos + node.nodeSize - 1;
-		const to = nodePos + node.nodeSize;
-		const paragraphAttrs = expectParagraphAttrs(node);
 		const paragraphMark = node.attrs["pPrMark"];
 		const paragraphMarkKind = isObjectRecord(paragraphMark) && isParagraphMarkChangeKind(paragraphMark["kind"]) ? PARAGRAPH_MARK_KIND_CARRIERS[paragraphMark["kind"]] : void 0;
 		if (paragraphMarkKind !== void 0 && isObjectRecord(paragraphMark)) {
-			const metadata = revisionMetadata(paragraphMark["info"]);
+			const metadata = propertyRevisionMetadata(paragraphMark["info"]);
 			if (metadata) carriers.push({
 				...metadata,
 				type: paragraphMarkKind,
 				text: node.textContent,
-				from,
-				to
+				from: nodePos + node.nodeSize - 1,
+				to: nodePos + node.nodeSize
 			});
 		}
+	}
+	for (const site of nodePropertyRevisionSites(node.type.name)) {
+		const range = site.range === "paragraph-boundary" ? {
+			from: nodePos + node.nodeSize - 1,
+			to: nodePos + node.nodeSize
+		} : {
+			from: nodePos,
+			to: nodePos + node.nodeSize
+		};
 		appendPropertyCarriers({
 			carriers,
-			changes: paragraphAttrs._propertyChanges,
-			type: "paragraphPropertiesChanged",
-			node,
-			from,
-			to
-		});
-		const sectionProperties = node.attrs["_sectionProperties"];
-		appendPropertyCarriers({
-			carriers,
-			changes: isObjectRecord(sectionProperties) ? sectionProperties["propertyChanges"] : null,
-			type: "sectionPropertiesChanged",
+			changes: propertyRevisionRecords(node, site),
+			type: site.carrier,
 			node,
-			from,
-			to
+			...range
 		});
-		return carriers;
-	}
-	const range = {
-		from: nodePos,
-		to: nodePos + node.nodeSize
-	};
-	switch (node.type.name) {
-		case "table":
-			appendPropertyCarriers({
-				carriers,
-				changes: node.attrs["tblPrChange"],
-				type: "tablePropertiesChanged",
-				node,
-				...range
-			});
-			break;
-		case "tableRow":
-			appendPropertyCarriers({
-				carriers,
-				changes: node.attrs["trPrChange"],
-				type: "rowPropertiesChanged",
-				node,
-				...range
-			});
-			break;
-		case "tableCell":
-		case "tableHeader":
-			appendPropertyCarriers({
-				carriers,
-				changes: node.attrs["tcPrChange"],
-				type: "cellPropertiesChanged",
-				node,
-				...range
-			});
-			break;
-		default: break;
 	}
 	return carriers;
 };
 //#endregion
-export { getFolioNodeRevisionCarriers };
+export { PROPERTY_REVISION_SITES, getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords };

package/dist/prosemirror/runFormattingInlineCarriers.d.ts

@@ -1,7 +1,7 @@
 import { Transaction } from "prosemirror-state";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/runFormattingInlineCarriers.d.ts
-type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
+type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
 /**
  * How every inline atom maps to a serialized run-formatting carrier.
  *
@@ -12,11 +12,15 @@ type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run
  */
 declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly bookmarkBoundary: "not-a-run";
+  readonly commentReference: "not-a-run";
   readonly field: "field-run";
   readonly hardBreak: "break-run";
   readonly image: "not-a-run";
   readonly math: "not-a-run";
+  readonly moveRangeBoundary: "not-a-run";
   readonly pageBreakRun: "page-break-carrier";
+  readonly preservedXml: "preserved-xml-run";
+  readonly rangeAnchor: "not-a-run";
   readonly renderedPageBreak: "not-a-run";
   readonly shape: "not-a-run";
   readonly structuredField: "structured-field";

package/dist/prosemirror/runFormattingInlineCarriers.js

@@ -1,5 +1,5 @@
 import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
-import { expectFieldAttrs, expectSymbolAttrs } from "./attrs/index.js";
+import { expectFieldAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "./attrs/index.js";
 import { panic } from "better-result";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingInlineCarriers.ts
@@ -13,11 +13,15 @@ import { Mark } from "prosemirror-model";
 */
 const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	bookmarkBoundary: "not-a-run",
+	commentReference: "not-a-run",
 	field: "field-run",
 	hardBreak: "break-run",
 	image: "not-a-run",
 	math: "not-a-run",
+	moveRangeBoundary: "not-a-run",
 	pageBreakRun: "page-break-carrier",
+	preservedXml: "preserved-xml-run",
+	rangeAnchor: "not-a-run",
 	renderedPageBreak: "not-a-run",
 	shape: "not-a-run",
 	structuredField: "structured-field",
@@ -32,6 +36,7 @@ const CONTROL_CHARACTER_BY_DISPOSITION = Object.freeze({
 	"field-run": null,
 	"not-a-run": null,
 	"page-break-carrier": null,
+	"preserved-xml-run": null,
 	"structured-field": null,
 	"symbol-run": null,
 	"tab-run": "	",
@@ -162,6 +167,7 @@ const runFormattingCarrierReviewText = (carrier) => {
 			const { char } = expectSymbolAttrs(carrier.node);
 			return decodeOoxmlSymbolCharacter(char) ?? "�";
 		}
+		case "preserved-xml-run": return expectPreservedXmlAttrs(carrier.node).text;
 		case "field-run":
 		case "structured-field": return expectFieldAttrs(carrier.node).displayText ?? carrier.node.textContent;
 	}

package/dist/prosemirror/runIdentity.d.ts

@@ -0,0 +1,28 @@
+import { document_d_exports } from "../types/document.js";
+import { RunIdentityMarkAttrs } from "./schema/marks.js";
+//#region src/prosemirror/runIdentity.d.ts
+/** The DOM attribute that carries a run's identity through copy and paste. */
+declare const RUN_IDENTITY_ATTRIBUTE = "data-docx-run-identity";
+/** The schema name of the mark these attrs belong to. */
+declare const RUN_IDENTITY_MARK_NAME = "runIdentity";
+/**
+ * What a run carries beside its id: absent fields left absent, empty
+ * collections normalised to absent so a run with nothing to carry keys the
+ * same however it was built.
+ */
+type RunIdentityPayload = {
+  preservedAttributes?: readonly document_d_exports.PreservedAttribute[] | undefined;
+  preserved?: document_d_exports.PreservedMarkup | undefined;
+};
+/** A run identity's attrs in canonical form. */
+declare const runIdentityAttrs: (id: number, { preservedAttributes, preserved }?: RunIdentityPayload) => RunIdentityMarkAttrs;
+/**
+ * Whether a run holds markup the mark exists to carry.
+ *
+ * The mint condition, minus the page break: a run with neither remainder nor
+ * sink and no break to rejoin its leaves across needs no identity, and 57.5%
+ * of corpus files hold none.
+ */
+declare const hasRunIdentityPayload: ({ preservedAttributes, preserved }: RunIdentityPayload) => boolean;
+//#endregion
+export { RUN_IDENTITY_ATTRIBUTE, RUN_IDENTITY_MARK_NAME, RunIdentityPayload, hasRunIdentityPayload, runIdentityAttrs };

package/dist/prosemirror/runIdentity.js

@@ -0,0 +1,36 @@
+//#region src/prosemirror/runIdentity.ts
+/** The DOM attribute that carries a run's identity through copy and paste. */
+const RUN_IDENTITY_ATTRIBUTE = "data-docx-run-identity";
+/** The schema name of the mark these attrs belong to. */
+const RUN_IDENTITY_MARK_NAME = "runIdentity";
+/** One remainder entry with its keys in canonical order. */
+const preservedAttribute = ({ namespace, name, value }) => namespace === void 0 ? {
+	name,
+	value
+} : {
+	namespace,
+	name,
+	value
+};
+/** The property-set sink with its keys in canonical order. */
+const preservedMarkup = ({ children }) => ({ children: (children ?? []).map(({ index, xml }) => ({
+	index,
+	xml
+})) });
+/** A run identity's attrs in canonical form. */
+const runIdentityAttrs = (id, { preservedAttributes, preserved } = {}) => {
+	const attrs = { id };
+	if (preservedAttributes && preservedAttributes.length > 0) attrs.preservedAttributes = preservedAttributes.map(preservedAttribute);
+	if (preserved && (preserved.children?.length ?? 0) > 0) attrs.preserved = preservedMarkup(preserved);
+	return attrs;
+};
+/**
+* Whether a run holds markup the mark exists to carry.
+*
+* The mint condition, minus the page break: a run with neither remainder nor
+* sink and no break to rejoin its leaves across needs no identity, and 57.5%
+* of corpus files hold none.
+*/
+const hasRunIdentityPayload = ({ preservedAttributes, preserved }) => (preservedAttributes?.length ?? 0) > 0 || (preserved?.children?.length ?? 0) > 0;
+//#endregion
+export { RUN_IDENTITY_ATTRIBUTE, RUN_IDENTITY_MARK_NAME, hasRunIdentityPayload, runIdentityAttrs };

package/dist/prosemirror/runStyleFormatting.js

@@ -21,7 +21,7 @@ const hasDirectRunFormatting = (formatting) => {
 	return Object.entries(formatting).some(([property, value]) => property !== "styleId" && value !== void 0);
 };
 const stripParagraphMarkOnlyFormatting = (formatting) => {
-	const { allCaps: _allCaps, highlight: _highlight, shading: _shading, smallCaps: _smallCaps, vertAlign: _vertAlign, ...formattingForBody } = formatting;
+	const { allCaps: _allCaps, highlight: _highlight, shading: _shading, smallCaps: _smallCaps, vertAlign: _vertAlign, preserved: _preserved, ...formattingForBody } = formatting;
 	return Object.keys(formattingForBody).length > 0 ? formattingForBody : void 0;
 };
 const stripParagraphMarkFormattingForBodyRuns = (formatting) => {

package/dist/prosemirror/schema/index.d.ts

@@ -1,5 +1,5 @@
-import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
-import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperKind, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
+import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
 import { ExtensionManager } from "../extensions/ExtensionManager.js";
 //#region src/prosemirror/schema/index.d.ts
 declare const singletonManager: ExtensionManager;
@@ -11,4 +11,4 @@ type DocxSchema = typeof schema;
 type DocxNode = ReturnType<typeof schema.node>;
 type DocxMark = ReturnType<typeof schema.mark>;
 //#endregion
-export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type PageBreakRunOwnerMarkAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };
+export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type InlineWrapperAttrs, type InlineWrapperKind, type InlineWrapperLayer, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type PreservedBlockAttrs, type PreservedXmlAttrs, type PreservedXmlLevel, type RunFormattingOverrideAttrs, type RunIdentityMarkAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };