@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/authoredTransformAttrs.d.ts

@@ -0,0 +1,28 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/prosemirror/authoredTransformAttrs.d.ts
+/** The transform attrs a drawing node (`image`, `shape`, `textBox`) carries. */
+type AuthoredTransformAttrs = {
+  docxFlipH: boolean | null;
+  docxFlipV: boolean | null;
+  docxRotation: number | null;
+  /** The rendered CSS, derived from the three above. */
+  transform: string | undefined;
+};
+/** What a drawing node's attrs say, as they arrive from a persisted document. */
+type ReadableTransformAttrs = {
+  docxFlipH?: boolean | null;
+  docxFlipV?: boolean | null;
+  docxRotation?: number | null;
+  transform?: string;
+};
+/** Project a model transform onto a drawing node's attrs. */
+declare const authoredTransformAttrs: (transform: document_d_exports.ImageTransform | undefined) => AuthoredTransformAttrs;
+/**
+ * Read a drawing node's authored transform back.
+ *
+ * The attrs are the record; the CSS string answers only for a node that states
+ * none of them, which is how a node persisted before they existed arrives.
+ */
+declare const readAuthoredTransform: (attrs: ReadableTransformAttrs) => document_d_exports.ImageTransform | undefined;
+//#endregion
+export { authoredTransformAttrs, readAuthoredTransform };

package/dist/prosemirror/authoredTransformAttrs.js

@@ -0,0 +1,64 @@
+//#region src/prosemirror/authoredTransformAttrs.ts
+/**
+* The CSS the three authored values render as.
+*
+* Only what the browser has to draw: a rotation of zero and an explicit
+* "not flipped" are the identity, and emitting them would put a no-op
+* transform on every drawing that states one.
+*/
+const cssTransform = (rotation, flipH, flipV) => {
+	const parts = [];
+	if (rotation !== null && rotation !== 0) parts.push(`rotate(${rotation}deg)`);
+	if (flipH === true) parts.push("scaleX(-1)");
+	if (flipV === true) parts.push("scaleY(-1)");
+	return parts.length > 0 ? parts.join(" ") : void 0;
+};
+/** Project a model transform onto a drawing node's attrs. */
+const authoredTransformAttrs = (transform) => {
+	const docxRotation = transform?.rotation ?? null;
+	const docxFlipH = transform?.flipH ?? null;
+	const docxFlipV = transform?.flipV ?? null;
+	return {
+		docxFlipH,
+		docxFlipV,
+		docxRotation,
+		transform: cssTransform(docxRotation, docxFlipH, docxFlipV)
+	};
+};
+/**
+* The transform a node persisted before these attrs existed carries.
+*
+* The CSS can state neither an authored zero rotation nor an authored "not
+* flipped", which is why the attrs exist; such a node never carried them
+* either, so reading it this way loses nothing.
+*/
+const transformFromCss = (css) => {
+	if (!css) return;
+	const transform = {};
+	const rotateMatch = /rotate\((?<deg>[-\d.]+)deg\)/u.exec(css);
+	if (rotateMatch) {
+		const rotation = Number.parseFloat(rotateMatch.groups["deg"]);
+		if (Number.isFinite(rotation)) transform.rotation = rotation;
+	}
+	if (css.includes("scaleX(-1)")) transform.flipH = true;
+	if (css.includes("scaleY(-1)")) transform.flipV = true;
+	if (transform.rotation === void 0 && !transform.flipH && !transform.flipV) return;
+	return transform;
+};
+/**
+* Read a drawing node's authored transform back.
+*
+* The attrs are the record; the CSS string answers only for a node that states
+* none of them, which is how a node persisted before they existed arrives.
+*/
+const readAuthoredTransform = (attrs) => {
+	const { docxFlipH, docxFlipV, docxRotation } = attrs;
+	if (docxRotation == null && docxFlipH == null && docxFlipV == null) return transformFromCss(attrs.transform);
+	return {
+		...docxRotation == null ? {} : { rotation: docxRotation },
+		...docxFlipH == null ? {} : { flipH: docxFlipH },
+		...docxFlipV == null ? {} : { flipV: docxFlipV }
+	};
+};
+//#endregion
+export { authoredTransformAttrs, readAuthoredTransform };

package/dist/prosemirror/bookmarkBoundaryAttrs.d.ts

@@ -12,7 +12,15 @@ declare const isDisplacedByCustomXml: (value: unknown) => value is document_d_ex
 declare const bookmarkBoundaryDisplacement: (attrs: BookmarkBoundaryAttrs) => {
   displacedByCustomXml?: document_d_exports.DisplacedByCustomXml;
 };
+/**
+ * The model marker a boundary node carries, at either level.
+ *
+ * A paragraph, a hyperlink, a revision wrapper and a block container each
+ * rebuild the same two elements from the same attributes; spelling that out
+ * per caller is how one of them comes to forget `w:colFirst`.
+ */
+declare const bookmarkMarkerFromAttrs: (attrs: BookmarkBoundaryAttrs) => document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd;
 declare const readBookmarkBoundaryAttrs: (node: Node) => ReadProseMirrorAttrsResult<BookmarkBoundaryAttrs>;
 declare const expectBookmarkBoundaryAttrs: (node: Node) => BookmarkBoundaryAttrs;
 //#endregion
-export { bookmarkBoundaryDisplacement, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };
+export { bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };

package/dist/prosemirror/bookmarkBoundaryAttrs.js

@@ -8,11 +8,30 @@ const attrsCache = /* @__PURE__ */ new WeakMap();
 * that build either one share this rather than each remembering the attribute.
 */
 const bookmarkBoundaryDisplacement = (attrs) => attrs.displacedByCustomXml === void 0 ? {} : { displacedByCustomXml: attrs.displacedByCustomXml };
+/**
+* The model marker a boundary node carries, at either level.
+*
+* A paragraph, a hyperlink, a revision wrapper and a block container each
+* rebuild the same two elements from the same attributes; spelling that out
+* per caller is how one of them comes to forget `w:colFirst`.
+*/
+const bookmarkMarkerFromAttrs = (attrs) => 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 } : {},
+	...bookmarkBoundaryDisplacement(attrs)
+} : {
+	type: "bookmarkEnd",
+	id: attrs.id,
+	...bookmarkBoundaryDisplacement(attrs)
+};
 const readBookmarkBoundaryAttrs = (node) => {
 	const issues = [];
-	if (node.type.name !== "bookmarkBoundary") issues.push({
+	if (node.type.name !== "bookmarkBoundary" && node.type.name !== "blockBookmarkBoundary") issues.push({
 		path: "bookmarkBoundary.type.name",
-		message: `Expected bookmarkBoundary, got ${node.type.name}.`
+		message: `Expected a bookmark boundary, got ${node.type.name}.`
 	});
 	const type = node.attrs["type"];
 	if (type !== "start" && type !== "end") issues.push({
@@ -78,4 +97,4 @@ const expectBookmarkBoundaryAttrs = (node) => {
 	return result.value;
 };
 //#endregion
-export { bookmarkBoundaryDisplacement, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };
+export { bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };

package/dist/prosemirror/commands/comments.js

@@ -1,3 +1,4 @@
+import { sameStatedParagraphNumbering as sameStatedParagraphNumbering$1 } from "../../docx/numberingReference.js";
 import { joinProseParagraphsWithRightPropertySource } from "../../docx/paragraphPropertySource.js";
 import { appendHeadlessInlineResolution } from "../../internal/headlessRevisionResolution.js";
 import { stateAllowsHeadlessRevisionResolution } from "../../internal/headlessRevisionResolutionGuard.js";
@@ -5,9 +6,10 @@ import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import "../extensions/nodes/SdtExtension.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
 import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
-import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
+import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
@@ -15,11 +17,11 @@ import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { reconcileTableGridAfterColumnRemoval } from "../tableGridMutation.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
-import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
+import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 import { TableMap, removeRow } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
-import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Add a comment mark to the current selection.
@@ -131,7 +133,6 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 							if (remaining.length > 0) restored.propertyChanges = remaining;
 							nextAttrs = nextAttrs ?? { ...node.attrs };
 							nextAttrs["_sectionProperties"] = restored;
-							nextAttrs["sectionBreakType"] = sectionBreakTypeFromSectionStart(restored.sectionStart);
 						}
 					}
 					if (nextAttrs) if (nextAttrs["styleId"] !== node.attrs["styleId"] && styleResolver) setParagraphAttrsWithRebasedRunFormatting({
@@ -153,10 +154,10 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 					if (op) tableRowStructuralOps.push(op);
 				}
 				if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && rangeCoversNode(from, to, pos, node)) tableCellStructuralOps.push(...collectTableCellStructuralOps(node, pos, mode, revisionSet));
-				const tableChangeAttrName = TABLE_PROPERTY_CHANGE_ATTR_BY_NODE[node.type.name];
-				if (tableChangeAttrName !== void 0) {
-					if (rangeCoversNode(from, to, pos, node)) {
-						const nextAttrs = resolveTablePropertyChangeAttrs(node, tableChangeAttrName, mode, revisionSet);
+				const nodeAttrSites = nodePropertyRevisionSites(node.type.name).filter((site) => site.resolution === "node-attrs");
+				if (nodeAttrSites.length > 0) {
+					if (rangeCoversNode(from, to, pos, node)) for (const site of nodeAttrSites) {
+						const nextAttrs = resolveNodePropertyChangeAttrs(tr.doc.nodeAt(pos) ?? node, site, mode, revisionSet);
 						if (nextAttrs) {
 							tr.setNodeMarkup(pos, void 0, nextAttrs);
 							markStructuralChange(tr);
@@ -169,6 +170,13 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				const nodeEnd = pos + node.nodeSize;
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
+				if (node.type.name === "sdt" && removeType !== void 0 && rangeCoversNode(from, to, pos, node) && revisionCoversWholeControl(node, removeType, matchesRevision)) {
+					deleteRanges.push({
+						from: pos,
+						to: nodeEnd
+					});
+					return false;
+				}
 				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
 				const removesNode = removeType !== void 0 && node.marks.some((mark) => mark.type === removeType && matchesRevision(mark));
 				if (runPropertyChangeMark) resolveRunPropertyChange({
@@ -248,7 +256,6 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				const joinedAttrs = {
 					...(emptyFirstParagraph ? nextNode : paragraph).attrs,
 					pPrMark: nextNode.attrs["pPrMark"],
-					sectionBreakType: nextNode.attrs["sectionBreakType"],
 					_sectionProperties: nextNode.attrs["_sectionProperties"]
 				};
 				try {
@@ -554,42 +561,64 @@ function rangeCoversParagraphBoundary(from, to, pos, node) {
 function rangeCoversNode(from, to, pos, node) {
 	return from <= pos && to >= pos + node.nodeSize;
 }
-const SECTION_BREAK_TYPE_VALUES = [
-	"nextPage",
-	"continuous",
-	"oddPage",
-	"evenPage"
-];
-function sectionBreakTypeFromSectionStart(sectionStart) {
-	return SECTION_BREAK_TYPE_VALUES.find((value) => value === sectionStart) ?? null;
+/**
+* Whether a revision covers everything an inline content control holds.
+*
+* The save leg writes such a revision around the control (`w:ins > w:sdt`),
+* so resolving it is an operation over the control itself: a reader who
+* rejects an inserted control gets no control, not an empty one standing
+* where it was. A revision over part of the content is a revision over that
+* part, and a control that holds nothing is covered by nothing.
+*/
+function revisionCoversWholeControl(node, removeType, matchesRevision) {
+	if (node.childCount === 0) return false;
+	for (let index = 0; index < node.childCount; index += 1) {
+		const child = node.child(index);
+		if (child.marks.some((mark) => mark.type === removeType && matchesRevision(mark))) continue;
+		if (child.type.name !== "sdt" || !revisionCoversWholeControl(child, removeType, matchesRevision)) return false;
+	}
+	return true;
 }
-/** PM node type name → the attr its tracked property-change records live on. */
-const TABLE_PROPERTY_CHANGE_ATTR_BY_NODE = {
-	table: "tblPrChange",
-	tableRow: "trPrChange",
-	tableCell: "tcPrChange",
-	tableHeader: "tcPrChange"
+/**
+* The attrs a reject restores for each property revision the shared node-attr
+* pass owns. Total over those kinds, so a revision the model gains either
+* declares a different resolution or states here what rejecting it restores.
+*
+* Each patch narrows the stored set to the property set its own element
+* carries. The casts are the ProseMirror attrs boundary: attrs are untyped,
+* and a record reached through the site filed under a kind is the one that
+* kind's parser and converter wrote.
+*/
+const NODE_ATTRS_REJECT_PATCHES = {
+	tablePropertyChange: (previousFormatting) => tableRejectAttrPatch(previousFormatting),
+	tablePropertyExceptionChange: (previousFormatting) => tablePropertyExceptionsRejectAttrPatch(previousFormatting),
+	tableRowPropertyChange: (previousFormatting) => tableRowRejectAttrPatch(previousFormatting),
+	tableCellPropertyChange: (previousFormatting, node) => tableCellRejectAttrPatch(previousFormatting, node.attrs["_originalFormatting"])
 };
 /**
-* Resolve the tracked property-change records on one table / row / cell node.
+* Resolve the tracked property-change records one site carries on a node.
 * Accept keeps the live formatting and clears the matched records; reject
 * additionally restores the stored previous formatting wholesale (the change
 * element stores the complete old property set — see propertyChangeScope.ts).
 * Returns the next attrs, or `null` when no record matches.
 */
-function resolveTablePropertyChangeAttrs(node, attrName, mode, revisionSet) {
-	const changes = node.attrs[attrName];
-	if (!Array.isArray(changes) || changes.length === 0) return null;
-	const matches = changes.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
+function resolveNodePropertyChangeAttrs(node, site, mode, revisionSet) {
+	const changes = propertyRevisionRecords(node, site);
+	if (changes.length === 0) return null;
+	const matches = changes.filter((change) => {
+		const metadata = propertyRevisionMetadata(change.info);
+		return revisionSet === null || metadata !== null && revisionSet.has(metadata.id);
+	});
 	if (matches.length === 0) return null;
-	const remaining = changes.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
+	const remaining = revisionSet === null ? [] : changes.filter((change) => !matches.includes(change));
 	const nextAttrs = {
 		...node.attrs,
-		[attrName]: remaining.length > 0 ? remaining : null
+		[site.attr]: remaining.length > 0 ? remaining : null
 	};
-	if (mode === "reject") for (const change of matches.toReversed()) if (attrName === "tblPrChange") Object.assign(nextAttrs, tableRejectAttrPatch(change.previousFormatting));
-	else if (attrName === "trPrChange") Object.assign(nextAttrs, tableRowRejectAttrPatch(change.previousFormatting));
-	else Object.assign(nextAttrs, tableCellRejectAttrPatch(change.previousFormatting, node.attrs["_originalFormatting"]));
+	if (mode === "reject") {
+		const rejectPatch = NODE_ATTRS_REJECT_PATCHES[site.kind];
+		for (const change of matches.toReversed()) Object.assign(nextAttrs, rejectPatch(change.previousFormatting, node));
+	}
 	return nextAttrs;
 }
 function isPPrMarkAttr(value) {
@@ -607,10 +636,7 @@ function isPPrMarkAttr(value) {
 * the two ends belong together, not because they resolve differently.
 */
 const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
-const ownsSectionEndpoint = (paragraph) => {
-	const attrs = expectParagraphAttrs(paragraph);
-	return attrs._sectionProperties !== void 0 || attrs.sectionBreakType !== void 0;
-};
+const ownsSectionEndpoint = (paragraph) => expectParagraphAttrs(paragraph)._sectionProperties !== void 0;
 const sectionReferencesOf = (paragraph) => {
 	const sectionProperties = expectParagraphAttrs(paragraph)._sectionProperties;
 	if (!sectionProperties) return [];
@@ -632,23 +658,12 @@ function readRevisionInfo(info) {
 	if (typeof info?.id === "number") revision.revisionId = info.id;
 	return revision;
 }
-function getListPropertyChangeType(attrs, change) {
+function getListPropertyChangeType(node, change) {
 	const previousFormatting = change.previousFormatting;
 	if (previousFormatting == null || !Object.hasOwn(previousFormatting, "numPr")) return null;
-	const currentNumPr = attrs["numPr"];
-	const previousNumPr = previousFormatting["numPr"];
-	if (previousNumPr == null && currentNumPr != null) return "insertion";
-	if (previousNumPr != null && currentNumPr == null) return "deletion";
-	if (!areNumPrValuesEqual(previousNumPr, currentNumPr)) return currentNumPr == null ? "deletion" : "insertion";
-	return null;
-}
-function areNumPrValuesEqual(left, right) {
-	if (left == null || right == null) return left == right;
-	if (!isObjectRecord(left) || !isObjectRecord(right)) return Object.is(left, right);
-	return left["numId"] === right["numId"] && left["ilvl"] === right["ilvl"];
-}
-function isObjectRecord(value) {
-	return typeof value === "object" && value !== null;
+	const current = expectParagraphAttrs(node).numPr;
+	if (sameStatedParagraphNumbering$1(previousFormatting["numPr"] ?? void 0, current)) return null;
+	return current === void 0 ? "deletion" : "insertion";
 }
 function toParagraphBoundaryChange(node, pos, type, info) {
 	return {
@@ -668,7 +683,7 @@ function findParagraphBoundaryChangeAtPosition(state, pos) {
 	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 	if (!Array.isArray(propertyChanges)) return null;
 	for (const change of propertyChanges) {
-		const type = getListPropertyChangeType(node.attrs, change);
+		const type = getListPropertyChangeType(node, change);
 		if (type) return toParagraphBoundaryChange(node, paragraphPos, type, change.info);
 	}
 	return null;

package/dist/prosemirror/commands/contentControls.js

@@ -1,5 +1,7 @@
+import { checkboxDisplayContent } from "../../content-controls/checkboxDisplay.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
 import { formatDate } from "../../docx/fieldParser.js";
+import { preservedSdtChild, withoutPreservedSdtChild } from "../../docx/sdtProperties.js";
 import { expectBlockSdtAttrs } from "../attrs/index.js";
 import { SUGGESTION_BYPASS_META } from "../plugins/suggestionMode.js";
 //#region src/prosemirror/commands/contentControls.ts
@@ -111,19 +113,26 @@ function ensureSdtNotLocked(node, options) {
 	const lock = node.attrs["lock"];
 	if (lock === "sdtLocked" || lock === "sdtContentLocked") throwLockedNode(node, lock);
 }
-const DATA_BINDING_RE = /<\w+:dataBinding\b(?<attrs>[^>]*)\/?>/iu;
 /**
-* Refuse content mutations on bound SDTs unless force; on force, return
-* the stripped rawPropertiesXml so the caller can persist it on the new
-* node attrs. Mirrors the headless `ensureContentNotBound` helper.
+* The control's preserved `w:sdtPr` children, off the node's attrs.
+*
+* `readBlockSdtAttrs` validates the shape at the document boundary, so this
+* is the same record the model carries rather than a second parse of it.
+*/
+const preservedOf = (node) => {
+	const value = node.attrs["_preserved"];
+	return value === null || value === void 0 ? void 0 : value;
+};
+/**
+* Refuse content mutations on bound SDTs unless force; on force, return the
+* attrs override that drops the `w:dataBinding` child, so the caller can
+* persist it on the new node. Mirrors the headless `ensureContentNotBound`.
 */
 function ensureContentNotBound(node, options) {
-	const raw = node.attrs["rawPropertiesXml"];
-	if (typeof raw !== "string") return { strippedRawPropertiesXml: void 0 };
-	const match = DATA_BINDING_RE.exec(raw);
-	if (!match) return { strippedRawPropertiesXml: void 0 };
+	const preserved = preservedOf(node);
+	const attrs = preservedSdtChild(preserved, "dataBinding");
+	if (attrs === void 0) return {};
 	if (!options.force) {
-		const attrs = match.groups?.["attrs"] ?? "";
 		const xpathMatch = /\bxpath="(?<xpath>[^"]*)"/iu.exec(attrs);
 		const storeMatch = /\bstoreItemID="(?<storeItemID>[^"]*)"/iu.exec(attrs);
 		const props = attrsToProperties(node);
@@ -135,7 +144,7 @@ function ensureContentNotBound(node, options) {
 			...props.alias !== void 0 ? { alias: props.alias } : {}
 		});
 	}
-	return { strippedRawPropertiesXml: raw.replaceAll(/<\w+:dataBinding\b[^>]*\/?>(?:[\s\S]*?<\/\w+:dataBinding>)?/giu, "") };
+	return { _preserved: withoutPreservedSdtChild(preserved, "dataBinding") ?? null };
 }
 function paragraphFromText(schema, text) {
 	if (text.length === 0) return schema.node("paragraph", {}, []);
@@ -157,13 +166,13 @@ function setContentControlContentTr(state, filter, input, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);
 	if (!match) return null;
 	ensureContentNotLocked(match.node, options);
-	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
+	const bindingOverride = ensureContentNotBound(match.node, options);
 	if (typeof input !== "string") throw new ContentControlTypeError({
 		message: "Block-content fill must go through `setContentControlContentBlocksTr` (avoids a schema/plugin import cycle); pass a string here.",
 		sdtType: match.node.attrs["sdtType"] ?? "richText",
 		reason: "PM-direct path takes string input only"
 	});
-	return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, input)], strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {});
+	return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, input)], bindingOverride);
 }
 /**
 * Internal helper for the block-content fill variant. Lives in this module
@@ -175,15 +184,13 @@ function replaceBlockSdtChildrenForFill(state, filter, children, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);
 	if (!match) return null;
 	ensureContentNotLocked(match.node, options);
-	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
-	return replaceBlockSdtChildren(state, match, children, strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {});
+	return replaceBlockSdtChildren(state, match, children, ensureContentNotBound(match.node, options));
 }
 function setContentControlValueTr(state, filter, input, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);
 	if (!match) return null;
 	ensureContentNotLocked(match.node, options);
-	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
-	const bindingOverride = strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {};
+	const bindingOverride = ensureContentNotBound(match.node, options);
 	const sdtType = match.node.attrs["sdtType"];
 	if (input.kind === "dropdown") {
 		if (sdtType !== "dropdown" && sdtType !== "comboBox") throw new ContentControlTypeError({
@@ -220,8 +227,15 @@ function setContentControlValueTr(state, filter, input, options = {}) {
 			sdtType,
 			reason: "kind=checkbox requires sdtType=checkbox"
 		});
-		const glyph = input.checked ? "☒" : "☐";
-		return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, glyph)], {
+		const display = checkboxDisplayContent(preservedSdtChild(preservedOf(match.node), "checkbox"), input.checked);
+		let content = display.type === "symbol" ? state.schema.node("symbol", {
+			font: display.font,
+			char: display.char
+		}) : state.schema.text(display.text);
+		const sourceParagraph = match.node.firstChild;
+		const sourceInline = sourceParagraph?.firstChild;
+		if (sourceInline && sourceInline.marks.length > 0) content = content.mark(sourceInline.marks);
+		return replaceBlockSdtChildren(state, match, [state.schema.node("paragraph", sourceParagraph?.type.name === "paragraph" ? sourceParagraph.attrs : {}, [content])], {
 			checked: input.checked,
 			...bindingOverride
 		});
@@ -270,8 +284,7 @@ function parseSdtDate(iso) {
 	return Number.isNaN(parsed.getTime()) ? null : parsed;
 }
 function isRepeatingSection(node) {
-	const raw = node.attrs["rawPropertiesXml"];
-	return typeof raw === "string" && /<\w+:repeatingSection\b/u.test(raw);
+	return preservedSdtChild(preservedOf(node), "repeatingSection") !== void 0;
 }
 function removeContentControlTr(state, filter, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);

package/dist/prosemirror/commands/image.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../../types/document.js";
 import { ImageAttrs, ImagePositionAttrs } from "../schema/nodes.js";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commands/image.d.ts
@@ -25,14 +26,20 @@ type ImagePropertiesInput = {
 };
 type ImageTransformAction = "rotateCW" | "rotateCCW" | "flipH" | "flipV";
 type ResolvedImageWrap = {
-  wrapType: ImageAttrs["wrapType"];
+  wrapType: NonNullable<ImageAttrs["wrapType"]>;
   displayMode: ImageAttrs["displayMode"];
   cssFloat: ImageAttrs["cssFloat"];
 };
 /** Map a toolbar wrap selection to the image's wrapType/displayMode/cssFloat, or null when unknown. */
 declare const resolveImageWrap: (wrapType: string) => ResolvedImageWrap | null;
-/** The CSS transform after applying a rotate/flip action to the current transform string. */
-declare const computeImageTransform: (currentTransform: string, action: ImageTransformAction) => string | undefined;
+/**
+ * The authored transform after applying a rotate/flip action.
+ *
+ * Every field the action decides is stated: rotating back to zero states zero,
+ * un-flipping states `false`. The editor is saying what the drawing is now, and
+ * leaving the field absent would hand the decision back to the file.
+ */
+declare const computeImageTransform: (current: document_d_exports.ImageTransform | undefined, action: ImageTransformAction) => document_d_exports.ImageTransform;
 declare const normalizeImageHorizontalPosition: (data: ImagePositionInput["horizontal"]) => ImagePositionAttrs["horizontal"] | undefined;
 declare const normalizeImageVerticalPosition: (data: ImagePositionInput["vertical"]) => ImagePositionAttrs["vertical"] | undefined;
 /** Clamp an image's intrinsic size to the page text width, preserving aspect ratio. */

package/dist/prosemirror/commands/image.js

@@ -1,7 +1,10 @@
+import { FOLIO_INSERTED_PICTURE_FRAME_LOCKS } from "../../docx/graphicFrameLocks.js";
+import { wrapPolygonFor } from "../../docx/wrapPolygon.js";
 import { IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES } from "../../types/documentEnumValues.js";
 import { isSafeImageFile } from "../../utils/imageValidation.js";
 import { sanitizeImageSrc } from "../../utils/sanitizeImageSrc.js";
 import { expectImageAttrs, mergeImageAttrs } from "../attrs/index.js";
+import { authoredTransformAttrs, readAuthoredTransform } from "../authoredTransformAttrs.js";
 //#region src/prosemirror/commands/image.ts
 /** Map a toolbar wrap selection to the image's wrapType/displayMode/cssFloat, or null when unknown. */
 const resolveImageWrap = (wrapType) => {
@@ -42,32 +45,44 @@ const resolveImageWrap = (wrapType) => {
 		default: return null;
 	}
 };
-/** The CSS transform after applying a rotate/flip action to the current transform string. */
-const computeImageTransform = (currentTransform, action) => {
-	const rotateMatch = /rotate\((?<degrees>-?\d+(?:\.\d+)?)deg\)/u.exec(currentTransform);
-	let rotation = rotateMatch ? Number.parseFloat(rotateMatch.groups["degrees"]) : 0;
-	let hasFlipH = currentTransform.includes("scaleX(-1)");
-	let hasFlipV = currentTransform.includes("scaleY(-1)");
+const QUARTER_TURN = 90;
+const FULL_TURN = 360;
+/**
+* The turn `degrees` names, in `[0, 360)`.
+*
+* `%` keeps the sign of its left operand in JavaScript, and an authored
+* rotation may be negative, so a bare remainder answers `-270` where the
+* drawing is at `90`.
+*/
+const withinOneTurn = (degrees) => (degrees % FULL_TURN + FULL_TURN) % FULL_TURN;
+/**
+* The authored transform after applying a rotate/flip action.
+*
+* Every field the action decides is stated: rotating back to zero states zero,
+* un-flipping states `false`. The editor is saying what the drawing is now, and
+* leaving the field absent would hand the decision back to the file.
+*/
+const computeImageTransform = (current, action) => {
+	const rotation = current?.rotation ?? 0;
 	switch (action) {
-		case "rotateCW":
-			rotation = (rotation + 90) % 360;
-			break;
-		case "rotateCCW":
-			rotation = (rotation - 90 + 360) % 360;
-			break;
-		case "flipH":
-			hasFlipH = !hasFlipH;
-			break;
-		case "flipV":
-			hasFlipV = !hasFlipV;
-			break;
-		default: break;
+		case "rotateCW": return {
+			...current,
+			rotation: withinOneTurn(rotation + QUARTER_TURN)
+		};
+		case "rotateCCW": return {
+			...current,
+			rotation: withinOneTurn(rotation - QUARTER_TURN)
+		};
+		case "flipH": return {
+			...current,
+			flipH: current?.flipH !== true
+		};
+		case "flipV": return {
+			...current,
+			flipV: current?.flipV !== true
+		};
+		default: return action;
 	}
-	const parts = [];
-	if (rotation !== 0) parts.push(`rotate(${rotation}deg)`);
-	if (hasFlipH) parts.push("scaleX(-1)");
-	if (hasFlipV) parts.push("scaleY(-1)");
-	return parts.length > 0 ? parts.join(" ") : void 0;
 };
 const isOneOf = (value, values) => value !== void 0 && values.some((allowed) => allowed === value);
 const normalizeImageHorizontalPosition = (data) => {
@@ -114,10 +129,12 @@ const applyImageWrapType = (view, pos, wrapType) => {
 	if (!node) return false;
 	const resolved = resolveImageWrap(wrapType);
 	if (!resolved) return false;
+	const authoredPolygon = expectImageAttrs(node).wrapPolygon;
 	const tr = view.state.tr.setNodeMarkup(pos, void 0, mergeImageAttrs(node, {
 		wrapType: resolved.wrapType,
 		displayMode: resolved.displayMode,
-		cssFloat: resolved.cssFloat
+		cssFloat: resolved.cssFloat,
+		wrapPolygon: wrapPolygonFor(resolved.wrapType, authoredPolygon) ?? authoredPolygon
 	}));
 	view.dispatch(tr.scrollIntoView());
 	return true;
@@ -126,9 +143,8 @@ const applyImageWrapType = (view, pos, wrapType) => {
 const applyImageTransform = (view, pos, action) => {
 	const node = imageNodeAt(view, pos);
 	if (!node) return false;
-	const currentTransform = expectImageAttrs(node).transform ?? "";
-	const transform = computeImageTransform(currentTransform, action);
-	const tr = view.state.tr.setNodeMarkup(pos, void 0, mergeImageAttrs(node, { transform }));
+	const transform = computeImageTransform(readAuthoredTransform(expectImageAttrs(node)), action);
+	const tr = view.state.tr.setNodeMarkup(pos, void 0, mergeImageAttrs(node, authoredTransformAttrs(transform)));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 };
@@ -185,7 +201,8 @@ const insertImageFromFile = async (view, file, onInserted) => {
 		height: constrained.height,
 		rId: `rId_img_${Date.now()}`,
 		wrapType: "inline",
-		displayMode: "inline"
+		displayMode: "inline",
+		frameLocks: FOLIO_INSERTED_PICTURE_FRAME_LOCKS
 	});
 	const { from } = view.state.selection;
 	const tr = view.state.tr.insert(from, imageNode);

package/dist/prosemirror/commands/pageBreak.js

@@ -29,7 +29,7 @@ const insertPageBreak = (state, dispatch) => {
 	const { $from } = state.selection;
 	if (!pageBreakRunType || !state.selection.empty || !$from.parent.isTextblock) return false;
 	for (let depth = $from.depth; depth >= 0; depth--) if (UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS.has($from.node(depth).type.name)) return false;
-	if ($from.parent.type.name !== "paragraph" || pageBreakRunParagraphProjectionDisposition($from.parent).status === "unsupported" || hasTextBoxAnchorAtOrAfter($from.parent, $from.start(), $from.pos)) return false;
+	if ($from.parent.type.name !== "paragraph" || pageBreakRunParagraphProjectionDisposition($from.parent).status === "approximate" || hasTextBoxAnchorAtOrAfter($from.parent, $from.start(), $from.pos)) return false;
 	if (dispatch) {
 		const pageBreak = pageBreakRunType.create();
 		dispatch(state.tr.replaceSelectionWith(pageBreak).scrollIntoView());