@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/extensions/nodes/BookmarkBoundaryExtension.js

@@ -1,20 +1,26 @@
-import { readParagraphAttrs } from "../../attrs/index.js";
-import { expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs } from "../../bookmarkBoundaryAttrs.js";
+import { readParagraphAttrs, readTableAttrs, readTableRowAttrs } from "../../attrs/index.js";
+import { readBookmarkBoundaryAttrs } from "../../bookmarkBoundaryAttrs.js";
 import { findInvalidBookmarkBoundaryIds } from "../../bookmarkBoundaryIntegrity.js";
 import { createNodeExtension } from "../create.js";
+import { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME } from "./BlockBookmarkBoundaryExtension.js";
+import { bookmarkBoundaryAttrSpec, bookmarkBoundaryDomAttributes, parseBookmarkBoundaryDom } from "./bookmarkBoundaryDom.js";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/extensions/nodes/BookmarkBoundaryExtension.ts
-function readNonnegativeInteger(value) {
-	if (value === null || !/^(?:0|[1-9]\d*)$/.test(value)) return false;
-	const parsed = Number(value);
-	return Number.isSafeInteger(parsed) ? parsed : false;
-}
-function readOptionalColumn(dom, attribute) {
-	const value = dom.getAttribute(attribute);
-	return value === null ? void 0 : readNonnegativeInteger(value);
-}
 /** The node name, for callers asking whether a paragraph holds any content. */
 const BOOKMARK_BOUNDARY_NODE_NAME = "bookmarkBoundary";
+/**
+* Both boundary node types, because a bookmark pairs across them.
+*
+* A range that opens as a child of `w:body` and closes inside a paragraph is
+* the commoner shape in real documents, so a pass that read one node type
+* would see half of every such pair, call it unpaired, and delete it.
+*/
+const BOUNDARY_NODE_NAMES = /* @__PURE__ */ new Set([BOOKMARK_BOUNDARY_NODE_NAME, BLOCK_BOOKMARK_BOUNDARY_NODE_NAME]);
+/** The markers a `table` or `tableRow` node carries, or none. */
+const positionedBookmarksOf = (node) => {
+	const attrs = node.type.name === "table" ? readTableAttrs(node) : readTableRowAttrs(node);
+	return attrs.ok ? attrs.value._bookmarks ?? [] : [];
+};
 const collectInvalidBoundaries = (doc) => {
 	const boundaries = [];
 	const malformedBoundaries = [];
@@ -24,7 +30,13 @@ const collectInvalidBoundaries = (doc) => {
 			const attrs = readParagraphAttrs(node);
 			if (attrs.ok) for (const bookmark of attrs.value.bookmarks ?? []) paragraphBookmarkIds.add(bookmark.id);
 		}
-		if (node.type.name !== "bookmarkBoundary") return true;
+		if (node.type.name === "table" || node.type.name === "tableRow") for (const { marker } of positionedBookmarksOf(node)) boundaries.push({
+			id: marker.id,
+			type: marker.type === "bookmarkStart" ? "start" : "end",
+			position,
+			node
+		});
+		if (!BOUNDARY_NODE_NAMES.has(node.type.name)) return true;
 		const result = readBookmarkBoundaryAttrs(node);
 		if (!result.ok) {
 			malformedBoundaries.push({
@@ -44,7 +56,7 @@ const collectInvalidBoundaries = (doc) => {
 		return false;
 	});
 	const invalidIds = findInvalidBookmarkBoundaryIds(boundaries, paragraphBookmarkIds);
-	return [...boundaries.filter(({ id }) => invalidIds.has(id)), ...malformedBoundaries];
+	return [...boundaries.filter(({ id, node }) => invalidIds.has(id) && BOUNDARY_NODE_NAMES.has(node.type.name)), ...malformedBoundaries];
 };
 const BookmarkBoundaryExtension = createNodeExtension({
 	name: BOOKMARK_BOUNDARY_NODE_NAME,
@@ -55,50 +67,13 @@ const BookmarkBoundaryExtension = createNodeExtension({
 		marks: "_",
 		atom: true,
 		selectable: false,
-		attrs: {
-			type: {},
-			id: {},
-			name: { default: null },
-			colFirst: { default: null },
-			colLast: { default: null },
-			displacedByCustomXml: { default: null }
-		},
+		attrs: bookmarkBoundaryAttrSpec,
 		parseDOM: [{
 			tag: "span[data-docx-bookmark-boundary]",
-			getAttrs(dom) {
-				const type = dom.getAttribute("data-docx-bookmark-boundary");
-				const id = readNonnegativeInteger(dom.getAttribute("data-docx-bookmark-id"));
-				if (type !== "start" && type !== "end" || id === false) return false;
-				const name = dom.getAttribute("data-docx-bookmark-name");
-				if (type === "start" && !name) return false;
-				const colFirst = readOptionalColumn(dom, "data-docx-bookmark-col-first");
-				const colLast = readOptionalColumn(dom, "data-docx-bookmark-col-last");
-				if (colFirst === false || colLast === false) return false;
-				const displaced = dom.getAttribute("data-docx-bookmark-displaced");
-				return {
-					type,
-					id,
-					...name ? { name } : {},
-					...colFirst !== void 0 ? { colFirst } : {},
-					...colLast !== void 0 ? { colLast } : {},
-					...isDisplacedByCustomXml(displaced) ? { displacedByCustomXml: displaced } : {}
-				};
-			}
+			getAttrs: parseBookmarkBoundaryDom
 		}],
 		toDOM(node) {
-			const attrs = expectBookmarkBoundaryAttrs(node);
-			return ["span", {
-				"data-docx-bookmark-boundary": attrs.type,
-				"data-docx-bookmark-id": String(attrs.id),
-				...attrs.type === "start" ? { "data-docx-bookmark-name": attrs.name } : {},
-				...attrs.type === "start" && attrs.colFirst !== void 0 ? { "data-docx-bookmark-col-first": String(attrs.colFirst) } : {},
-				...attrs.type === "start" && attrs.colLast !== void 0 ? { "data-docx-bookmark-col-last": String(attrs.colLast) } : {},
-				...attrs.displacedByCustomXml !== void 0 ? { "data-docx-bookmark-displaced": attrs.displacedByCustomXml } : {},
-				"aria-hidden": "true",
-				contenteditable: "false",
-				style: "display: none;",
-				...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
-			}];
+			return ["span", bookmarkBoundaryDomAttributes(node, options.getInternalClipboardToken?.())];
 		}
 	}),
 	onSchemaReady: () => ({ plugins: [new Plugin({ appendTransaction(transactions, _oldState, newState) {

package/dist/prosemirror/extensions/nodes/CommentReferenceExtension.d.ts

@@ -0,0 +1,11 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/CommentReferenceExtension.d.ts
+/** Zero-width `w:commentReference`: where a comment's visible mark is painted. */
+type CommentReferenceOptions = {
+  getInternalClipboardToken?: () => string;
+};
+/** The node name, for callers asking whether a paragraph holds any content. */
+declare const COMMENT_REFERENCE_NODE_NAME = "commentReference";
+declare const CommentReferenceExtension: (options?: Partial<CommentReferenceOptions> | undefined) => NodeExtension;
+//#endregion
+export { COMMENT_REFERENCE_NODE_NAME, CommentReferenceExtension };

package/dist/prosemirror/extensions/nodes/CommentReferenceExtension.js

@@ -0,0 +1,97 @@
+import { readCommentReferenceAttrs } from "../../commentReferenceAttrs.js";
+import { planCommentReferenceRepairs } from "../../commentReferenceIntegrity.js";
+import { readRangeAnchorAttrs } from "../../rangeAnchorAttrs.js";
+import { createNodeExtension } from "../create.js";
+import "./RangeAnchorExtension.js";
+import { Plugin } from "prosemirror-state";
+//#region src/prosemirror/extensions/nodes/CommentReferenceExtension.ts
+/** The node name, for callers asking whether a paragraph holds any content. */
+const COMMENT_REFERENCE_NODE_NAME = "commentReference";
+const surveyCommentReferences = (doc) => {
+	const references = [];
+	const markEnds = /* @__PURE__ */ new Map();
+	doc.descendants((node, position) => {
+		if (node.type.name === "commentReference") {
+			const attrs = readCommentReferenceAttrs(node);
+			references.push({
+				commentId: attrs.ok ? attrs.value.commentId : -1,
+				position,
+				size: node.nodeSize,
+				malformed: !attrs.ok
+			});
+			return false;
+		}
+		if (node.type.name === "rangeAnchor") {
+			const attrs = readRangeAnchorAttrs(node);
+			if (attrs.ok && attrs.value.start.type === "commentRangeStart") {
+				const { id } = attrs.value.start;
+				markEnds.set(id, Math.max(markEnds.get(id) ?? 0, position + node.nodeSize));
+			}
+			return false;
+		}
+		if (!node.isInline) return true;
+		for (const mark of node.marks) {
+			if (mark.type.name !== "comment") continue;
+			const commentId = mark.attrs["commentId"];
+			if (typeof commentId !== "number") continue;
+			markEnds.set(commentId, Math.max(markEnds.get(commentId) ?? 0, position + node.nodeSize));
+		}
+		return true;
+	});
+	return {
+		references,
+		markExtents: [...markEnds].map(([commentId, end]) => ({
+			commentId,
+			end
+		}))
+	};
+};
+const CommentReferenceExtension = createNodeExtension({
+	name: COMMENT_REFERENCE_NODE_NAME,
+	schemaNodeName: COMMENT_REFERENCE_NODE_NAME,
+	nodeSpec: (options) => ({
+		inline: true,
+		group: "inline",
+		marks: "_",
+		atom: true,
+		selectable: false,
+		attrs: { commentId: {} },
+		parseDOM: [{
+			tag: "span[data-docx-comment-reference]",
+			getAttrs(dom) {
+				const raw = dom.getAttribute("data-docx-comment-reference");
+				if (raw === null || !/^(?:0|[1-9]\d*)$/.test(raw)) return false;
+				const commentId = Number(raw);
+				return Number.isSafeInteger(commentId) ? { commentId } : false;
+			}
+		}],
+		toDOM(node) {
+			const attrs = readCommentReferenceAttrs(node);
+			return ["span", {
+				"data-docx-comment-reference": String(attrs.ok ? attrs.value.commentId : ""),
+				"aria-hidden": "true",
+				contenteditable: "false",
+				style: "display: none;",
+				...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
+			}];
+		}
+	}),
+	onSchemaReady: ({ schema }) => ({ plugins: [new Plugin({ appendTransaction(transactions, _oldState, newState) {
+		if (!transactions.some(({ docChanged }) => docChanged)) return null;
+		const referenceType = schema.nodes[COMMENT_REFERENCE_NODE_NAME];
+		if (!referenceType) return null;
+		const repairs = planCommentReferenceRepairs(surveyCommentReferences(newState.doc));
+		if (repairs.length === 0) return null;
+		const transaction = newState.tr;
+		for (const repair of repairs) {
+			if (repair.type === "delete") {
+				transaction.delete(repair.position, repair.position + repair.size);
+				continue;
+			}
+			transaction.insert(transaction.mapping.map(repair.position), referenceType.create({ commentId: repair.commentId }));
+		}
+		return transaction;
+	} })] })
+});
+//#endregion
+export { COMMENT_REFERENCE_NODE_NAME, CommentReferenceExtension };

package/dist/prosemirror/extensions/nodes/FieldExtension.js

@@ -8,16 +8,18 @@ const createFieldAttrs = () => ({
 	displayText: { default: "" },
 	_numberedRefBaseline: { default: void 0 },
 	fieldKind: { default: "simple" },
-	fldLock: { default: false },
-	dirty: { default: false }
+	fldLock: { default: null },
+	dirty: { default: null }
 });
+/** A `data-` flag a pasted field carried: absent states nothing. */
+const statedFlag = (value) => value === void 0 ? null : value === "true";
 const readFieldDomAttrs = (dom) => ({
 	fieldType: dom.dataset["fieldType"] ?? "UNKNOWN",
 	instruction: dom.dataset["instruction"] ?? "",
 	displayText: dom.textContent ?? "",
 	fieldKind: dom.dataset["fieldKind"] ?? "simple",
-	fldLock: dom.dataset["fldLock"] === "true",
-	dirty: dom.dataset["dirty"] === "true"
+	fldLock: statedFlag(dom.dataset["fldLock"]),
+	dirty: statedFlag(dom.dataset["dirty"])
 });
 const getFieldDomAttrs = (node) => {
 	const { fieldType, instruction, fieldKind, fldLock, dirty } = expectFieldAttrs(node);
@@ -26,8 +28,8 @@ const getFieldDomAttrs = (node) => {
 		"data-field-type": fieldType,
 		"data-instruction": instruction,
 		"data-field-kind": fieldKind,
-		...fldLock ? { "data-fld-lock": "true" } : {},
-		...dirty ? { "data-dirty": "true" } : {},
+		...fldLock === void 0 ? {} : { "data-fld-lock": String(fldLock) },
+		...dirty === void 0 ? {} : { "data-dirty": String(dirty) },
 		style: "outline: 1px solid var(--doc-field-outline, rgba(200,200,200,0.4)); padding: 0 1px; border-radius: 2px;"
 	};
 };
@@ -74,7 +76,7 @@ const StructuredFieldExtension = createNodeExtension({
 	nodeSpec: (options) => ({
 		inline: true,
 		group: "inline",
-		content: "(text | bookmarkBoundary | tab | symbol | hardBreak | pageBreakRun | image | shape | renderedPageBreak | textBoxAnchor)+",
+		content: "(text | bookmarkBoundary | tab | symbol | hardBreak | pageBreakRun | image | shape | renderedPageBreak | textBoxAnchor | preservedXml)+",
 		atom: true,
 		selectable: true,
 		attrs: createFieldAttrs(),

package/dist/prosemirror/extensions/nodes/ImageExtension.js

@@ -1,3 +1,4 @@
+import { imageLuminanceFilter } from "../../../utils/imageLuminance.js";
 import { expectImageAttrs } from "../../attrs/index.js";
 import { createNodeExtension } from "../create.js";
 //#region src/prosemirror/extensions/nodes/ImageExtension.ts
@@ -14,6 +15,7 @@ const ImageExtension = createNodeExtension({
 		draggable: true,
 		attrs: {
 			src: {},
+			preview: { default: null },
 			docPrName: { default: null },
 			alt: { default: null },
 			title: { default: null },
@@ -24,7 +26,12 @@ const ImageExtension = createNodeExtension({
 			displayMode: { default: "inline" },
 			cssFloat: { default: null },
 			transform: { default: null },
+			docxRotation: { default: null },
+			docxFlipH: { default: null },
+			docxFlipV: { default: null },
 			opacity: { default: null },
+			brightness: { default: null },
+			contrast: { default: null },
 			distTop: { default: null },
 			distBottom: { default: null },
 			distLeft: { default: null },
@@ -38,7 +45,10 @@ const ImageExtension = createNodeExtension({
 			paddingBottom: { default: null },
 			paddingLeft: { default: null },
 			position: { default: null },
-			layoutInCell: { default: null },
+			anchor: { default: null },
+			wrapDistanceSlots: { default: null },
+			wrapEffectExtentSlots: { default: null },
+			wrapPolygon: { default: null },
 			decorative: { default: null },
 			hidden: { default: null },
 			docPrExtensions: { default: null },
@@ -50,6 +60,9 @@ const ImageExtension = createNodeExtension({
 			wrapText: { default: null },
 			hlinkHref: { default: null },
 			hlinkRId: { default: null },
+			hlinkClickSource: { default: null },
+			hlinkHoverXml: { default: null },
+			docPrId: { default: null },
 			_docxRawXml: { default: null },
 			_docxRawXmlMode: { default: null },
 			_docxRawImageFingerprint: { default: null },
@@ -66,6 +79,10 @@ const ImageExtension = createNodeExtension({
 				const borderWidthRaw = element.dataset["borderWidth"];
 				const opacityRaw = element.dataset["opacity"];
 				const opacityParsed = opacityRaw === void 0 ? NaN : Number(opacityRaw);
+				const brightnessRaw = element.dataset["brightness"];
+				const brightness = brightnessRaw === void 0 ? NaN : Number(brightnessRaw);
+				const contrastRaw = element.dataset["contrast"];
+				const contrast = contrastRaw === void 0 ? NaN : Number(contrastRaw);
 				return {
 					src: element.getAttribute("src") || "",
 					...alt ? { alt } : {},
@@ -78,6 +95,8 @@ const ImageExtension = createNodeExtension({
 					...cssFloat ? { cssFloat } : {},
 					...element.dataset["transform"] ? { transform: element.dataset["transform"] } : {},
 					...Number.isFinite(opacityParsed) ? { opacity: opacityParsed } : {},
+					...Number.isFinite(brightness) ? { brightness } : {},
+					...Number.isFinite(contrast) ? { contrast } : {},
 					...borderWidthRaw ? { borderWidth: Number(borderWidthRaw) } : {},
 					...element.dataset["borderColor"] ? { borderColor: element.dataset["borderColor"] } : {},
 					...element.dataset["borderStyle"] ? { borderStyle: element.dataset["borderStyle"] } : {}
@@ -98,6 +117,8 @@ const ImageExtension = createNodeExtension({
 			if (attrs.cssFloat) domAttrs["data-css-float"] = attrs.cssFloat;
 			if (attrs.transform) domAttrs["data-transform"] = attrs.transform;
 			if (attrs.opacity != null) domAttrs["data-opacity"] = String(attrs.opacity);
+			if (attrs.brightness != null) domAttrs["data-brightness"] = String(attrs.brightness);
+			if (attrs.contrast != null) domAttrs["data-contrast"] = String(attrs.contrast);
 			if (attrs.borderWidth) domAttrs["data-border-width"] = String(attrs.borderWidth);
 			if (attrs.borderColor) domAttrs["data-border-color"] = attrs.borderColor;
 			if (attrs.borderStyle) domAttrs["data-border-style"] = attrs.borderStyle;
@@ -134,6 +155,8 @@ const ImageExtension = createNodeExtension({
 			}
 			if (attrs.transform) styles.push(`transform: ${attrs.transform}`);
 			if (attrs.opacity != null && attrs.opacity < 1) styles.push(`opacity: ${Math.max(0, attrs.opacity)}`);
+			const luminanceFilter = imageLuminanceFilter(attrs);
+			if (luminanceFilter !== void 0) styles.push(`filter: ${luminanceFilter}`);
 			if (attrs.borderWidth && attrs.borderWidth > 0) {
 				const bStyle = attrs.borderStyle || "solid";
 				const bColor = attrs.borderColor || "#000000";

package/dist/prosemirror/extensions/nodes/MoveRangeBoundaryExtension.d.ts

@@ -0,0 +1,11 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/MoveRangeBoundaryExtension.d.ts
+/** Hidden boundary for one non-empty tracked-move range. */
+type MoveRangeBoundaryOptions = {
+  getInternalClipboardToken?: () => string;
+};
+declare const MOVE_RANGE_BOUNDARY_NODE_NAME = "moveRangeBoundary";
+declare const MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE = "data-docx-move-range-boundary";
+declare const MoveRangeBoundaryExtension: (options?: Partial<MoveRangeBoundaryOptions> | undefined) => NodeExtension;
+//#endregion
+export { MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE, MOVE_RANGE_BOUNDARY_NODE_NAME, MoveRangeBoundaryExtension };

package/dist/prosemirror/extensions/nodes/MoveRangeBoundaryExtension.js

@@ -0,0 +1,43 @@
+import { expectMoveRangeBoundaryAttrs, readMoveRangeMarker } from "../../moveRangeBoundaryAttrs.js";
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/MoveRangeBoundaryExtension.ts
+/** Hidden boundary for one non-empty tracked-move range. */
+const MOVE_RANGE_BOUNDARY_NODE_NAME = "moveRangeBoundary";
+const MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE = "data-docx-move-range-boundary";
+const MoveRangeBoundaryExtension = createNodeExtension({
+	name: MOVE_RANGE_BOUNDARY_NODE_NAME,
+	schemaNodeName: MOVE_RANGE_BOUNDARY_NODE_NAME,
+	nodeSpec: (options) => ({
+		inline: true,
+		group: "inline",
+		marks: "_",
+		atom: true,
+		selectable: false,
+		attrs: { marker: {} },
+		parseDOM: [{
+			tag: `span[${MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE}]`,
+			getAttrs(dom) {
+				const raw = dom.getAttribute(MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE);
+				if (raw === null) return false;
+				try {
+					const result = readMoveRangeMarker(JSON.parse(raw));
+					return result.ok ? { marker: result.value } : false;
+				} catch {
+					return false;
+				}
+			}
+		}],
+		toDOM(node) {
+			const marker = expectMoveRangeBoundaryAttrs(node);
+			return ["span", {
+				[MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE]: JSON.stringify(marker),
+				"aria-hidden": "true",
+				contenteditable: "false",
+				style: "display: none;",
+				...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
+			}];
+		}
+	})
+});
+//#endregion
+export { MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE, MOVE_RANGE_BOUNDARY_NODE_NAME, MoveRangeBoundaryExtension };

package/dist/prosemirror/extensions/nodes/PreservedBlockExtension.d.ts

@@ -0,0 +1,32 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/PreservedBlockExtension.d.ts
+/**
+ * A zero-width block for markup folio keeps opaquely between two blocks.
+ *
+ * The block-level twin of the `preservedXml` inline atom. A `w:permStart`
+ * between two paragraphs, an `m:oMathPara`, a `w:altChunk`, a comment or move
+ * range that opens between blocks: the editor has no model for any of it and
+ * does not need one, because it only has to not lose it. So the node renders
+ * nothing, takes no selection and holds no text.
+ *
+ * **Position is structure, not an attribute.** The node sits between the same
+ * two blocks it sat between in the source, and ProseMirror's own mapping keeps
+ * it there: inserting, splitting or deleting a neighbour moves the markup the
+ * way a reader would expect, and nothing has to keep an index honest. The
+ * alternative — an index into the container recorded on the node — drifts the
+ * first time anything around it changes, and a drifting index is how markup
+ * ends up in the wrong place rather than merely lost.
+ *
+ * Deleting a *neighbour* therefore leaves the markup attached to whatever now
+ * follows it; only a selection that covers the node itself removes it, which
+ * is the same rule the editor applies to every other block.
+ *
+ * The integrity plugin removes a node that can never write markup back: bad
+ * attributes, or an empty payload left by a paste through the DOM. Keeping one
+ * would leave a zero-width block in the document that serializes to nothing.
+ */
+/** The node name, for callers asking what a container holds. */
+declare const PRESERVED_BLOCK_NODE_NAME = "preservedBlock";
+declare const PreservedBlockExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { PRESERVED_BLOCK_NODE_NAME, PreservedBlockExtension };

package/dist/prosemirror/extensions/nodes/PreservedBlockExtension.js

@@ -0,0 +1,67 @@
+import { expectPreservedBlockAttrs, readPreservedBlockAttrs } from "../../attrs/index.js";
+import { createNodeExtension } from "../create.js";
+import { Plugin } from "prosemirror-state";
+//#region src/prosemirror/extensions/nodes/PreservedBlockExtension.ts
+/** The node name, for callers asking what a container holds. */
+const PRESERVED_BLOCK_NODE_NAME = "preservedBlock";
+/**
+* A node that can never write markup back.
+*
+* Either the attributes do not read at all, or `xml` is empty: a copy that
+* came back from a paste with its payload stripped. Keeping one would put a
+* zero-width block in the document that serializes to nothing, so the plugin
+* removes it rather than letting it ride along.
+*/
+const isUnwritable = (node) => {
+	const attrs = readPreservedBlockAttrs(node);
+	return !attrs.ok || attrs.value.xml === "";
+};
+const collectUnwritableBlocks = (doc) => {
+	const unwritable = [];
+	doc.descendants((node, position) => {
+		if (node.type.name !== "preservedBlock") return true;
+		if (isUnwritable(node)) unwritable.push({
+			position,
+			node
+		});
+		return false;
+	});
+	return unwritable;
+};
+const PreservedBlockExtension = createNodeExtension({
+	name: PRESERVED_BLOCK_NODE_NAME,
+	schemaNodeName: PRESERVED_BLOCK_NODE_NAME,
+	nodeSpec: {
+		group: "block",
+		atom: true,
+		selectable: false,
+		attrs: { xml: {} },
+		parseDOM: [{
+			tag: "div[data-docx-preserved-block]",
+			getAttrs(dom) {
+				if (!(dom instanceof HTMLElement)) return false;
+				const xml = dom.dataset["docxPreservedBlock"];
+				return xml === void 0 || xml === "" ? false : { xml };
+			}
+		}],
+		toDOM(node) {
+			const { xml } = expectPreservedBlockAttrs(node);
+			return ["div", {
+				"data-docx-preserved-block": xml,
+				"aria-hidden": "true",
+				contenteditable: "false",
+				style: "display: none;"
+			}];
+		}
+	},
+	onSchemaReady: () => ({ plugins: [new Plugin({ appendTransaction(transactions, _oldState, newState) {
+		if (!transactions.some(({ docChanged }) => docChanged)) return null;
+		const unwritable = collectUnwritableBlocks(newState.doc);
+		if (unwritable.length === 0) return null;
+		const transaction = newState.tr;
+		for (const { node, position } of unwritable.toSorted((first, second) => second.position - first.position)) transaction.delete(position, position + node.nodeSize);
+		return transaction;
+	} })] })
+});
+//#endregion
+export { PRESERVED_BLOCK_NODE_NAME, PreservedBlockExtension };

package/dist/prosemirror/extensions/nodes/PreservedXmlExtension.d.ts

@@ -0,0 +1,16 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/PreservedXmlExtension.d.ts
+/**
+ * An opaque inline atom for a run child folio does not model.
+ *
+ * The editor cannot edit markup it has no model for, and it does not have to:
+ * it only has to not lose it. The node carries the captured bytes untouched
+ * and shows the visible text the markup puts on the line (`w:ruby` renders its
+ * `w:rubyBase` there), so the round trip keeps both the document's text and
+ * the document's markup.
+ */
+/** The node name, for callers asking what a paragraph holds. */
+declare const PRESERVED_XML_NODE_NAME = "preservedXml";
+declare const PreservedXmlExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { PRESERVED_XML_NODE_NAME, PreservedXmlExtension };

package/dist/prosemirror/extensions/nodes/PreservedXmlExtension.js

@@ -0,0 +1,60 @@
+import { expectPreservedXmlAttrs } from "../../attrs/index.js";
+import { PRESERVED_XML_LEVELS } from "../../schema/nodes.js";
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/PreservedXmlExtension.ts
+/**
+* An opaque inline atom for a run child folio does not model.
+*
+* The editor cannot edit markup it has no model for, and it does not have to:
+* it only has to not lose it. The node carries the captured bytes untouched
+* and shows the visible text the markup puts on the line (`w:ruby` renders its
+* `w:rubyBase` there), so the round trip keeps both the document's text and
+* the document's markup.
+*/
+/** The node name, for callers asking what a paragraph holds. */
+const PRESERVED_XML_NODE_NAME = "preservedXml";
+const PreservedXmlExtension = createNodeExtension({
+	name: PRESERVED_XML_NODE_NAME,
+	schemaNodeName: PRESERVED_XML_NODE_NAME,
+	nodeSpec: {
+		inline: true,
+		group: "inline",
+		atom: true,
+		marks: "_",
+		selectable: false,
+		attrs: {
+			xml: {},
+			text: { default: "" },
+			level: { default: PRESERVED_XML_LEVELS.run }
+		},
+		parseDOM: [{
+			tag: "span[data-docx-preserved-xml]",
+			getAttrs(node) {
+				if (!(node instanceof HTMLElement)) return false;
+				const xml = node.dataset["docxPreservedXml"];
+				if (xml === void 0 || xml === "") return false;
+				const level = node.dataset["docxPreservedLevel"] === PRESERVED_XML_LEVELS.inline ? PRESERVED_XML_LEVELS.inline : PRESERVED_XML_LEVELS.run;
+				return {
+					xml,
+					text: node.dataset["docxPreservedText"] ?? "",
+					level
+				};
+			}
+		}],
+		toDOM(node) {
+			const { xml, text, level } = expectPreservedXmlAttrs(node);
+			return [
+				"span",
+				{
+					"data-docx-preserved-xml": xml,
+					"data-docx-preserved-level": level,
+					...text === "" ? {} : { "data-docx-preserved-text": text },
+					contenteditable: "false"
+				},
+				text
+			];
+		}
+	}
+});
+//#endregion
+export { PRESERVED_XML_NODE_NAME, PreservedXmlExtension };

package/dist/prosemirror/extensions/nodes/RangeAnchorExtension.d.ts

@@ -0,0 +1,13 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/RangeAnchorExtension.d.ts
+/** Zero-width comment or tracked-move range that spans no content. */
+type RangeAnchorOptions = {
+  getInternalClipboardToken?: () => string;
+};
+/** The node name, for callers asking whether a paragraph holds any content. */
+declare const RANGE_ANCHOR_NODE_NAME = "rangeAnchor";
+/** The attribute the DOM spelling carries both markers in. */
+declare const RANGE_ANCHOR_DOM_ATTRIBUTE = "data-docx-range-anchor";
+declare const RangeAnchorExtension: (options?: Partial<RangeAnchorOptions> | undefined) => NodeExtension;
+//#endregion
+export { RANGE_ANCHOR_DOM_ATTRIBUTE, RANGE_ANCHOR_NODE_NAME, RangeAnchorExtension };

package/dist/prosemirror/extensions/nodes/RangeAnchorExtension.js

@@ -0,0 +1,65 @@
+import { readRangeAnchorAttrs, readRangeAnchorValues } from "../../rangeAnchorAttrs.js";
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/RangeAnchorExtension.ts
+/** Zero-width comment or tracked-move range that spans no content. */
+/** The node name, for callers asking whether a paragraph holds any content. */
+const RANGE_ANCHOR_NODE_NAME = "rangeAnchor";
+/** The attribute the DOM spelling carries both markers in. */
+const RANGE_ANCHOR_DOM_ATTRIBUTE = "data-docx-range-anchor";
+const RangeAnchorExtension = createNodeExtension({
+	name: RANGE_ANCHOR_NODE_NAME,
+	schemaNodeName: RANGE_ANCHOR_NODE_NAME,
+	nodeSpec: (options) => ({
+		inline: true,
+		group: "inline",
+		marks: "_",
+		atom: true,
+		selectable: false,
+		attrs: {
+			start: {},
+			end: {}
+		},
+		parseDOM: [{
+			tag: `span[${RANGE_ANCHOR_DOM_ATTRIBUTE}]`,
+			getAttrs(dom) {
+				const raw = dom.getAttribute(RANGE_ANCHOR_DOM_ATTRIBUTE);
+				if (raw === null) return false;
+				const parsed = parseMarkers(raw);
+				if (parsed === null) return false;
+				const result = readRangeAnchorValues(parsed.start, parsed.end);
+				return result.ok ? result.value : false;
+			}
+		}],
+		toDOM(node) {
+			const attrs = readRangeAnchorAttrs(node);
+			return ["span", {
+				[RANGE_ANCHOR_DOM_ATTRIBUTE]: attrs.ok ? JSON.stringify(attrs.value) : "",
+				"aria-hidden": "true",
+				contenteditable: "false",
+				style: "display: none;",
+				...options.getInternalClipboardToken ? { "data-docx-internal-clipboard": options.getInternalClipboardToken() } : {}
+			}];
+		}
+	})
+});
+/**
+* The attribute back as an attrs bag, or `null` when it is not one.
+*
+* `JSON.parse` throws on malformed input reaching the schema from a paste, and
+* a parser branch that refuses the node is the boundary this belongs at.
+*/
+const parseMarkers = (raw) => {
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		if (!("start" in parsed) || !("end" in parsed)) return null;
+		return {
+			start: parsed.start,
+			end: parsed.end
+		};
+	} catch {
+		return null;
+	}
+};
+//#endregion
+export { RANGE_ANCHOR_DOM_ATTRIBUTE, RANGE_ANCHOR_NODE_NAME, RangeAnchorExtension };