@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/anchoredTextBoxes.d.ts

@@ -0,0 +1,37 @@
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/anchoredTextBoxes.d.ts
+/** The id a text box anchor names, or `undefined` for anything else. */
+declare const textBoxAnchorIdOf: (node: Node) => string | undefined;
+/** The anchor ids of the text boxes drawn in `node`. */
+declare const textBoxAnchorIdsIn: (node: Node) => Set<string>;
+/** The anchor id of a text box block drawn in a paragraph, or `undefined`. */
+declare const anchoredTextBoxId: (node: Node) => string | undefined;
+/**
+ * Where the paragraph at `position` ends together with the text boxes drawn
+ * in it that follow it: the place for a block inserted after the paragraph.
+ */
+declare const endOfParagraphWithItsTextBoxes: (doc: Node, position: number) => number;
+/** Anchor ids `before` holds and `after` does not. */
+declare const droppedTextBoxAnchorIds: (before: Node, after: Node) => Set<string>;
+/**
+ * Delete the text box blocks whose anchors are in `anchorIds`. Returns whether
+ * any went.
+ */
+declare const deleteTextBoxesAnchoredAt: (tr: Transaction, anchorIds: ReadonlySet<string>) => boolean;
+/**
+ * Put every text box drawn in the paragraph at `position` right after it,
+ * keeping the boxes' order. For a paragraph just split: the boxes follow the
+ * second half, and those anchored in the first half move up to it.
+ */
+declare const gatherTextBoxesAfterParagraph: (tr: Transaction, position: number) => void;
+/** The anchor ids of the text boxes drawn between `from` and `to`. */
+declare const textBoxAnchorIdsBetween: (doc: Node, from: number, to: number) => Set<string>;
+/**
+ * Before the paragraph at `position` joins the one after it: move the text
+ * boxes drawn in it, which stand between the two, past that paragraph, where
+ * they follow the joined one. Returns whether any moved.
+ */
+declare const moveTextBoxesPastNextParagraph: (tr: Transaction, position: number) => boolean;
+//#endregion
+export { anchoredTextBoxId, deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, endOfParagraphWithItsTextBoxes, gatherTextBoxesAfterParagraph, moveTextBoxesPastNextParagraph, textBoxAnchorIdOf, textBoxAnchorIdsBetween, textBoxAnchorIdsIn };

package/dist/prosemirror/anchoredTextBoxes.js

@@ -0,0 +1,156 @@
+import { expectTextBoxAttrs } from "./attrs/index.js";
+import "./extensions/nodes/TextBoxAnchorExtension.js";
+import { readTextBoxAnchorAttrs } from "./textBoxAnchorAttrs.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/anchoredTextBoxes.ts
+/**
+* A text box and the paragraph it is drawn in.
+*
+* In DOCX a text box is run content: a `w:drawing` in a run of its paragraph.
+* The editor lifts it out into a `textBox` block after that paragraph and
+* leaves a zero-width `textBoxAnchor` where the run was; the save puts the box
+* back at its anchor, wherever the block has ended up. So the anchor, not the
+* block's position, says which paragraph owns the box, and two rules follow:
+*
+* - The box follows its anchor. A paragraph deleted, or its anchor deleted,
+*   takes the box with it: a drawing is content of the paragraph it is in.
+*   Left behind, the block was saved into whatever paragraph came before it.
+* - The box sits right after its paragraph. The reader lists the box's
+*   paragraphs where the block is, and a reopened package puts the block
+*   right after the paragraph holding its anchor, so a block written between
+*   the two is read in a different order once saved.
+*
+* Only a box placed `inlineWithPrevious` has an anchor: a `standalone` one
+* stands in for a paragraph that held nothing else.
+*/
+/**
+* Add the anchor id of `node`, when it is an anchor that names one. An anchor
+* naming none ties no box to its paragraph.
+*/
+const collectAnchorId = (node, ids) => {
+	const anchorId = textBoxAnchorIdOf(node);
+	if (anchorId !== void 0) ids.add(anchorId);
+};
+/** The id a text box anchor names, or `undefined` for anything else. */
+const textBoxAnchorIdOf = (node) => {
+	if (node.type.name !== "textBoxAnchor") return;
+	const attrs = readTextBoxAnchorAttrs(node);
+	return attrs.ok ? attrs.value.anchorId : void 0;
+};
+/** The anchor ids of the text boxes drawn in `node`. */
+const textBoxAnchorIdsIn = (node) => {
+	const ids = /* @__PURE__ */ new Set();
+	node.descendants((child) => {
+		collectAnchorId(child, ids);
+		return true;
+	});
+	return ids;
+};
+/** The anchor id of a text box block drawn in a paragraph, or `undefined`. */
+const anchoredTextBoxId = (node) => {
+	if (node.type.name !== "textBox") return;
+	const attrs = expectTextBoxAttrs(node);
+	return attrs._docxPlacement === "inlineWithPrevious" ? attrs._docxAnchorId : void 0;
+};
+/**
+* Where the paragraph at `position` ends together with the text boxes drawn
+* in it that follow it: the place for a block inserted after the paragraph.
+*/
+const endOfParagraphWithItsTextBoxes = (doc, position) => {
+	const paragraph = doc.nodeAt(position);
+	if (!paragraph) return position;
+	let end = position + paragraph.nodeSize;
+	const anchors = textBoxAnchorIdsIn(paragraph);
+	if (anchors.size === 0) return end;
+	const after = doc.resolve(end);
+	for (let index = after.index(); index < after.parent.childCount; index += 1) {
+		const sibling = after.parent.child(index);
+		const anchorId = anchoredTextBoxId(sibling);
+		if (anchorId === void 0 || !anchors.has(anchorId)) break;
+		end += sibling.nodeSize;
+	}
+	return end;
+};
+/** Anchor ids `before` holds and `after` does not. */
+const droppedTextBoxAnchorIds = (before, after) => {
+	const dropped = textBoxAnchorIdsIn(before);
+	if (dropped.size === 0) return dropped;
+	for (const anchorId of textBoxAnchorIdsIn(after)) dropped.delete(anchorId);
+	return dropped;
+};
+/**
+* Delete the text box blocks whose anchors are in `anchorIds`. Returns whether
+* any went.
+*/
+const deleteTextBoxesAnchoredAt = (tr, anchorIds) => {
+	if (anchorIds.size === 0) return false;
+	const ranges = [];
+	tr.doc.descendants((node, position) => {
+		const anchorId = anchoredTextBoxId(node);
+		if (anchorId !== void 0 && anchorIds.has(anchorId)) {
+			ranges.push({
+				from: position,
+				to: position + node.nodeSize
+			});
+			return false;
+		}
+		return !node.isTextblock;
+	});
+	for (const { from, to } of ranges.toReversed()) tr.delete(from, to);
+	return ranges.length > 0;
+};
+/**
+* Put every text box drawn in the paragraph at `position` right after it,
+* keeping the boxes' order. For a paragraph just split: the boxes follow the
+* second half, and those anchored in the first half move up to it.
+*/
+const gatherTextBoxesAfterParagraph = (tr, position) => {
+	const paragraph = tr.doc.nodeAt(position);
+	if (!paragraph) return;
+	const anchors = textBoxAnchorIdsIn(paragraph);
+	if (anchors.size === 0) return;
+	const boxesEnd = endOfParagraphWithItsTextBoxes(tr.doc, position);
+	const at = tr.doc.resolve(boxesEnd);
+	const moved = [];
+	let offset = boxesEnd;
+	for (let index = at.index(); index < at.parent.childCount; index += 1) {
+		const sibling = at.parent.child(index);
+		const anchorId = anchoredTextBoxId(sibling);
+		if (anchorId !== void 0 && anchors.has(anchorId)) moved.push({
+			node: sibling,
+			from: offset
+		});
+		offset += sibling.nodeSize;
+	}
+	if (moved.length === 0) return;
+	for (const { node, from } of moved.toReversed()) tr.delete(from, from + node.nodeSize);
+	tr.insert(boxesEnd, Fragment.fromArray(moved.map(({ node }) => node)));
+};
+/** The anchor ids of the text boxes drawn between `from` and `to`. */
+const textBoxAnchorIdsBetween = (doc, from, to) => {
+	const ids = /* @__PURE__ */ new Set();
+	doc.nodesBetween(from, to, (node) => {
+		collectAnchorId(node, ids);
+		return true;
+	});
+	return ids;
+};
+/**
+* Before the paragraph at `position` joins the one after it: move the text
+* boxes drawn in it, which stand between the two, past that paragraph, where
+* they follow the joined one. Returns whether any moved.
+*/
+const moveTextBoxesPastNextParagraph = (tr, position) => {
+	const paragraph = tr.doc.nodeAt(position);
+	if (!paragraph) return false;
+	const paragraphEnd = position + paragraph.nodeSize;
+	const boxesEnd = endOfParagraphWithItsTextBoxes(tr.doc, position);
+	const next = boxesEnd > paragraphEnd ? tr.doc.nodeAt(boxesEnd) : null;
+	if (!next || next.type !== paragraph.type) return false;
+	const boxes = tr.doc.slice(paragraphEnd, boxesEnd).content;
+	tr.delete(paragraphEnd, boxesEnd);
+	tr.insert(paragraphEnd + next.nodeSize, boxes);
+	return true;
+};
+//#endregion
+export { anchoredTextBoxId, deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, endOfParagraphWithItsTextBoxes, gatherTextBoxesAfterParagraph, moveTextBoxesPastNextParagraph, textBoxAnchorIdOf, textBoxAnchorIdsBetween, textBoxAnchorIdsIn };

package/dist/prosemirror/attrs/index.d.ts

@@ -1,5 +1,5 @@
 import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs } from "../schema/marks.js";
-import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
+import { BlockCustomXmlAttrs, BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
 import "../schema/index.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/attrs/index.d.ts
@@ -36,12 +36,16 @@ declare const readTableCellAttrs: (node: Node) => ReadProseMirrorAttrsResult<Tab
 declare const expectTableCellAttrs: (node: Node) => TableCellAttrs;
 declare const readImageAttrs: (node: Node) => ReadProseMirrorAttrsResult<ImageAttrs>;
 declare const expectImageAttrs: (node: Node) => ImageAttrs;
+declare const isValidEmptyFieldResultRuns: (value: unknown) => value is NonNullable<FieldAttrs["_docxEmptyResultRuns"]>;
+declare const isValidFieldCode: (value: unknown) => value is NonNullable<FieldAttrs["_docxFieldCode"]>;
 declare const readFieldAttrs: (node: Node) => ReadProseMirrorAttrsResult<FieldAttrs>;
 declare const expectFieldAttrs: (node: Node) => FieldAttrs;
 declare const readMathAttrs: (node: Node) => ReadProseMirrorAttrsResult<MathAttrs>;
 declare const expectMathAttrs: (node: Node) => MathAttrs;
 declare const readSdtAttrs: (node: Node) => ReadProseMirrorAttrsResult<SdtAttrs>;
 declare const expectSdtAttrs: (node: Node) => SdtAttrs;
+declare const readBlockCustomXmlAttrs: (node: Node) => ReadProseMirrorAttrsResult<BlockCustomXmlAttrs>;
+declare const expectBlockCustomXmlAttrs: (node: Node) => BlockCustomXmlAttrs;
 declare const readBlockSdtAttrs: (node: Node) => ReadProseMirrorAttrsResult<BlockSdtAttrs>;
 declare const expectBlockSdtAttrs: (node: Node) => BlockSdtAttrs;
 declare const readShapeAttrs: (node: Node) => ReadProseMirrorAttrsResult<ShapeAttrs>;
@@ -119,4 +123,4 @@ declare const mergeTableRowAttrs: (node: Node, patch: NodeAttrPatch<TableRowAttr
  */
 declare const mergeTableCellAttrs: (node: Node, patch: NodeAttrPatch<TableCellAttrs>) => TableCellAttrs;
 //#endregion
-export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, isValidEmptyFieldResultRuns, isValidFieldCode, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };

package/dist/prosemirror/attrs/index.js

@@ -374,6 +374,7 @@ const readPreservedBlockAttrs = (node) => {
 	const issues = [];
 	expectNodeType(node, "preservedBlock", issues);
 	requiredString(attrs, "xml", "preservedBlock.attrs.xml", issues);
+	optionalString(attrs, "readerText", "preservedBlock.attrs.readerText", issues);
 	return attrsResult(attrs, issues);
 };
 const expectPreservedBlockAttrs = (node) => expectCachedNodeAttrs(node, preservedBlockAttrsCache, readPreservedBlockAttrs, "preservedBlock attrs");
@@ -402,6 +403,7 @@ const readTableAttrsUncached = (node) => {
 	optionalRecord(attrs, "_originalFormatting", "table.attrs._originalFormatting", issues);
 	optionalPositionedBookmarks(attrs, "table.attrs._bookmarks", issues);
 	optionalTablePreservedMarkup(attrs, "_preserved", "table.attrs._preserved", issues);
+	optionalTableContentCarriers(attrs, "carrierStack", "table.attrs.carrierStack", issues);
 	return attrsResult(attrs, issues);
 };
 const readTableAttrs = memoizeNodeAttrsReader(readTableAttrsUncached);
@@ -426,6 +428,7 @@ const readTableRowAttrsUncached = (node) => {
 	optionalPreservedAttributes(attrs, "_preservedAttributes", "tableRow.attrs._preservedAttributes", issues);
 	optionalPositionedBookmarks(attrs, "tableRow.attrs._bookmarks", issues);
 	optionalContentControls(attrs, "tableRow.attrs.contentControls", issues);
+	optionalTableContentCarriers(attrs, "carrierStack", "tableRow.attrs.carrierStack", issues);
 	optionalTablePreservedMarkup(attrs, "_preserved", "tableRow.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
@@ -461,6 +464,7 @@ const readTableCellAttrs = (node) => {
 	optionalRecord(attrs, "_originalFormatting", "tableCell.attrs._originalFormatting", issues);
 	optionalTableCellRevision(attrs, issues);
 	optionalContentControls(attrs, "tableCell.attrs.contentControls", issues);
+	optionalTableContentCarriers(attrs, "carrierStack", "tableCell.attrs.carrierStack", issues);
 	optionalBoolean(attrs, "_preserveVMergeRestart", "tableCell.attrs._preserveVMergeRestart", issues);
 	return attrsResult(attrs, issues);
 };
@@ -529,6 +533,81 @@ const readImageAttrs = (node) => {
 	return attrsResult(attrs, issues);
 };
 const expectImageAttrs = (node) => expectCachedNodeAttrs(node, imageAttrsCache, readImageAttrs, "image attrs");
+const validateEmptyFieldResultRuns = (value, issues) => {
+	if (!Array.isArray(value) || value.length === 0) {
+		issues.push({
+			path: "field.attrs._docxEmptyResultRuns",
+			message: "Expected a nonempty array of empty runs."
+		});
+		return;
+	}
+	for (const [index, run] of value.entries()) {
+		const path = `field.attrs._docxEmptyResultRuns[${index}]`;
+		if (!isRecord(run) || run["type"] !== "run") {
+			issues.push({
+				path,
+				message: "Expected a run."
+			});
+			continue;
+		}
+		const content = run["content"];
+		if (!Array.isArray(content) || !content.every((item) => isRecord(item) && item["type"] === "text" && item["text"] === "")) issues.push({
+			path: `${path}.content`,
+			message: "Expected only empty text."
+		});
+		const formatting = run["formatting"];
+		if (formatting !== void 0) if (!isRecord(formatting)) issues.push({
+			path: `${path}.formatting`,
+			message: "Expected formatting object."
+		});
+		else validateTextFormatting(formatting, `${path}.formatting`, issues);
+		optionalPropertyChanges(run, "propertyChanges", `${path}.propertyChanges`, issues, ["runPropertyChange"]);
+		optionalPreservedAttributes(run, "preservedAttributes", `${path}.preservedAttributes`, issues);
+	}
+};
+const isValidEmptyFieldResultRuns = (value) => {
+	const issues = [];
+	validateEmptyFieldResultRuns(value, issues);
+	return issues.length === 0;
+};
+const isFieldCodeContent = (value) => {
+	if (!isRecord(value)) return false;
+	switch (value["type"]) {
+		case "text":
+		case "instrText": return typeof value["text"] === "string";
+		case "fieldChar": return value["charType"] === "begin" || value["charType"] === "separate" || value["charType"] === "end";
+		case "preservedXml": return typeof value["xml"] === "string" && isSafePreservedChildXml(value["xml"]) && typeof value["text"] === "string";
+		case "symbol": return typeof value["font"] === "string" && typeof value["char"] === "string";
+		case "footnoteRef":
+		case "endnoteRef": return typeof value["id"] === "number";
+		case "drawing": return isRecord(value["image"]);
+		case "shape": return isRecord(value["shape"]);
+		case "tab":
+		case "break":
+		case "softHyphen":
+		case "noBreakHyphen":
+		case "renderedPageBreak": return true;
+		default: return false;
+	}
+};
+const isValidFieldCode = (value) => {
+	if (!isRecord(value) || typeof value["instruction"] !== "string") return false;
+	const runs = value["runs"];
+	if (!Array.isArray(runs) || runs.length === 0) return false;
+	const issues = [];
+	for (const [index, run] of runs.entries()) {
+		if (!isRecord(run) || run["type"] !== "run" || !Array.isArray(run["content"])) return false;
+		if (!run["content"].every(isFieldCodeContent)) return false;
+		const path = `field.attrs._docxFieldCode.runs[${index}]`;
+		if (run["formatting"] !== void 0) {
+			if (!isRecord(run["formatting"])) return false;
+			validateTextFormatting(run["formatting"], `${path}.formatting`, issues);
+		}
+		optionalPropertyChanges(run, "propertyChanges", `${path}.propertyChanges`, issues, ["runPropertyChange"]);
+		optionalPreservedAttributes(run, "preservedAttributes", `${path}.preservedAttributes`, issues);
+	}
+	return issues.length === 0;
+};
 const readFieldAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -541,6 +620,34 @@ const readFieldAttrs = (node) => {
 	optionalBoolean(attrs, "fldLock", "field.attrs.fldLock", issues);
 	optionalBoolean(attrs, "dirty", "field.attrs.dirty", issues);
 	optionalBoolean(attrs, "fieldResultIsFallback", "field.attrs.fieldResultIsFallback", issues);
+	optionalString(attrs, "formFieldDataXml", "field.attrs.formFieldDataXml", issues);
+	if (attrs["fieldKind"] === "simple") {
+		if (attrs["fieldResultIsFallback"] !== void 0 && attrs["fieldResultIsFallback"] !== null) issues.push({
+			path: "field.attrs.fieldResultIsFallback",
+			message: "Simple fields cannot have a synthesized complex-field result."
+		});
+		if (attrs["formFieldDataXml"] !== void 0 && attrs["formFieldDataXml"] !== null) issues.push({
+			path: "field.attrs.formFieldDataXml",
+			message: "Simple fields cannot carry complex-field form data."
+		});
+	}
+	const emptyResultRuns = attrs["_docxEmptyResultRuns"];
+	if (emptyResultRuns !== void 0 && emptyResultRuns !== null) validateEmptyFieldResultRuns(emptyResultRuns, issues);
+	const fieldCode = attrs["_docxFieldCode"];
+	if (fieldCode !== void 0 && fieldCode !== null && !isValidFieldCode(fieldCode)) issues.push({
+		path: "field.attrs._docxFieldCode",
+		message: "Expected source field code runs."
+	});
+	if (attrs["fieldKind"] === "simple") {
+		if (fieldCode !== void 0 && fieldCode !== null) issues.push({
+			path: "field.attrs._docxFieldCode",
+			message: "Simple fields cannot carry complex-field code runs."
+		});
+		if (attrs["fieldResultIsFallback"] !== void 0 && attrs["fieldResultIsFallback"] !== null) issues.push({
+			path: "field.attrs.fieldResultIsFallback",
+			message: "Simple fields cannot have a synthesized complex-field result."
+		});
+	}
 	return attrsResult(attrs, issues);
 };
 const expectFieldAttrs = (node) => expectCachedNodeAttrs(node, fieldAttrsCache, readFieldAttrs, "field attrs");
@@ -563,6 +670,17 @@ const readSdtAttrs = (node) => {
 };
 const expectSdtAttrs = (node) => expectCachedNodeAttrs(node, sdtAttrsCache, readSdtAttrs, "sdt attrs");
 const blockSdtAttrsCache = /* @__PURE__ */ new WeakMap();
+const blockCustomXmlAttrsCache = /* @__PURE__ */ new WeakMap();
+const readBlockCustomXmlAttrs = (node) => {
+	const attrs = attrsRecord(node.attrs);
+	const issues = [];
+	expectNodeType(node, "blockCustomXml", issues);
+	requiredString(attrs, "openingXml", "blockCustomXml.attrs.openingXml", issues);
+	requiredString(attrs, "closingXml", "blockCustomXml.attrs.closingXml", issues);
+	optionalBoolean(attrs, "_originallyEmpty", "blockCustomXml.attrs._originallyEmpty", issues);
+	return attrsResult(attrs, issues);
+};
+const expectBlockCustomXmlAttrs = (node) => expectCachedNodeAttrs(node, blockCustomXmlAttrsCache, readBlockCustomXmlAttrs, "blockCustomXml attrs");
 const readBlockSdtAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -1724,6 +1842,57 @@ const optionalContentControls = (attrs, path, issues) => {
 		requiredString(entry, "sdtType", `${entryPath}.sdtType`, issues);
 	}
 };
+const optionalTableContentCarriers = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, carrier] of value.entries()) {
+		const carrierPath = `${path}[${index}]`;
+		if (!isRecord(carrier)) {
+			issues.push({
+				path: carrierPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		if (carrier["type"] === "customXml") {
+			const wrapper = carrier["wrapper"];
+			if (!isRecord(wrapper)) {
+				issues.push({
+					path: `${carrierPath}.wrapper`,
+					message: "Expected an object."
+				});
+				continue;
+			}
+			requiredNumber(wrapper, "id", `${carrierPath}.wrapper.id`, issues);
+			requiredString(wrapper, "openingXml", `${carrierPath}.wrapper.openingXml`, issues);
+			requiredString(wrapper, "closingXml", `${carrierPath}.wrapper.closingXml`, issues);
+			continue;
+		}
+		if (carrier["type"] === "sdt") {
+			const properties = carrier["properties"];
+			if (!isRecord(properties)) {
+				issues.push({
+					path: `${carrierPath}.properties`,
+					message: "Expected an object."
+				});
+				continue;
+			}
+			requiredString(properties, "sdtType", `${carrierPath}.properties.sdtType`, issues);
+			continue;
+		}
+		issues.push({
+			path: `${carrierPath}.type`,
+			message: "Expected \"customXml\" or \"sdt\"."
+		});
+	}
+};
 /** A table sink entry may itself sit inside a row- or cell-level control. */
 const optionalTablePreservedMarkup = (attrs, key, path, issues) => {
 	optionalPreservedMarkup(attrs, key, path, issues);
@@ -1821,6 +1990,7 @@ const optionalPreservedMarkup = (attrs, key, path, issues) => {
 		}
 		requiredNumber(entry, "index", `${entryPath}.index`, issues);
 		requiredString(entry, "xml", `${entryPath}.xml`, issues);
+		optionalTableContentCarriers(entry, "carrierStack", `${entryPath}.carrierStack`, issues);
 		const xml = entry["xml"];
 		if (typeof xml === "string" && !isSafePreservedChildXml(xml)) issues.push({
 			path: `${entryPath}.xml`,
@@ -1855,6 +2025,7 @@ const optionalPositionedBookmarks = (attrs, path, issues) => {
 			continue;
 		}
 		validateNonNegativeSafeInteger(entry["index"], `${entryPath}.index`, issues);
+		optionalTableContentCarriers(entry, "carrierStack", `${entryPath}.carrierStack`, issues);
 		const marker = entry["marker"];
 		if (!isRecord(marker)) {
 			issues.push({
@@ -2839,4 +3010,4 @@ const optionalEmptyHyperlinkArray = (value, issues) => {
 	}
 };
 //#endregion
-export { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, isValidEmptyFieldResultRuns, isValidFieldCode, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };

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

@@ -32,7 +32,8 @@ declare function acceptChange(from: number, to: number): Command;
  */
 declare function rejectChange(from: number, to: number): Command;
 /**
- * Accept all tracked changes in the document.
+ * Accept all tracked changes in the document. Returns `false` while pending
+ * suggestions are present because this command cannot restage them.
  */
 declare function acceptAllChanges(): Command;
 /**
@@ -42,15 +43,11 @@ declare function rejectAllChanges(): Command;
 /**
  * Resolve a complete state synchronously for a headless reader or writer.
  *
- * @internal The replacement transaction is consumed here and never exposed:
- * it is deliberately not an editor command and must not be transported or
- * mapped through concurrent edits.
+ * Uses the same single-step resolver as the interactive editor command.
  */
 declare function resolveAllChangesInHeadlessState(state: EditorState, mode: ResolveMode): EditorState;
 /**
- * Resolve through the editor command path when a caller must map a position in
- * the reviewed document back to the tracked source. The bulk resolver is
- * faster, but deliberately replaces inline content without retaining mapping.
+ * Resolve a story and retain its position map for callers addressing the tracked source.
  */
 declare const resolveAllChangesInHeadlessStateWithMapping: (state: EditorState, mode: ResolveMode) => {
   state: EditorState;
@@ -109,6 +106,8 @@ type FolioSuggestion = {
  * accepting it applies (tracked vs direct).
  */
 declare function getSuggestions(state: EditorState): FolioSuggestion[];
+/** The suggestion a revision belongs to, or `null` for an ordinary tracked change. */
+declare function suggestionIdOfRevision(state: EditorState, revisionId: number): string | null;
 /**
  * The document range covering every mark belonging to `suggestionId`, plus the
  * revision ids those marks carry. Returns null when the suggestion is absent
@@ -184,4 +183,4 @@ declare function findNextChange(state: EditorState, startPos: number): ChangeRan
  */
 declare function findPreviousChange(state: EditorState, startPos: number): ChangeRange | null;
 //#endregion
-export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping };
+export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping, suggestionIdOfRevision };