@stll/folio-core 0.47.7 → 0.49.0

package/dist/prosemirror/attrs/index.js

@@ -14,6 +14,7 @@ import { panic } from "better-result";
 import { DRAWING_RAW_XML_MODES, THEME_COLORS, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
 import { isSafePreservedChildXml, isWithinPreservedMarkupBudget } from "@stll/docx-core/schema";
 //#region src/prosemirror/attrs/index.ts
+const RUN_FORMATTING_VALUE_PROPERTY_SET = new Set(RUN_FORMATTING_VALUE_PROPERTIES);
 const PRESERVED_XML_LEVEL_VALUES = new Set(Object.values(PRESERVED_XML_LEVELS));
 const IMAGE_DISPLAY_MODES = [
 	"inline",
@@ -149,15 +150,12 @@ const SECTION_VERTICAL_ALIGNMENTS = [
 	"bottom"
 ];
 const OMITTED_GRID_SLOT_VALUES = ["before", "after"];
-const paragraphAttrsCache = /* @__PURE__ */ new WeakMap();
 const hardBreakAttrsCache = /* @__PURE__ */ new WeakMap();
 const pageBreakRunAttrsCache = /* @__PURE__ */ new WeakMap();
 const tabAttrsCache = /* @__PURE__ */ new WeakMap();
 const symbolAttrsCache = /* @__PURE__ */ new WeakMap();
 const preservedXmlAttrsCache = /* @__PURE__ */ new WeakMap();
 const preservedBlockAttrsCache = /* @__PURE__ */ new WeakMap();
-const tableAttrsCache = /* @__PURE__ */ new WeakMap();
-const tableRowAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableCellAttrsCache = /* @__PURE__ */ new WeakMap();
 const imageAttrsCache = /* @__PURE__ */ new WeakMap();
 const fieldAttrsCache = /* @__PURE__ */ new WeakMap();
@@ -185,7 +183,36 @@ const runIdentityAttrsCache = /* @__PURE__ */ new WeakMap();
 const inlineWrapperAttrsCache = /* @__PURE__ */ new WeakMap();
 const runFormattingOverrideAttrsCache = /* @__PURE__ */ new WeakMap();
 const hyperlinkAttrsCache = /* @__PURE__ */ new WeakMap();
-const readParagraphAttrs = (node) => {
+/**
+* Read a node's attrs once per node. Nodes are immutable, and one conversion
+* reads each paragraph, table and row several times (node validation, the
+* bookmark walk, numbering). The cached result is frozen, value and issues
+* included, so no caller can change what the next one reads.
+*/
+const memoizeNodeAttrsReader = (read) => {
+	const results = /* @__PURE__ */ new WeakMap();
+	return (node) => {
+		const cached = results.get(node);
+		if (cached !== void 0) return cached;
+		const result = freezeAttrsResult(read(node));
+		results.set(node, result);
+		return result;
+	};
+};
+const freezeAttrsResult = (result) => {
+	if (!result.ok) {
+		const issues = result.issues.map((issue) => Object.freeze({ ...issue }));
+		return Object.freeze({
+			ok: false,
+			issues: Object.freeze(issues)
+		});
+	}
+	return Object.freeze({
+		ok: true,
+		value: Object.freeze(result.value)
+	});
+};
+const readParagraphAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "paragraph", issues);
@@ -244,6 +271,7 @@ const readParagraphAttrs = (node) => {
 	});
 	optionalStringArray(attrs, "listLevelNumFmts", "paragraph.attrs.listLevelNumFmts", issues);
 	optionalNumberArray(attrs, "listLevelStarts", "paragraph.attrs.listLevelStarts", issues);
+	optionalTabStops(attrs, "listLevelTabs", "paragraph.attrs.listLevelTabs", issues);
 	optionalNumber(attrs, "listAbstractNumId", "paragraph.attrs.listAbstractNumId", issues);
 	optionalBorderMap(attrs, "borders", "paragraph.attrs.borders", issues, [
 		"top",
@@ -271,7 +299,8 @@ const readParagraphAttrs = (node) => {
 	optionalPreservedAttributes(attrs, "_preservedAttributes", "paragraph.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
-const expectParagraphAttrs = (node) => expectCachedNodeAttrs(node, paragraphAttrsCache, readParagraphAttrs, "paragraph attrs");
+const readParagraphAttrs = memoizeNodeAttrsReader(readParagraphAttrsUncached);
+const expectParagraphAttrs = (node) => expectAttrs(readParagraphAttrs(node), "paragraph attrs");
 const readHardBreakAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -348,7 +377,7 @@ const readPreservedBlockAttrs = (node) => {
 	return attrsResult(attrs, issues);
 };
 const expectPreservedBlockAttrs = (node) => expectCachedNodeAttrs(node, preservedBlockAttrsCache, readPreservedBlockAttrs, "preservedBlock attrs");
-const readTableAttrs = (node) => {
+const readTableAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "table", issues);
@@ -375,8 +404,9 @@ const readTableAttrs = (node) => {
 	optionalTablePreservedMarkup(attrs, "_preserved", "table.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
-const expectTableAttrs = (node) => expectCachedNodeAttrs(node, tableAttrsCache, readTableAttrs, "table attrs");
-const readTableRowAttrs = (node) => {
+const readTableAttrs = memoizeNodeAttrsReader(readTableAttrsUncached);
+const expectTableAttrs = (node) => expectAttrs(readTableAttrs(node), "table attrs");
+const readTableRowAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "tableRow", issues);
@@ -399,7 +429,8 @@ const readTableRowAttrs = (node) => {
 	optionalTablePreservedMarkup(attrs, "_preserved", "tableRow.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
-const expectTableRowAttrs = (node) => expectCachedNodeAttrs(node, tableRowAttrsCache, readTableRowAttrs, "table row attrs");
+const readTableRowAttrs = memoizeNodeAttrsReader(readTableRowAttrsUncached);
+const expectTableRowAttrs = (node) => expectAttrs(readTableRowAttrs(node), "table row attrs");
 const readTableCellAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -509,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");
@@ -606,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");
@@ -623,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);
@@ -650,12 +684,15 @@ 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);
 	optionalPreservedAttributes(attrs, "_preservedAttributes", "textBox.attrs._preservedAttributes", issues);
+	optionalRecord(attrs, "_docxHostParagraph", "textBox.attrs._docxHostParagraph", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTextBoxAttrs = (node) => expectCachedNodeAttrs(node, textBoxAttrsCache, readTextBoxAttrs, "text box attrs");
@@ -1042,8 +1079,7 @@ const readRunFormattingOverrideMarkAttrs = (mark) => {
 	optionalTextFormatting(attrs, "_authoredValues", "runFormattingOverride.attrs._authoredValues", issues);
 	const authoredValues = attrs["_authoredValues"];
 	if (isRecord(authoredValues)) {
-		const allowed = new Set(RUN_FORMATTING_VALUE_PROPERTIES);
-		for (const property of Object.keys(authoredValues)) if (!allowed.has(property)) issues.push({
+		for (const property of Object.keys(authoredValues)) if (!RUN_FORMATTING_VALUE_PROPERTY_SET.has(property)) issues.push({
 			path: `runFormattingOverride.attrs._authoredValues.${property}`,
 			message: "Expected a non-boolean authored formatting property."
 		});
@@ -1587,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)) {
@@ -1636,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.
@@ -2199,6 +2250,7 @@ const validateParagraphFormatting = (value, path, issues) => {
 	]);
 	optionalOneOfArray(value, "listLevelNumFmts", `${path}.listLevelNumFmts`, issues, COUNTER_FORMAT_VALUES);
 	optionalNumberArray(value, "listLevelStarts", `${path}.listLevelStarts`, issues);
+	optionalTabStops(value, "listLevelTabs", `${path}.listLevelTabs`, issues);
 	optionalAutospacingBase(value, `${path}._autospacingBase`, issues);
 	for (const key of ["numPr", "numPrFromStyle"]) optionalParagraphNumbering(value, key, `${path}.${key}`, issues);
 	const direction = value["direction"];
@@ -2523,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 };