@stll/folio-core 0.48.0 → 0.49.0

package/dist/layout-painter/renderParagraph.js

@@ -5,6 +5,7 @@ import { applyComplexScriptFormatting, hasComplexScriptFormatting, resolveComple
 import { getHyperlinkInstanceIndex } from "../layout-engine/measure/hyperlinkInstance.js";
 import { getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont } from "../layout-engine/measure/listMarkerWidth.js";
 import { DEFAULT_FONT_FAMILY, docxScriptFontSize } from "../layout-engine/measure/measureHelpers.js";
+import { SMALL_CAPS_SCALE, smallCapsSegments } from "../layout-engine/measure/smallCapsCasing.js";
 import { calculateTabWidth } from "../layout-engine/measure/tabCalculator.js";
 import { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode, toPaintedText } from "../layout-engine/measure/textMeasurementPolicy.js";
 import { isFloatingImageRun } from "../layout-engine/types.js";
@@ -201,7 +202,6 @@ function applyRunStyles(element, run) {
 	}
 	if (run.letterSpacing) element.style.letterSpacing = `${run.letterSpacing}px`;
 	if (run.allCaps) element.style.textTransform = "uppercase";
-	if (run.smallCaps) element.style.fontVariant = "small-caps";
 	if (run.positionPx) element.style.verticalAlign = `${run.positionPx}px`;
 	applyHorizontalScaleTransform(element, run.horizontalScale);
 	element.style.fontKerning = getRunFontKerningMode(run, 11);
@@ -338,7 +338,8 @@ function applyPmPositions(element, pmStart, pmEnd) {
 }
 const NON_COMPRESSIBLE_WHITESPACE_PATTERN = /([^\S ]+)/gu;
 const HAS_NON_COMPRESSIBLE_WHITESPACE_PATTERN = /[^\S ]/u;
-function appendPaintedText({ host, text, doc, contractedWordSpacing }) {
+/** Fill `host` with `text`, splitting it into word-spacing segments as needed. */
+function fillPaintedText({ host, text, doc, contractedWordSpacing }) {
 	if (!contractedWordSpacing) {
 		host.textContent = text;
 		return;
@@ -357,6 +358,39 @@ function appendPaintedText({ host, text, doc, contractedWordSpacing }) {
 		host.append(segmentEl);
 	}
 }
+function appendPaintedText({ host, text, doc, contractedWordSpacing, smallCapsFontSizePx }) {
+	const wordSpacing = contractedWordSpacing === void 0 ? {} : { contractedWordSpacing };
+	if (smallCapsFontSizePx === void 0) {
+		fillPaintedText({
+			host,
+			text,
+			doc,
+			...wordSpacing
+		});
+		return;
+	}
+	const segments = smallCapsSegments(text);
+	if (!segments.some((segment) => segment.small)) {
+		fillPaintedText({
+			host,
+			text,
+			doc,
+			...wordSpacing
+		});
+		return;
+	}
+	for (const segment of segments) {
+		const segmentEl = doc.createElement("span");
+		if (segment.small) segmentEl.style.fontSize = `${smallCapsFontSizePx}px`;
+		fillPaintedText({
+			host: segmentEl,
+			text: segment.text,
+			doc,
+			...wordSpacing
+		});
+		host.append(segmentEl);
+	}
+}
 function renderTextRun(run, doc, options) {
 	const span = doc.createElement("span");
 	span.className = `${PARAGRAPH_CLASS_NAMES.run} ${PARAGRAPH_CLASS_NAMES.text}`;
@@ -374,6 +408,7 @@ function renderTextRun(run, doc, options) {
 	applyRunStyles(span, run);
 	applyPmPositions(span, run.pmStart, run.pmEnd);
 	const paintedText = toPaintedText(run.text);
+	const smallCapsFontSizePx = run.smallCaps && !run.allCaps ? fontSizePtToPx(run.fontSize || 11) * SMALL_CAPS_SCALE : void 0;
 	const visualSpaceContractionPx = options?.visualSpaceContractionPx;
 	const effectiveHorizontalScaleFactor = getHorizontalScaleFactor(run.horizontalScale) * (options?.ancestorHorizontalScaleFactor ?? 1);
 	const contractedWordSpacing = visualSpaceContractionPx === void 0 || effectiveHorizontalScaleFactor === 0 ? void 0 : `${-visualSpaceContractionPx / effectiveHorizontalScaleFactor}px`;
@@ -393,7 +428,8 @@ function renderTextRun(run, doc, options) {
 			host: anchor,
 			text: paintedText,
 			doc,
-			...contractedWordSpacing !== void 0 ? { contractedWordSpacing } : {}
+			...contractedWordSpacing !== void 0 ? { contractedWordSpacing } : {},
+			...smallCapsFontSizePx !== void 0 ? { smallCapsFontSizePx } : {}
 		});
 		if (!run.hyperlink.noDefaultStyle) {
 			const hyperlinkColor = getHyperlinkTextColor(run, span.style.color);
@@ -406,7 +442,8 @@ function renderTextRun(run, doc, options) {
 		host: span,
 		text: paintedText,
 		doc,
-		...contractedWordSpacing !== void 0 ? { contractedWordSpacing } : {}
+		...contractedWordSpacing !== void 0 ? { contractedWordSpacing } : {},
+		...smallCapsFontSizePx !== void 0 ? { smallCapsFontSizePx } : {}
 	});
 	applyWhitespaceUnderline(span, run);
 	return span;

package/dist/layout-painter/renderTextBox.d.ts

@@ -1,4 +1,4 @@
-import { TableBlock, TableMeasure, TextBoxBlock, TextBoxFragment, TextBoxMeasure } from "../layout-engine/types.js";
+import { TableBlock, TableMeasure, TextBoxBlock, TextBoxFragment, TextBoxGradientFill, TextBoxMeasure } from "../layout-engine/types.js";
 import { RenderContext } from "./renderUtils.js";
 //#region src/layout-painter/renderTextBox.d.ts
 /**
@@ -14,9 +14,19 @@ type RenderTextBoxFragmentOptions = {
   document?: Document;
   renderTable?: (block: TableBlock, measure: TableMeasure, context: RenderContext, document: Document, frameWidth?: number) => HTMLElement;
 };
+/**
+ * The CSS angle of a DrawingML linear gradient over a `width` x `height` box.
+ *
+ * DrawingML measures `a:lin@ang` clockwise from the positive x axis; CSS
+ * measures clockwise from "to top", a quarter turn earlier. A `scaled` angle is
+ * stated in the unit square: stretching that square to the box keeps each
+ * isoline through the same corners, so the gradient runs perpendicular to the
+ * stretched isoline rather than along the stated angle.
+ */
+declare function cssLinearGradientAngle(fill: Pick<TextBoxGradientFill, "angle" | "scaled">, width: number, height: number): number;
 /**
  * Render a text box fragment to DOM
  */
 declare function renderTextBoxFragment(fragment: TextBoxFragment, block: TextBoxBlock, measure: TextBoxMeasure, context: RenderContext, options?: RenderTextBoxFragmentOptions): HTMLElement;
 //#endregion
-export { RenderTextBoxFragmentOptions, TEXTBOX_CLASS_NAMES, renderTextBoxFragment };
+export { RenderTextBoxFragmentOptions, TEXTBOX_CLASS_NAMES, cssLinearGradientAngle, renderTextBoxFragment };

package/dist/layout-painter/renderTextBox.js

@@ -10,7 +10,7 @@ import { panic } from "better-result";
 * Text Box Renderer
 *
 * Renders text box fragments to DOM. Handles:
-* - Background fill color
+* - Background fill color or linear gradient
 * - Border/outline
 * - Internal padding (margins)
 * - Block content inside the box (using pre-measured data)
@@ -20,6 +20,29 @@ import { panic } from "better-result";
 */
 const TEXTBOX_CLASS_NAMES = { textBox: "layout-textbox" };
 /**
+* The CSS angle of a DrawingML linear gradient over a `width` x `height` box.
+*
+* DrawingML measures `a:lin@ang` clockwise from the positive x axis; CSS
+* measures clockwise from "to top", a quarter turn earlier. A `scaled` angle is
+* stated in the unit square: stretching that square to the box keeps each
+* isoline through the same corners, so the gradient runs perpendicular to the
+* stretched isoline rather than along the stated angle.
+*/
+function cssLinearGradientAngle(fill, width, height) {
+	const radians = fill.angle * Math.PI / 180;
+	return ((90 + (fill.scaled && width > 0 && height > 0 ? Math.atan2(width * Math.sin(radians), height * Math.cos(radians)) : radians) * 180 / Math.PI) % 360 + 360) % 360;
+}
+const formatCssNumber = (value) => String(Math.round(value * 1e3) / 1e3);
+function paintGradientFill(style, fill, width, height) {
+	const [first] = fill.stops;
+	if (first === void 0) return;
+	if (fill.stops.length === 1) {
+		setAuthoredBackgroundColor(style, first.color);
+		return;
+	}
+	style.backgroundImage = `linear-gradient(${formatCssNumber(cssLinearGradientAngle(fill, width, height))}deg, ${fill.stops.map((stop) => `${stop.color} ${formatCssNumber(stop.offset * 100)}%`).join(", ")})`;
+}
+/**
 * Render a text box fragment to DOM
 */
 function renderTextBoxFragment(fragment, block, measure, context, options = {}) {
@@ -32,6 +55,7 @@ function renderTextBoxFragment(fragment, block, measure, context, options = {})
 	containerEl.style.overflow = block.textWrap === "none" ? "visible" : "hidden";
 	containerEl.style.boxSizing = "border-box";
 	if (block.fillColor) setAuthoredBackgroundColor(containerEl.style, block.fillColor);
+	else if (block.fillGradient) paintGradientFill(containerEl.style, block.fillGradient, fragment.width, fragment.height);
 	const outlineDash = presetDashForOutlineAttr(block.outlineStyle) ?? "solid";
 	if (block.outlineWidth && block.outlineWidth > 0 && outlineDash !== "none") {
 		const color = block.outlineColor || "#000000";
@@ -93,4 +117,4 @@ function renderTextBoxFragment(fragment, block, measure, context, options = {})
 	return containerEl;
 }
 //#endregion
-export { TEXTBOX_CLASS_NAMES, renderTextBoxFragment };
+export { TEXTBOX_CLASS_NAMES, cssLinearGradientAngle, renderTextBoxFragment };

package/dist/prosemirror/alternateContentAttrs.d.ts

@@ -0,0 +1,9 @@
+import { AlternateContentAttrs } from "./schema/nodes.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/alternateContentAttrs.d.ts
+/** Attach a captured `mc:AlternateContent` to a freshly projected node. */
+declare const withAlternateContent: (node: Node, xml: string | undefined) => Node;
+/** The captured element, while the node is still the one it was attached to. */
+declare const unchangedAlternateContentXml: (node: Node, captured: AlternateContentAttrs | undefined) => string | undefined;
+//#endregion
+export { unchangedAlternateContentXml, withAlternateContent };

package/dist/prosemirror/alternateContentAttrs.js

@@ -0,0 +1,35 @@
+import { canonicalJson } from "../utils/canonicalJson.js";
+//#region src/prosemirror/alternateContentAttrs.ts
+const ALTERNATE_CONTENT_ATTR = "_docxAlternateContent";
+/**
+* What the node says about the shape: its attributes and, for a text box, its
+* content. Marks are left out; they carry the run's properties, which sit
+* outside `mc:AlternateContent`.
+*
+* The projection from the model is lossy, so the node is compared with itself
+* as it was projected rather than the rebuilt shape with the parsed one: a
+* round trip that changed nothing would otherwise read as an edit.
+*/
+const nodeFingerprint = (node) => {
+	const { [ALTERNATE_CONTENT_ATTR]: _captured, ...attrs } = node.attrs;
+	return canonicalJson({
+		attrs,
+		content: node.content.toJSON()
+	});
+};
+/** Attach a captured `mc:AlternateContent` to a freshly projected node. */
+const withAlternateContent = (node, xml) => {
+	if (xml === void 0) return node;
+	const alternateContent = {
+		xml,
+		fingerprint: nodeFingerprint(node)
+	};
+	return node.type.create({
+		...node.attrs,
+		[ALTERNATE_CONTENT_ATTR]: alternateContent
+	}, node.content, node.marks);
+};
+/** The captured element, while the node is still the one it was attached to. */
+const unchangedAlternateContentXml = (node, captured) => captured !== void 0 && captured.fingerprint === nodeFingerprint(node) ? captured.xml : void 0;
+//#endregion
+export { unchangedAlternateContentXml, withAlternateContent };

package/dist/prosemirror/attrs/index.js

@@ -540,6 +540,7 @@ const readFieldAttrs = (node) => {
 	requiredOneOf(attrs, "fieldKind", "field.attrs.fieldKind", issues, FIELD_KINDS);
 	optionalBoolean(attrs, "fldLock", "field.attrs.fldLock", issues);
 	optionalBoolean(attrs, "dirty", "field.attrs.dirty", issues);
+	optionalBoolean(attrs, "fieldResultIsFallback", "field.attrs.fieldResultIsFallback", issues);
 	return attrsResult(attrs, issues);
 };
 const expectFieldAttrs = (node) => expectCachedNodeAttrs(node, fieldAttrsCache, readFieldAttrs, "field attrs");
@@ -637,6 +638,7 @@ const readShapeAttrs = (node) => {
 	optionalNumber(attrs, "shadowOffsetY", "shape.attrs.shadowOffsetY", issues);
 	optionalString(attrs, "glowColor", "shape.attrs.glowColor", issues);
 	optionalNumber(attrs, "glowRadius", "shape.attrs.glowRadius", issues);
+	optionalAlternateContent(attrs, "shape.attrs._docxAlternateContent", issues);
 	return attrsResult(attrs, issues);
 };
 const expectShapeAttrs = (node) => expectCachedNodeAttrs(node, shapeAttrsCache, readShapeAttrs, "shape attrs");
@@ -654,6 +656,7 @@ const readTextBoxAttrs = (node) => {
 	optionalString(attrs, "alt", "textBox.attrs.alt", issues);
 	optionalString(attrs, "title", "textBox.attrs.title", issues);
 	optionalString(attrs, "fillColor", "textBox.attrs.fillColor", issues);
+	optionalGradientFill(attrs, "gradientFill", "textBox.attrs.gradientFill", issues);
 	optionalNumber(attrs, "outlineWidth", "textBox.attrs.outlineWidth", issues);
 	optionalAuthoredEmu(attrs, "_docxAuthoredEmu", "textBox.attrs._docxAuthoredEmu", issues, TEXT_BOX_AUTHORED_EMU_ATTRS);
 	optionalString(attrs, "outlineColor", "textBox.attrs.outlineColor", issues);
@@ -681,8 +684,10 @@ const readTextBoxAttrs = (node) => {
 	optionalEffectExtentSlots(attrs, "wrapEffectExtentSlots", "textBox.attrs.wrapEffectExtentSlots", issues);
 	optionalWrapPolygon(attrs, "wrapPolygon", "textBox.attrs.wrapPolygon", issues);
 	optionalOneOf(attrs, "_docxPlacement", "textBox.attrs._docxPlacement", issues, TEXT_BOX_DOCX_PLACEMENTS);
+	optionalAlternateContent(attrs, "textBox.attrs._docxAlternateContent", issues);
 	optionalString(attrs, "_docxGroupId", "textBox.attrs._docxGroupId", issues);
 	optionalString(attrs, "_docxAnchorId", "textBox.attrs._docxAnchorId", issues);
+	optionalDrawingGroupChild(attrs, "_docxGroupChild", "textBox.attrs._docxGroupChild", issues);
 	requiredTextBoxBodyContentState(attrs, issues);
 	optionalTextBoxTrackedChange(attrs, issues);
 	optionalTextBoxInlineSdts(attrs, issues);
@@ -1618,6 +1623,20 @@ const optionalTextBoxTrackedChange = (attrs, issues) => {
 	requiredString(info, "author", "textBox.attrs._docxTrackedChange.info.author", issues);
 	optionalString(info, "date", "textBox.attrs._docxTrackedChange.info.date", issues);
 };
+/** `_docxAlternateContent`: a captured element and its node fingerprint, or absent. */
+const optionalAlternateContent = (attrs, path, issues) => {
+	const value = attrs["_docxAlternateContent"];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	requiredString(value, "xml", `${path}.xml`, issues);
+	requiredString(value, "fingerprint", `${path}.fingerprint`, issues);
+};
 const requiredTextBoxBodyContentState = (attrs, issues) => {
 	const value = attrs["_docxTextBodyContentState"];
 	if (!isRecord(value)) {
@@ -1667,6 +1686,7 @@ const validateSdtAttrsRecord = (attrs, path, issues) => {
 	optionalPreservedMarkup(attrs, "_preserved", `${path}._preserved`, issues);
 	optionalString(attrs, "rawEndPropertiesXml", `${path}.rawEndPropertiesXml`, issues);
 	optionalSdtEndProperties(attrs, `${path}.endProperties`, issues);
+	optionalNumberArray(attrs, "_docxEnclosingRevisionIds", `${path}._docxEnclosingRevisionIds`, issues);
 };
 /**
 * The attribute remainder an authored element's record carries.
@@ -2555,6 +2575,76 @@ const optionalWrapPolygon = (attrs, key, path, issues) => {
 		readWrapPolygonPoint(point, `${path}.lineTo[${index}]`, issues);
 	});
 };
+/** A text box's gradient fill: the model's `ShapeFill`, and only its gradient arm. */
+const optionalGradientFill = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	if (value["type"] !== "gradient") issues.push({
+		path: `${path}.type`,
+		message: "Expected \"gradient\"."
+	});
+	optionalString(value, "rawXml", `${path}.rawXml`, issues);
+	const gradient = value["gradient"];
+	if (!isRecord(gradient)) {
+		issues.push({
+			path: `${path}.gradient`,
+			message: "Expected an object."
+		});
+		return;
+	}
+	optionalOneOf(gradient, "type", `${path}.gradient.type`, issues, SHAPE_GRADIENT_TYPES);
+	optionalNumber(gradient, "angle", `${path}.gradient.angle`, issues);
+	optionalBoolean(gradient, "scaled", `${path}.gradient.scaled`, issues);
+	const stops = gradient["stops"];
+	if (!Array.isArray(stops)) {
+		issues.push({
+			path: `${path}.gradient.stops`,
+			message: "Expected an array."
+		});
+		return;
+	}
+	stops.forEach((stop, index) => {
+		const stopPath = `${path}.gradient.stops[${index}]`;
+		if (!isRecord(stop)) {
+			issues.push({
+				path: stopPath,
+				message: "Expected a gradient stop object."
+			});
+			return;
+		}
+		if (typeof stop["position"] !== "number") issues.push({
+			path: `${stopPath}.position`,
+			message: "Expected a number."
+		});
+		optionalColorValue(stop, "color", `${stopPath}.color`, issues);
+	});
+};
+/** Where a text box sits inside a DrawingML group: its element path and two fingerprints. */
+const optionalDrawingGroupChild = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	const childPath = value["path"];
+	if (!Array.isArray(childPath) || childPath.length === 0 || !childPath.every((index) => Number.isInteger(index) && index >= 0)) issues.push({
+		path: `${path}.path`,
+		message: "Expected a non-empty array of indices."
+	});
+	requiredString(value, "group", `${path}.group`, issues);
+	requiredString(value, "content", `${path}.content`, issues);
+};
 /** `a:hlinkClick` as captured: its own bytes, plus the target it named. */
 const optionalDocPrLink = (attrs, key, path, issues) => {
 	const value = attrs[key];

package/dist/prosemirror/commands/comments.js

@@ -4,11 +4,13 @@ import { appendHeadlessInlineResolution } from "../../internal/headlessRevisionR
 import { stateAllowsHeadlessRevisionResolution } from "../../internal/headlessRevisionResolutionGuard.js";
 import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
+import { enclosingRevisionIds, resolutionRemovesControl, withoutResolvedEnclosures } from "../contentControlRevisions.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 { rejoinRunsAt } from "../rejoinRunCarriers.js";
 import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
@@ -109,6 +111,8 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 		if (dispatch) {
 			const tr = state.tr;
 			const deleteRanges = [];
+			/** Where resolved inline content began and ended, in `state.doc`. */
+			const resolvedBoundaries = [];
 			const pPrMarkOps = [];
 			const tableRowStructuralOps = [];
 			const tableCellStructuralOps = [];
@@ -198,15 +202,27 @@ 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;
+				if (node.type.name === "sdt") {
+					if (!rangeCoversNode(from, to, pos, node)) return true;
+					const resolvesRevision = (revisionId) => revisionSet === null || revisionSet.has(revisionId);
+					if (resolutionRemovesControl({
+						control: node,
+						removeType,
+						resolves: resolvesRevision
+					})) {
+						deleteRanges.push({
+							from: pos,
+							to: nodeEnd
+						});
+						return false;
+					}
+					const released = withoutResolvedEnclosures(node, resolvesRevision);
+					if (released) tr.setNodeMarkup(pos, void 0, released);
+					return true;
 				}
 				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 (removesNode || runPropertyChangeMark !== void 0 || node.marks.some((mark) => (mark.type === insertionType || mark.type === deletionType) && matchesRevision(mark))) resolvedBoundaries.push(rangeFrom, rangeTo);
 				if (runPropertyChangeMark) resolveRunPropertyChange({
 					tr,
 					node,
@@ -386,6 +402,11 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				removedReferences: removedSectionReferences
 			});
 			if (!terminalTableDeletionIsPending(tr)) resolveTerminalTableReviewCarrier(tr, mode);
+			rejoinRunsAt({
+				tr,
+				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)),
+				styleResolver
+			});
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
@@ -620,24 +641,6 @@ function rangeCoversNode(from, to, pos, node) {
 	return from <= pos && to >= pos + node.nodeSize;
 }
 /**
-* 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;
-}
-/**
 * 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.
@@ -826,6 +829,7 @@ function findAIEditRevisionRange(state, revisionIds) {
 	};
 	state.doc.descendants((node, pos) => {
 		for (const carrier of getFolioNodeRevisionCarriers(node, pos)) if (idSet.has(carrier.id)) includeRange(carrier.from, carrier.to);
+		if (node.type.name === "sdt" && enclosingRevisionIds(node).some((id) => idSet.has(id))) includeRange(pos, pos + node.nodeSize);
 		if (node.type.name === "tableRow") for (const attrName of ["trIns", "trDel"]) {
 			const marker = node.attrs[attrName];
 			if (isTableRowRevisionAttr(marker) && idSet.has(marker.revisionId)) {
@@ -1724,24 +1728,30 @@ function expandTrackedChangeRange(state, mark, fromHint, toHint) {
 	const carriesSameInlineMark = (node) => node?.isInline === true && node.marks.some((m) => m.eq(mark));
 	let from = fromHint;
 	let to = toHint;
-	let $from = state.doc.resolve(from);
-	let nodeBefore = $from.nodeBefore;
-	while (carriesSameInlineMark(nodeBefore)) {
-		from -= nodeBefore.nodeSize;
-		$from = state.doc.resolve(from);
-		nodeBefore = $from.nodeBefore;
-	}
-	let $to = state.doc.resolve(to);
-	let nodeAfter = $to.nodeAfter;
-	while (carriesSameInlineMark(nodeAfter)) {
-		to += nodeAfter.nodeSize;
-		$to = state.doc.resolve(to);
-		nodeAfter = $to.nodeAfter;
+	const revisionId = mark.attrs["revisionId"];
+	for (;;) {
+		let $from = state.doc.resolve(from);
+		let nodeBefore = $from.nodeBefore;
+		while (carriesSameInlineMark(nodeBefore)) {
+			from -= nodeBefore.nodeSize;
+			$from = state.doc.resolve(from);
+			nodeBefore = $from.nodeBefore;
+		}
+		let $to = state.doc.resolve(to);
+		let nodeAfter = $to.nodeAfter;
+		while (carriesSameInlineMark(nodeAfter)) {
+			to += nodeAfter.nodeSize;
+			$to = state.doc.resolve(to);
+			nodeAfter = $to.nodeAfter;
+		}
+		const control = $from.parent;
+		if (control.type.name !== "sdt" || typeof revisionId !== "number" || !enclosingRevisionIds(control).includes(revisionId) || from !== $from.start() || to !== $from.end()) return {
+			from,
+			to
+		};
+		from = $from.before();
+		to = $from.after();
 	}
-	return {
-		from,
-		to
-	};
 }
 /**
 * Find the next tracked change after the given position. Returns the full

package/dist/prosemirror/contentControlRevisions.d.ts

@@ -0,0 +1,43 @@
+import { Transaction } from "prosemirror-state";
+import { MarkType, Node } from "prosemirror-model";
+//#region src/prosemirror/contentControlRevisions.d.ts
+declare const ENCLOSING_REVISION_IDS_ATTR = "_docxEnclosingRevisionIds";
+/** The revisions whose element encloses `control`. */
+declare const enclosingRevisionIds: (control: Node) => readonly number[];
+/** `control`'s attrs with `revisionId` added to its enclosing revisions. */
+declare const withEnclosingRevision: (control: Node, revisionId: number) => Node["attrs"] | null;
+type ResolutionRemovesControlOptions = {
+  control: Node;
+  /** The revision mark type the resolution removes content under. */
+  removeType: MarkType | undefined;
+  /** Whether the resolution resolves revision `revisionId`. */
+  resolves: (revisionId: number) => boolean;
+};
+/**
+ * Whether resolving removes the control itself: a revision that encloses it is
+ * resolved in the direction that removes its content, and still covers all of
+ * it. Removing only the content leaves the control standing, emptied.
+ */
+declare const resolutionRemovesControl: ({ control, removeType, resolves }: ResolutionRemovesControlOptions) => boolean;
+/**
+ * `control`'s attrs without the enclosing revisions `resolved` names, or
+ * `null` when none of them is: a resolved revision no longer exists, and an id
+ * left behind would claim whatever revision is later given that id.
+ */
+declare const withoutResolvedEnclosures: (control: Node, resolved: (revisionId: number) => boolean) => Node["attrs"] | null;
+type EncloseWholeControlsOptions = {
+  tr: Transaction;
+  from: number;
+  to: number;
+  revisionId: number;
+};
+/**
+ * Record `revisionId` as enclosing every inline control `[from, to]` covers
+ * whole, opening and closing token included: the revision removes or adds the
+ * control, as deleting or inserting the same range directly would. A control
+ * the range covers only the content of is left alone, and its revision stays
+ * one over that content.
+ */
+declare const encloseWholeControls: ({ tr, from, to, revisionId }: EncloseWholeControlsOptions) => void;
+//#endregion
+export { ENCLOSING_REVISION_IDS_ATTR, encloseWholeControls, enclosingRevisionIds, resolutionRemovesControl, withEnclosingRevision, withoutResolvedEnclosures };

package/dist/prosemirror/contentControlRevisions.js

@@ -0,0 +1,84 @@
+import { expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+import "./extensions/nodes/SdtExtension.js";
+//#region src/prosemirror/contentControlRevisions.ts
+const ENCLOSING_REVISION_IDS_ATTR = "_docxEnclosingRevisionIds";
+const isInlineControl = (node) => node.type.name === "sdt";
+/** The revisions whose element encloses `control`. */
+const enclosingRevisionIds = (control) => {
+	const ids = control.attrs[ENCLOSING_REVISION_IDS_ATTR];
+	return Array.isArray(ids) ? ids.filter((id) => typeof id === "number") : [];
+};
+/** `control`'s attrs with `revisionId` added to its enclosing revisions. */
+const withEnclosingRevision = (control, revisionId) => {
+	const ids = enclosingRevisionIds(control);
+	return ids.includes(revisionId) ? null : {
+		...control.attrs,
+		[ENCLOSING_REVISION_IDS_ATTR]: [...ids, revisionId]
+	};
+};
+const REMOVED_LAYERS = {
+	deletion: /* @__PURE__ */ new Set(["deletion", "moveFrom"]),
+	insertion: /* @__PURE__ */ new Set(["insertion", "moveTo"])
+};
+/** Whether `mark`, or a revision it is nested in, is `revisionId` of `removeType`'s kind. */
+const carriesRevision = (mark, removeType, revisionId) => {
+	if (mark.type.name !== "insertion" && mark.type.name !== "deletion") return false;
+	const attrs = expectTrackedChangeMarkAttrs(mark);
+	if (mark.type === removeType && attrs.revisionId === revisionId) return true;
+	const removed = removeType.name === "deletion" ? REMOVED_LAYERS.deletion : REMOVED_LAYERS.insertion;
+	return (attrs._docxRevisionAncestors ?? []).some((layer) => layer.revisionId === revisionId && removed.has(layer.type));
+};
+const coveredBy = (node, covers) => {
+	if (node.childCount === 0) return false;
+	for (let index = 0; index < node.childCount; index += 1) {
+		const child = node.child(index);
+		if (child.marks.some(covers)) continue;
+		if (!isInlineControl(child) || !coveredBy(child, covers)) return false;
+	}
+	return true;
+};
+/**
+* Whether resolving removes the control itself: a revision that encloses it is
+* resolved in the direction that removes its content, and still covers all of
+* it. Removing only the content leaves the control standing, emptied.
+*/
+const resolutionRemovesControl = ({ control, removeType, resolves }) => {
+	if (removeType === void 0 || !isInlineControl(control)) return false;
+	return enclosingRevisionIds(control).some((revisionId) => resolves(revisionId) && coveredBy(control, (mark) => carriesRevision(mark, removeType, revisionId)));
+};
+/**
+* `control`'s attrs without the enclosing revisions `resolved` names, or
+* `null` when none of them is: a resolved revision no longer exists, and an id
+* left behind would claim whatever revision is later given that id.
+*/
+const withoutResolvedEnclosures = (control, resolved) => {
+	const ids = enclosingRevisionIds(control);
+	const remaining = ids.filter((revisionId) => !resolved(revisionId));
+	if (remaining.length === ids.length) return null;
+	return {
+		...control.attrs,
+		[ENCLOSING_REVISION_IDS_ATTR]: remaining.length > 0 ? remaining : null
+	};
+};
+/**
+* Record `revisionId` as enclosing every inline control `[from, to]` covers
+* whole, opening and closing token included: the revision removes or adds the
+* control, as deleting or inserting the same range directly would. A control
+* the range covers only the content of is left alone, and its revision stays
+* one over that content.
+*/
+const encloseWholeControls = ({ tr, from, to, revisionId }) => {
+	const enclosed = [];
+	tr.doc.nodesBetween(from, to, (node, pos) => {
+		if (!isInlineControl(node) || pos < from || pos + node.nodeSize > to) return true;
+		const attrs = withEnclosingRevision(node, revisionId);
+		if (attrs) enclosed.push({
+			pos,
+			attrs
+		});
+		return true;
+	});
+	for (const { pos, attrs } of enclosed) tr.setNodeMarkup(pos, void 0, attrs);
+};
+//#endregion
+export { ENCLOSING_REVISION_IDS_ATTR, encloseWholeControls, enclosingRevisionIds, resolutionRemovesControl, withEnclosingRevision, withoutResolvedEnclosures };