@stll/folio-core 0.44.0 → 0.46.0

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

@@ -0,0 +1,87 @@
+import { readCommentReferenceAttrs } from "../../commentReferenceAttrs.js";
+import { planCommentReferenceRepairs } from "../../commentReferenceIntegrity.js";
+import { createNodeExtension } from "../create.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.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
@@ -24,7 +25,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 },
@@ -39,8 +45,12 @@ const ImageExtension = createNodeExtension({
 			paddingLeft: { default: null },
 			position: { default: null },
 			layoutInCell: { default: null },
+			decorative: { default: null },
+			hidden: { default: null },
+			docPrExtensions: { default: null },
 			frameLocks: { default: null },
 			borderWidth: { default: null },
+			_docxAuthoredEmu: { default: null },
 			borderColor: { default: null },
 			borderStyle: { default: null },
 			wrapText: { default: null },
@@ -62,6 +72,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 } : {},
@@ -74,6 +88,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"] } : {}
@@ -94,6 +110,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;
@@ -130,6 +148,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/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/ShapeExtension.js

@@ -371,22 +371,30 @@ const ShapeExtension = createNodeExtension({
 			geometryAdjustments: { default: null },
 			_docxRunFormatting: { default: null },
 			shapeId: { default: null },
+			shapeName: { default: null },
+			alt: { default: null },
+			title: { default: null },
 			width: { default: 100 },
 			height: { default: 80 },
+			_docxAuthoredEmu: { default: null },
 			fillColor: { default: null },
 			fillColorValue: { default: null },
 			fillType: { default: "solid" },
 			gradientType: { default: null },
 			gradientAngle: { default: null },
 			gradientStops: { default: null },
-			outlineWidth: { default: 1 },
+			outlineWidth: { default: null },
 			outlineColor: { default: "var(--doc-shape-outline, #000000)" },
 			outlineColorValue: { default: null },
-			outlineStyle: { default: "solid" },
+			outlineStyle: { default: null },
 			outlineCap: { default: null },
+			outlineJoin: { default: null },
 			outlineHeadEnd: { default: null },
 			outlineTailEnd: { default: null },
 			transform: { default: null },
+			docxRotation: { default: null },
+			docxFlipH: { default: null },
+			docxFlipV: { default: null },
 			displayMode: { default: "inline" },
 			cssFloat: { default: null },
 			wrapType: { default: "inline" },

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

@@ -206,6 +206,7 @@ const tableRowSpec = {
 		_resolvedJustification: { default: null },
 		_originalFormatting: { default: null },
 		trPrChange: { default: null },
+		_preservedAttributes: { default: null },
 		trIns: { default: null },
 		trDel: { default: null }
 	},
@@ -308,7 +309,7 @@ function buildCellWidthStyles(attrs) {
 	return styles;
 }
 const tableCellSpec = {
-	content: "(paragraph | table | textBox)+",
+	content: "(paragraph | table | textBox | preservedBlock)+",
 	tableRole: "cell",
 	isolating: true,
 	attrs: {
@@ -366,7 +367,7 @@ const tableCellSpec = {
 	}
 };
 const tableHeaderSpec = {
-	content: "(paragraph | table | textBox)+",
+	content: "(paragraph | table | textBox | preservedBlock)+",
 	tableRole: "header_cell",
 	isolating: true,
 	attrs: {

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

@@ -77,19 +77,26 @@ const TextBoxExtension = createNodeExtension({
 		attrs: {
 			width: { default: 200 },
 			height: { default: null },
+			_docxAuthoredEmu: { default: null },
 			autoFit: { default: null },
 			wordArt: { default: null },
 			textWrap: { default: null },
 			textBoxId: { default: null },
+			textBoxName: { default: null },
+			alt: { default: null },
+			title: { default: null },
 			fillColor: { default: null },
 			outlineWidth: { default: null },
 			outlineColor: { default: null },
 			outlineStyle: { default: null },
 			transform: { default: null },
-			marginTop: { default: 4 },
-			marginBottom: { default: 4 },
-			marginLeft: { default: 7 },
-			marginRight: { default: 7 },
+			docxRotation: { default: null },
+			docxFlipH: { default: null },
+			docxFlipV: { default: null },
+			marginTop: { default: null },
+			marginBottom: { default: null },
+			marginLeft: { default: null },
+			marginRight: { default: null },
 			verticalAlign: { default: null },
 			displayMode: { default: "inline" },
 			cssFloat: { default: null },
@@ -105,7 +112,8 @@ const TextBoxExtension = createNodeExtension({
 			_docxAnchorId: { default: null },
 			_docxTextBodyContentState: { default: { type: "authored" } },
 			_docxTrackedChange: { default: null },
-			_docxInlineSdts: { default: null }
+			_docxInlineSdts: { default: null },
+			_preservedAttributes: { default: null }
 		},
 		parseDOM: [{
 			tag: "div.docx-textbox",

package/dist/prosemirror/inlineWrapperStack.d.ts

@@ -0,0 +1,39 @@
+import { document_d_exports } from "../types/document.js";
+import { InlineWrapperLayer } from "./schema/marks.js";
+//#region src/prosemirror/inlineWrapperStack.d.ts
+/** The DOM attribute that carries a serialised stack through copy and paste. */
+declare const INLINE_WRAPPER_STACK_ATTRIBUTE = "data-inline-wrapper";
+/** A layer with its keys in canonical order, absent fields left absent. */
+declare const inlineWrapperLayer: (layer: InlineWrapperLayer) => InlineWrapperLayer;
+/**
+ * The model member a layer describes, holding `content`.
+ *
+ * The inverse of the `WrapperLayer` projection: `toProseDoc` takes the model
+ * member apart into a layer and its content, and the save leg puts one back
+ * together. Both directions live here so a wrapper kind is spelled once.
+ */
+declare const inlineWrapperMember: (layer: InlineWrapperLayer, content: document_d_exports.InlineWrapper["content"]) => document_d_exports.InlineWrapper;
+/** `layers` in canonical form, or `null` when there is no wrapper to record. */
+declare const inlineWrapperStack: (layers: readonly InlineWrapperLayer[]) => readonly InlineWrapperLayer[] | null;
+declare const serializeInlineWrapperStack: (stack: readonly InlineWrapperLayer[]) => string;
+/**
+ * The key two stacks share exactly when they are the same nest of wrappers.
+ *
+ * The save leg groups adjacent inline leaves by it, so it has to be the
+ * factory's canonical spelling rather than whatever order an attrs object
+ * happens to carry: two leaves inside one `w:bdo` that keyed differently would
+ * be written as two `w:bdo` elements. The empty stack keys as the empty string,
+ * which is what "inside no wrapper" compares as.
+ */
+declare const inlineWrapperStackKey: (stack: readonly InlineWrapperLayer[]) => string;
+/**
+ * A stack read back from the DOM, or `null` when the markup carries none.
+ *
+ * Paste from outside the editor is the ordinary case: the attribute is absent,
+ * so the pasted leaf carries no wrapper. Markup that states the attribute but
+ * not a stack this build validates is read the same way — the text is what
+ * matters, and inventing a wrapper around it would change the document.
+ */
+declare const parseInlineWrapperStack: (serialized: string | null | undefined) => readonly InlineWrapperLayer[] | null;
+//#endregion
+export { INLINE_WRAPPER_STACK_ATTRIBUTE, inlineWrapperLayer, inlineWrapperMember, inlineWrapperStack, inlineWrapperStackKey, parseInlineWrapperStack, serializeInlineWrapperStack };

package/dist/prosemirror/inlineWrapperStack.js

@@ -0,0 +1,75 @@
+import { readInlineWrapperStack } from "./attrs/index.js";
+import { Result, panic } from "better-result";
+//#region src/prosemirror/inlineWrapperStack.ts
+/**
+* The one place an inline-wrapper layer is built, and the codec that carries a
+* stack through the DOM.
+*
+* Two layers describing the same wrapper have to be the same value, because
+* `fromProseDoc` groups inline leaves into runs by `JSON.stringify` over their
+* mark attrs: one wrapper spelled with its keys in two orders would split one
+* run into two. Object key order is insertion order in JavaScript, so the
+* factory fixes it and every construction site goes through the factory —
+* including the one that reads a stack back out of the DOM, where `JSON.parse`
+* preserves whatever order the markup happened to carry.
+*/
+/** The DOM attribute that carries a serialised stack through copy and paste. */
+const INLINE_WRAPPER_STACK_ATTRIBUTE = "data-inline-wrapper";
+/** A layer with its keys in canonical order, absent fields left absent. */
+const inlineWrapperLayer = (layer) => {
+	switch (layer.kind) {
+		case "bidi": return layer.direction === void 0 ? {
+			kind: "bidi",
+			control: layer.control
+		} : {
+			kind: "bidi",
+			control: layer.control,
+			direction: layer.direction
+		};
+		default:
+			layer.kind;
+			panic(`Unsupported inline wrapper layer: ${JSON.stringify(layer)}`);
+	}
+};
+/**
+* The model member a layer describes, holding `content`.
+*
+* The inverse of the `WrapperLayer` projection: `toProseDoc` takes the model
+* member apart into a layer and its content, and the save leg puts one back
+* together. Both directions live here so a wrapper kind is spelled once.
+*/
+const inlineWrapperMember = (layer, content) => ({
+	...inlineWrapperLayer(layer),
+	type: "inlineWrapper",
+	content
+});
+/** `layers` in canonical form, or `null` when there is no wrapper to record. */
+const inlineWrapperStack = (layers) => layers.length === 0 ? null : layers.map(inlineWrapperLayer);
+const serializeInlineWrapperStack = (stack) => JSON.stringify(stack);
+/**
+* The key two stacks share exactly when they are the same nest of wrappers.
+*
+* The save leg groups adjacent inline leaves by it, so it has to be the
+* factory's canonical spelling rather than whatever order an attrs object
+* happens to carry: two leaves inside one `w:bdo` that keyed differently would
+* be written as two `w:bdo` elements. The empty stack keys as the empty string,
+* which is what "inside no wrapper" compares as.
+*/
+const inlineWrapperStackKey = (stack) => stack.length === 0 ? "" : serializeInlineWrapperStack(stack.map(inlineWrapperLayer));
+/**
+* A stack read back from the DOM, or `null` when the markup carries none.
+*
+* Paste from outside the editor is the ordinary case: the attribute is absent,
+* so the pasted leaf carries no wrapper. Markup that states the attribute but
+* not a stack this build validates is read the same way — the text is what
+* matters, and inventing a wrapper around it would change the document.
+*/
+const parseInlineWrapperStack = (serialized) => {
+	if (!serialized) return null;
+	const parsed = Result.try(() => JSON.parse(serialized));
+	if (parsed.isErr()) return null;
+	const stack = readInlineWrapperStack(parsed.value);
+	return stack.ok ? stack.value.map(inlineWrapperLayer) : null;
+};
+//#endregion
+export { INLINE_WRAPPER_STACK_ATTRIBUTE, inlineWrapperLayer, inlineWrapperMember, inlineWrapperStack, inlineWrapperStackKey, parseInlineWrapperStack, serializeInlineWrapperStack };

package/dist/prosemirror/pageBreakRunProjection.d.ts

@@ -2,17 +2,27 @@ import { document_d_exports } from "../types/document.js";
 import { ParagraphAttrs } from "./schema/nodes.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/pageBreakRunProjection.d.ts
+/**
+ * Paragraph shapes whose explicit page-break run the editor lays out
+ * approximately.
+ *
+ * Layout splits a paragraph into fragments at its breaks, and a paragraph
+ * property that describes the paragraph as a whole then applies to each
+ * fragment. That is an approximation, not a loss: the run is projected, it is
+ * saved, and the document opens. Folio used to refuse these instead, which
+ * meant a file Word opens could not be opened, laid out or exported at all.
+ */
 declare const PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES: {
-  readonly borders: "A bordered paragraph containing an explicit page-break run cannot be projected";
-  readonly frame: "A framed paragraph containing an explicit page-break run cannot be projected";
-  readonly outline: "An outline paragraph containing an explicit page-break run cannot be projected";
-  readonly textBoxAnchor: "A paragraph whose text-box anchor follows an explicit page-break run cannot be projected";
+  readonly borders: "A bordered paragraph is split at its explicit page-break run, so its border is drawn around each part";
+  readonly frame: "A framed paragraph is split at its explicit page-break run, so its frame applies to each part";
+  readonly outline: "An outline paragraph is split at its explicit page-break run, so each part carries the outline level";
+  readonly textBoxAnchor: "A text-box anchor following an explicit page-break run is hosted by the paragraph's first part";
 };
 type PageBreakRunParagraphProjectionReason = keyof typeof PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES;
 type PageBreakRunParagraphProjectionDisposition = {
-  status: "supported";
+  status: "exact";
 } | {
-  status: "unsupported";
+  status: "approximate";
   reason: PageBreakRunParagraphProjectionReason;
   message: (typeof PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES)[keyof typeof PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES];
 };
@@ -25,7 +35,7 @@ type PageBreakRunParagraphFeatures = {
    * Layout splits such a paragraph into fragments at its breaks, and only the
    * first fragment keeps the paragraph's block id, which is what an anchor
    * resolves its host through. An anchor before the first break is therefore
-   * projected faithfully; one after it would lose its host.
+   * laid out exactly; one after it falls back to the first fragment.
    */
   textBoxAnchorAfterPageBreak: boolean;
 };