@stll/folio-core 0.51.0 → 0.53.0

package/dist/docx/listNumberingInstances.js

@@ -0,0 +1,249 @@
+import { NUMBER_FORMATS } from "@stll/docx-core/model";
+//#region src/docx/listNumberingInstances.ts
+/**
+* Numbering instances the editor defines itself.
+*
+* A list command in a document with no list of the requested kind has nothing
+* to reference: the package may have no numbering part at all. The command
+* then defines one, an `w:abstractNum` built from {@link defaultListLevels}
+* plus the `w:num` naming it, as a word processor does when a list is
+* started in a document without lists.
+*
+* The definition lives in two places without being stored twice. While the
+* document is edited, the paragraphs that reference the instance carry the
+* rendering it resolved to (`listAbstractNumId`, `listNumFmt`,
+* `listMarkerTemplate`, `listStartOverride`, …), and those attrs travel with
+* the paragraph through undo, collaboration and every save path.
+* {@link completeListNumbering} turns them back into the definition wherever
+* the package's own numbering has no entry for the id. Because a minted
+* definition is the template plus level-0 facts that the rendering states, the
+* definition it rebuilds is the one the command minted.
+*/
+/** The two kinds of list a command can create. */
+const LIST_KINDS = ["bullet", "numbered"];
+const INDENT_STEP_TWIPS = 720;
+const HANGING_TWIPS = 360;
+const ROMAN_HANGING_TWIPS = 180;
+const LEVEL_COUNT = 9;
+const levelIndent = (ilvl, hanging) => ({
+	indentLeft: INDENT_STEP_TWIPS * (ilvl + 1),
+	indentFirstLine: -hanging,
+	hangingIndent: true
+});
+/** The customary numbered-list cycle: `1.`, `a.`, `i.`, then again one level deeper. */
+const NUMBERED_CYCLE = [
+	{
+		numFmt: "decimal",
+		lvlJc: "left",
+		hanging: HANGING_TWIPS
+	},
+	{
+		numFmt: "lowerLetter",
+		lvlJc: "left",
+		hanging: HANGING_TWIPS
+	},
+	{
+		numFmt: "lowerRoman",
+		lvlJc: "right",
+		hanging: ROMAN_HANGING_TWIPS
+	}
+];
+/** The customary bullet cycle: a round bullet, an open circle, a square. */
+const BULLET_CYCLE = [
+	{
+		text: "•",
+		font: null
+	},
+	{
+		text: "o",
+		font: "Courier New"
+	},
+	{
+		text: "▪",
+		font: null
+	}
+];
+const cycleEntry = (cycle, ilvl) => cycle.at(ilvl % cycle.length) ?? cycle[0];
+const numberedLevel = (ilvl) => {
+	const { numFmt, lvlJc, hanging } = cycleEntry(NUMBERED_CYCLE, ilvl);
+	return {
+		ilvl,
+		start: 1,
+		numFmt,
+		lvlText: `%${ilvl + 1}.`,
+		lvlJc,
+		pPr: levelIndent(ilvl, hanging)
+	};
+};
+const bulletLevel = (ilvl) => {
+	const { text, font } = cycleEntry(BULLET_CYCLE, ilvl);
+	return {
+		ilvl,
+		start: 1,
+		numFmt: "bullet",
+		lvlText: text,
+		lvlJc: "left",
+		pPr: levelIndent(ilvl, HANGING_TWIPS),
+		...font === null ? {} : { rPr: { fontFamily: {
+			ascii: font,
+			hAnsi: font
+		} } }
+	};
+};
+/** The nine levels a list of `kind` is minted with. */
+const defaultListLevels = (kind) => Array.from({ length: LEVEL_COUNT }, (_, ilvl) => kind === "bullet" ? bulletLevel(ilvl) : numberedLevel(ilvl));
+const mintAbstractNumbering = ({ abstractNumId, kind, format }) => {
+	const levels = defaultListLevels(kind);
+	const first = levels[0];
+	if (first && kind === "numbered" && format) levels[0] = {
+		...first,
+		numFmt: format.numFmt,
+		lvlText: format.lvlText
+	};
+	return {
+		abstractNumId,
+		multiLevelType: "hybridMultilevel",
+		levels
+	};
+};
+/** The template counts from one, so only another first value needs an override. */
+const levelZeroStart = (start) => start === void 0 || start === 1 ? void 0 : [{
+	ilvl: 0,
+	startOverride: start
+}];
+const EMPTY_DEFINITIONS = {
+	abstractNums: [],
+	nums: []
+};
+const nextId = (ids, floor) => {
+	let next = floor;
+	for (const id of ids) next = Math.max(next, id + 1);
+	return next;
+};
+/** A fresh `w:numId` for `definitions`; zero is reserved for "no numbering". */
+const nextNumId = (definitions) => nextId((definitions?.nums ?? []).map(({ numId }) => numId), 1);
+/** A fresh `w:abstractNumId` for `definitions`. */
+const nextAbstractNumId = (definitions) => nextId((definitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), 0);
+/**
+* Define a new list: a new `w:abstractNum` of the requested kind and the
+* `w:num` naming it. `definitions` must already hold every instance the
+* document references (see {@link completeListNumbering}), so the new ids
+* collide with none of them.
+*/
+const mintListInstance = (definitions, { kind, format, start }) => {
+	const current = definitions ?? EMPTY_DEFINITIONS;
+	const numId = nextNumId(current);
+	const abstractNumId = nextAbstractNumId(current);
+	const levelOverrides = levelZeroStart(start);
+	const instance = {
+		numId,
+		abstractNumId,
+		...levelOverrides ? { levelOverrides } : {}
+	};
+	return {
+		numId,
+		definitions: {
+			...current,
+			abstractNums: [...current.abstractNums, mintAbstractNumbering({
+				abstractNumId,
+				kind,
+				format
+			})],
+			nums: [...current.nums, instance]
+		}
+	};
+};
+/**
+* A new `w:num` over an existing `w:abstractNum`, with a `w:startOverride` at
+* `ilvl`: *Restart Numbering* and *Set Numbering Value*. The override is what
+* makes a consumer count the instance on its own rather than continue the
+* other instances of the same definition.
+*/
+const restartListInstance = (definitions, { abstractNumId, ilvl, start }) => {
+	const current = definitions ?? EMPTY_DEFINITIONS;
+	const numId = nextNumId(current);
+	const instance = {
+		numId,
+		abstractNumId,
+		levelOverrides: [{
+			ilvl,
+			startOverride: start
+		}]
+	};
+	return {
+		numId,
+		definitions: {
+			...current,
+			nums: [...current.nums, instance]
+		}
+	};
+};
+const NUMBER_FORMAT_SET = new Set(NUMBER_FORMATS);
+const isNumberFormat = (format) => format !== void 0 && NUMBER_FORMAT_SET.has(format);
+const levelZeroFormat = (references) => {
+	const first = references.find(({ ilvl }) => ilvl === 0)?.rendering;
+	const numFmt = first?.numFmt ?? references.find(({ rendering }) => rendering.levelNumFmts?.[0])?.rendering.levelNumFmts?.[0];
+	if (!isNumberFormat(numFmt)) return;
+	return {
+		numFmt,
+		lvlText: first?.markerTemplate ?? "%1."
+	};
+};
+const startOverridesOf = (references) => {
+	const byLevel = /* @__PURE__ */ new Map();
+	for (const { ilvl, rendering } of references) if (rendering.startOverride !== void 0 && !byLevel.has(ilvl)) byLevel.set(ilvl, rendering.startOverride);
+	return [...byLevel.entries()].toSorted(([left], [right]) => left - right).map(([ilvl, startOverride]) => ({
+		ilvl,
+		startOverride
+	}));
+};
+/**
+* Define every instance `references` name that `definitions` does not.
+*
+* A reference the editor resolved carries its rendering, and a rendering is
+* what a minted instance leaves behind; a reference without one (a dangling
+* id read from a file) has no rendering and so is never defined here. Returns
+* `definitions` itself when nothing is missing.
+*/
+const completeListNumbering = (definitions, references) => {
+	const definedNums = new Set((definitions?.nums ?? []).map(({ numId }) => numId));
+	const missing = /* @__PURE__ */ new Map();
+	for (const reference of references) {
+		if (definedNums.has(reference.numId)) continue;
+		const group = missing.get(reference.numId);
+		if (group) group.push(reference);
+		else missing.set(reference.numId, [reference]);
+	}
+	if (missing.size === 0) return definitions;
+	const current = definitions ?? EMPTY_DEFINITIONS;
+	const abstractIds = new Set(current.abstractNums.map(({ abstractNumId }) => abstractNumId));
+	const statedAbstractIds = [...missing.values()].flatMap((group) => group.flatMap(({ rendering }) => rendering.abstractNumId === void 0 ? [] : [rendering.abstractNumId]));
+	let freeAbstractId = nextId([...abstractIds, ...statedAbstractIds], 0);
+	const abstractNums = [];
+	const nums = [];
+	for (const [numId, group] of missing) {
+		const abstractNumId = group.find(({ rendering }) => rendering.abstractNumId !== void 0)?.rendering.abstractNumId ?? freeAbstractId++;
+		if (!abstractIds.has(abstractNumId)) {
+			abstractIds.add(abstractNumId);
+			const kind = group.some(({ rendering }) => rendering.isBullet) ? "bullet" : "numbered";
+			abstractNums.push(mintAbstractNumbering({
+				abstractNumId,
+				kind,
+				format: levelZeroFormat(group)
+			}));
+		}
+		const levelOverrides = startOverridesOf(group);
+		nums.push({
+			numId,
+			abstractNumId,
+			...levelOverrides.length > 0 ? { levelOverrides } : {}
+		});
+	}
+	return {
+		...current,
+		abstractNums: [...current.abstractNums, ...abstractNums],
+		nums: [...current.nums, ...nums]
+	};
+};
+//#endregion
+export { LIST_KINDS, completeListNumbering, mintListInstance, restartListInstance };

package/dist/docx/normalizeBaseDirection.js

@@ -52,7 +52,8 @@ const normalizeCellBlock = (block, styles) => {
 	switch (block.type) {
 		case "paragraph": return normalizeParagraph(block, styles);
 		case "table": return normalizeTable(block, styles);
-		case "blockSdt": return {
+		case "blockSdt":
+		case "blockCustomXml": return {
 			...block,
 			content: block.content.map((child) => normalizeCellBlock(child, styles))
 		};

package/dist/docx/opaqueCarrier.d.ts

@@ -0,0 +1,7 @@
+//#region src/docx/opaqueCarrier.d.ts
+declare const OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC = "[Unsupported block-level tracked-change content]";
+declare const opaqueRevisionCarrierName: (xml: string) => string | undefined;
+declare const countOpaqueRevisionWrappers: (xml: string) => number;
+declare const isOpaqueNestedRowMarkup: (xml: string) => boolean;
+//#endregion
+export { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, countOpaqueRevisionWrappers, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName };

package/dist/docx/opaqueCarrier.js

@@ -0,0 +1,38 @@
+import { OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, getChildElements, getLocalName, parseXml } from "./xmlParser.js";
+//#region src/docx/opaqueCarrier.ts
+const OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC = "[Unsupported block-level tracked-change content]";
+const REVISION_WRAPPERS = /* @__PURE__ */ new Set([
+	"ins",
+	"del",
+	"moveFrom",
+	"moveTo"
+]);
+const opaqueRevisionCarrierName = (xml) => {
+	const visit = (element) => {
+		const localName = getLocalName(element.name);
+		if (WORDPROCESSINGML_NAMESPACE_URIS.has(element.namespaceUri ?? "") && REVISION_WRAPPERS.has(localName)) return `w:${localName}`;
+		for (const child of getChildElements(element)) {
+			const match = visit(child);
+			if (match !== void 0) return match;
+		}
+	};
+	for (const root of getChildElements(parseXml(xml, OOXML_NAMESPACE_SCOPE))) {
+		const match = visit(root);
+		if (match !== void 0) return match;
+	}
+};
+const countOpaqueRevisionWrappers = (xml) => {
+	const count = (element) => {
+		const localName = getLocalName(element.name);
+		let total = WORDPROCESSINGML_NAMESPACE_URIS.has(element.namespaceUri ?? "") && REVISION_WRAPPERS.has(localName) ? 1 : 0;
+		for (const child of getChildElements(element)) total += count(child);
+		return total;
+	};
+	return getChildElements(parseXml(xml, OOXML_NAMESPACE_SCOPE)).reduce((total, element) => total + count(element), 0);
+};
+const isOpaqueNestedRowMarkup = (xml) => {
+	const element = getChildElements(parseXml(xml, OOXML_NAMESPACE_SCOPE)).at(0);
+	return element !== void 0 && getLocalName(element.name) === "tr" && WORDPROCESSINGML_NAMESPACE_URIS.has(element.namespaceUri ?? "");
+};
+//#endregion
+export { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, countOpaqueRevisionWrappers, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName };

package/dist/docx/packageParts.js

@@ -58,7 +58,10 @@ const isPresent = (present, partPath) => present.has(normalizePartPath(partPath)
 const relationshipTarget = (element, relsPath) => {
 	if (TARGET_MODE_ATTRIBUTE.exec(element)?.groups?.["value"] === "External") return null;
 	const target = TARGET_ATTRIBUTE.exec(element)?.groups?.["value"];
-	return target === void 0 ? null : resolveRelativePath(relsPath, target);
+	if (target === void 0) return null;
+	const fragment = target.indexOf("#");
+	if (fragment === 0) return owningPartPath(relsPath) ?? "";
+	return resolveRelativePath(relsPath, fragment > 0 ? target.slice(0, fragment) : target);
 };
 /**
 * Every `.rels` part with its text. Read one at a time rather than through

package/dist/docx/paragraphParser.js

@@ -578,8 +578,8 @@ const hasRunPayload = ({ run, runElement, rels, media }) => {
 * the assembled field, and one that reaches the editor's inline converter on
 * its own is dropped. So a `w:fldChar` whose field this paragraph never closed,
 * or one with no `begin` before it, loses the editor round trip — and the
-* model holds nothing of its `w:ffData` either, so the save loses a legacy form
-* field's name, macros, help text and checkbox state as well.
+* orphan field has no owning `ComplexField` to hold its `w:ffData`, so dropping
+* this run would also lose its name, macros, help text and checkbox state.
 *
 * `preservedXml` is the run's own capture member: the editor carries it as an
 * opaque atom and the serializer replays the source bytes, `w:ffData` included.
@@ -610,9 +610,11 @@ const LEGACY_FORM_CHECKBOX_GLYPHS = {
 	unchecked: "☐"
 };
 const LEGACY_FORM_CHECKBOX_INSTRUCTION = "FORMCHECKBOX";
-function getLegacyFormCheckboxDisplay(runElement) {
-	const fieldChar = findChild(runElement, "w", "fldChar");
-	const fieldData = fieldChar ? findChild(fieldChar, "w", "ffData") : null;
+const beginFieldCharOf = (runElement) => findChildrenByNamespaceUri(runElement, WORDPROCESSINGML_NAMESPACE_URIS, "fldChar").find((fieldChar) => {
+	const charType = getAttribute(fieldChar, "w", "fldCharType");
+	return charType !== "separate" && charType !== "end";
+});
+function getLegacyFormCheckboxDisplay(fieldData) {
 	const checkBox = fieldData ? findChild(fieldData, "w", "checkBox") : null;
 	if (!checkBox) return;
 	const checked = findChild(checkBox, "w", "checked");
@@ -676,6 +678,30 @@ const FIELD_INLINE_WRAPPER_HANDLERS = {
 	pPr: CAPTURE
 };
 /**
+* Whether the walk is currently inside some open field's code region — its
+* own `begin` has been read but not yet its `separate` — at any nesting
+* depth. `codeDepthStack` tracks every open field regardless of whether it
+* assembles into a `ComplexField`, so this answers the question for content,
+* such as a `w:fldSimple`, that a `ComplexField`'s own code/result split
+* cannot carry.
+*/
+const isHiddenByOpenFieldCode = (scan) => scan.codeDepthStack.some((pastSeparator) => !pastSeparator);
+/**
+* A run captured for a position this field's `fieldResult` (or `fieldCode`)
+* must hold — the source ordering a save has to reproduce puts it there —
+* whose actual content sits inside a deeper, still-open field's own
+* instruction region and so must show nothing. Every non-`w:rPr` child is
+* captured through `preserveRunChild`, the same verbatim-with-no-text capture
+* an unrecognised run child already gets, rather than kept as the `text`/
+* `instrText` the parse produced — a `w:t` this walk read as authored result
+* text is exactly what must not read back out of `fieldResult`.
+*/
+const hiddenRunCaptureOf = (runElement, formatting) => ({
+	type: "run",
+	content: getChildElements(runElement).filter((child) => getLocalName(child.name) !== "rPr").map((child) => preserveRunChild(child)),
+	...formatting && Object.keys(formatting).length > 0 ? { formatting } : {}
+});
+/**
 * The container children a complex field's result may hold and still be
 * assembled into a `ComplexField`: its runs and the zero-width markers read
 * beside them. Any other child is inline content (a hyperlink, a simple field,
@@ -713,25 +739,31 @@ const isWordprocessingChild = (child) => {
 };
 /**
 * The `w:r` children whose `begin` opens a complex field that this container's
-* walk closes.
+* walk closes as its own top-level `ComplexField`.
 *
 * A field is assembled from the runs between its `begin` and its `end`, so it
 * exists only when both are runs of this container with nothing between them
 * that a `ComplexField` cannot hold. A TOC opened here and closed in a later
-* paragraph, a field whose result holds a `w:hyperlink` (a TOC's `\h` entries),
-* and an outer field whose result holds a nested field are none of these; their
-* runs are ordinary content, read in source order alongside the siblings
-* between them. Mirrors the `w:r` handler run by run: a run with a `begin`
-* opens a field, and a run with an `end` closes the one open.
+* paragraph, and a field whose result holds a `w:hyperlink` (a TOC's `\h`
+* entries), are neither of those; their runs are ordinary content, read in
+* source order alongside the siblings between them.
+*
+* A `begin`/`end` pair that closes while another `begin` is still open is
+* nested inside that other field's code or result — its own runs stay with
+* the outer field's, carried in `fieldCode`/`fieldResult` rather than
+* assembled into a `ComplexField` of their own, which is why only the
+* outermost pair of a nested run adds its `begin` here. Tracked with a stack
+* rather than one slot so a field nested inside a field nested inside a field
+* closes each level against the right opener instead of the most recent one.
 */
 const assembledFieldBeginsOf = (container) => {
 	const assembled = /* @__PURE__ */ new Set();
-	let open;
+	const open = [];
 	for (const child of getChildElements(container)) {
 		const wordprocessing = isWordprocessingChild(child);
 		const localName = getLocalName(child.name);
 		if (!wordprocessing || localName !== "r") {
-			if (!wordprocessing || !FIELD_TRANSPARENT_CHILDREN.has(localName)) open = void 0;
+			if (!wordprocessing || !FIELD_TRANSPARENT_CHILDREN.has(localName)) open.length = 0;
 			continue;
 		}
 		let hasBegin = false;
@@ -742,10 +774,10 @@ const assembledFieldBeginsOf = (container) => {
 			if (charType === "end") hasEnd = true;
 			else if (charType !== "separate") hasBegin = true;
 		}
-		if (hasBegin) open = child;
-		if (hasEnd && open !== void 0) {
-			assembled.add(open);
-			open = void 0;
+		if (hasBegin) open.push(child);
+		if (hasEnd && open.length > 0) {
+			const closed = open.pop();
+			if (closed !== void 0 && open.length === 0) assembled.add(closed);
 		}
 	}
 	return assembled;
@@ -774,7 +806,8 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 		const commentReferenceId = getCommentReferenceId(runElement);
 		let hasFieldBegin = false;
 		let beginFieldState = {};
-		const beginFallbackDisplay = getLegacyFormCheckboxDisplay(runElement);
+		const beginFieldData = findWordprocessingChild(beginFieldCharOf(runElement), "ffData");
+		const beginFallbackDisplay = getLegacyFormCheckboxDisplay(beginFieldData);
 		let hasFieldSeparate = false;
 		let hasFieldEnd = false;
 		let endOriginalValue;
@@ -788,6 +821,8 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 			if (content.originalValue !== void 0) endOriginalValue = content.originalValue;
 		}
 		else if (content.type === "instrText") instrText += content.text;
+		if (hasFieldBegin) scan.codeDepthStack.push(false);
+		if (hasFieldSeparate && scan.codeDepthStack.length > 0) scan.codeDepthStack[scan.codeDepthStack.length - 1] = true;
 		if (hasFieldBegin) {
 			scan.assembledFieldBegins ??= assembledFieldBeginsOf(scan.container);
 			if (!scan.assembledFieldBegins.has(child)) hasFieldBegin = false;
@@ -804,9 +839,13 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 			scan.complexFieldResultRuns = [];
 			scan.complexFieldOpenRuns = [];
 			scan.complexFieldState = beginFieldState;
+			scan.complexFieldDataXml = beginFieldData ? captureVerbatimXml(beginFieldData) : void 0;
 			scan.complexFieldFallbackDisplay = beginFallbackDisplay;
 			scan.complexFieldFormatting = run.formatting;
+			scan.complexFieldBaseDepth = scan.codeDepthStack.length;
 		}
+		const isNestedField = scan.codeDepthStack.length > scan.complexFieldBaseDepth;
+		if (hasFieldEnd && scan.codeDepthStack.length > 0) scan.codeDepthStack.pop();
 		if (scan.inComplexField) {
 			scan.complexFieldOpenRuns.push(withOrphanFieldCharsPreserved(run, runElement));
 			if (instrText) scan.complexFieldInstr += instrText;
@@ -815,6 +854,10 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 			const fieldCodeContent = [];
 			for (const content of run.content) {
 				if (content.type === "fieldChar") {
+					if (isNestedField) {
+						if (inFieldCodeRegion) fieldCodeContent.push(content);
+						continue;
+					}
 					inFieldCodeRegion = content.charType === "begin";
 					continue;
 				}
@@ -824,11 +867,11 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 				...run,
 				content: fieldCodeContent
 			});
-			if (hasFieldSeparate) scan.afterSeparator = true;
+			if (hasFieldSeparate && !isNestedField) scan.afterSeparator = true;
 			if (scan.afterSeparator && !hasFieldEnd) {
-				if (!hasFieldSeparate) scan.complexFieldResultRuns.push(run);
+				if (!hasFieldSeparate) scan.complexFieldResultRuns.push(isHiddenByOpenFieldCode(scan) ? hiddenRunCaptureOf(runElement, run.formatting) : run);
 			}
-			if (hasFieldEnd) {
+			if (hasFieldEnd && !isNestedField) {
 				let resultRuns = scan.complexFieldResultRuns;
 				let resultIsFallback = false;
 				if (resultRuns.length === 0 && scan.complexFieldFallbackDisplay !== void 0 && isLegacyFormCheckboxInstruction(scan.complexFieldInstr)) {
@@ -850,6 +893,7 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 					fieldResult: resultRuns,
 					...scan.complexFieldState
 				};
+				if (scan.complexFieldDataXml !== void 0) complexField.formFieldDataXml = scan.complexFieldDataXml;
 				if (resultIsFallback) complexField.fieldResultIsFallback = true;
 				if (scan.complexFieldFormatting) complexField.formatting = scan.complexFieldFormatting;
 				contents.push(complexField);
@@ -865,6 +909,17 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 				type: "commentReference",
 				id: commentReferenceId
 			});
+		} else if (isHiddenByOpenFieldCode(scan)) {
+			if (hasRunPayload({
+				run,
+				runElement,
+				rels,
+				media
+			})) contents.push({
+				type: "preservedInline",
+				xml: captureVerbatimXml(runElement),
+				text: ""
+			});
 		} else if (hasRunPayload({
 			run,
 			runElement,
@@ -881,8 +936,17 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 	bookmarkEnd: (child, { contents }) => {
 		contents.push(parseBookmarkEnd(child));
 	},
-	fldSimple: (child, { contents, styles, theme, rels, media, previews, inScopeXmlns }) => {
-		contents.push(parseSimpleField(child, styles, theme, rels, media, inScopeXmlns, previews));
+	fldSimple: (child, { contents, styles, theme, rels, media, previews, inScopeXmlns, trackedContext, scan }) => {
+		const fieldElement = trackedContext === "deletion" ? normalizeDeletionContentElement(child) : child;
+		if (isHiddenByOpenFieldCode(scan)) {
+			contents.push({
+				type: "preservedInline",
+				xml: captureVerbatimXml(fieldElement),
+				text: ""
+			});
+			return;
+		}
+		contents.push(parseSimpleField(fieldElement, styles, theme, rels, media, inScopeXmlns, previews));
 	},
 	pPr: PARAGRAPH_PROPERTIES_OWNER,
 	customXml: paragraphInlineWrapper("customXml"),
@@ -1005,10 +1069,13 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 		complexFieldOpenRuns: [],
 		afterSeparator: false,
 		complexFieldState: {},
+		complexFieldDataXml: void 0,
 		complexFieldFallbackDisplay: void 0,
 		complexFieldFormatting: void 0,
 		container: paraElement,
-		assembledFieldBegins: void 0
+		assembledFieldBegins: void 0,
+		codeDepthStack: [],
+		complexFieldBaseDepth: 0
 	};
 	const preserved = dispatchChildrenWithContext({
 		element: paraElement,

package/dist/docx/paragraphPropertySource.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { ModeledParagraphFormattingEmission } from "../internal/paragraphFormattingSerialization.js";
-import { Transaction } from "prosemirror-state";
 import { Fragment, Mark, Node, NodeType } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/docx/paragraphPropertySource.d.ts
 declare const paragraphPropertySourceEmissionFingerprint: unique symbol;
 type ParagraphPropertySource = Readonly<{
@@ -97,6 +97,8 @@ type JoinProseParagraphsWithRightPropertySourceOptions = {
 };
 /** Join adjacent paragraphs when revision semantics deliberately select the right owner. */
 declare const joinProseParagraphsWithRightPropertySource: ({ attrs, pos, transaction }: JoinProseParagraphsWithRightPropertySourceOptions) => Transaction;
+/** Record the property owners deliberately selected by a batch of paragraph joins. */
+declare const markParagraphPropertySourceTransfers: (transaction: Transaction, transfers: readonly ParagraphPropertySourceTransfer[]) => void;
 declare const getExplicitParagraphPropertySourceTransfers: (transaction: Transaction) => readonly ParagraphPropertySourceTransfer[];
 type RecreateProseNodeOptions = {
   attrs?: Node["attrs"];
@@ -134,4 +136,4 @@ declare const linkParagraphPropertySourceCandidate: (target: document_d_exports.
 declare const getParagraphPropertySourceCandidate: (paragraph: document_d_exports.Paragraph) => document_d_exports.Paragraph | undefined;
 declare const getParagraphPropertySourceTransferId: (paragraph: document_d_exports.Paragraph) => string | undefined;
 //#endregion
-export { DecodedTableCellParagraphSourcePayload, PARAGRAPH_PROPERTY_SOURCE_VALIDATION_CODES, PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR, ParagraphPropertySourceValidationCode, ParagraphPropertySourceValidationError, TABLE_CELL_PARAGRAPH_SOURCE_BINDING_ATTR, TABLE_CELL_PARAGRAPH_SOURCE_PAYLOAD_ERROR_CLASSIFICATIONS, TableCellParagraphPropertySourceBinding, TableCellParagraphSourcePayloadErrorClassification, assignDocumentParagraphPropertySourceContract, assignParagraphPropertySource, cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, cloneParagraphWithoutPropertySource, cloneTableCellsWithParagraphPropertyCaptures, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, createProseParagraphWithPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getExplicitParagraphPropertySourceTransfers, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, isParagraphPropertySourceToken, joinProseParagraphsWithRightPropertySource, linkParagraphPropertySourceCandidate, linkProseParagraphPropertySource, paragraphPropertySourceBelongsToDocument, paragraphPropertySourceMatchesEmission, paragraphPropertySourceTokenMatchesContract, proseParagraphAttrsWithoutPropertySource, recreateProseNodeWithDetachedParagraphPropertySource, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource, transportTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings };
+export { DecodedTableCellParagraphSourcePayload, PARAGRAPH_PROPERTY_SOURCE_VALIDATION_CODES, PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR, ParagraphPropertySourceValidationCode, ParagraphPropertySourceValidationError, TABLE_CELL_PARAGRAPH_SOURCE_BINDING_ATTR, TABLE_CELL_PARAGRAPH_SOURCE_PAYLOAD_ERROR_CLASSIFICATIONS, TableCellParagraphPropertySourceBinding, TableCellParagraphSourcePayloadErrorClassification, assignDocumentParagraphPropertySourceContract, assignParagraphPropertySource, cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, cloneParagraphWithoutPropertySource, cloneTableCellsWithParagraphPropertyCaptures, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, createProseParagraphWithPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getExplicitParagraphPropertySourceTransfers, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, isParagraphPropertySourceToken, joinProseParagraphsWithRightPropertySource, linkParagraphPropertySourceCandidate, linkProseParagraphPropertySource, markParagraphPropertySourceTransfers, paragraphPropertySourceBelongsToDocument, paragraphPropertySourceMatchesEmission, paragraphPropertySourceTokenMatchesContract, proseParagraphAttrsWithoutPropertySource, recreateProseNodeWithDetachedParagraphPropertySource, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource, transportTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings };

package/dist/docx/paragraphPropertySource.js

@@ -261,6 +261,7 @@ const invalidTableCellParagraphSourcePayload = (classification, path) => {
 };
 const tableCellBlockTraversalByType = {
 	blockSdt: "blockSdt",
+	blockCustomXml: "blockSdt",
 	bookmarkEnd: "leaf",
 	bookmarkStart: "leaf",
 	paragraph: "paragraph",
@@ -634,6 +635,11 @@ const joinProseParagraphsWithRightPropertySource = ({ attrs, pos, transaction })
 	}]);
 	return transaction;
 };
+/** Record the property owners deliberately selected by a batch of paragraph joins. */
+const markParagraphPropertySourceTransfers = (transaction, transfers) => {
+	if (transfers.length === 0) return;
+	transaction.setMeta(paragraphPropertySourceTransfersKey, [...transaction.getMeta(paragraphPropertySourceTransfersKey) ?? [], ...transfers]);
+};
 const getExplicitParagraphPropertySourceTransfers = (transaction) => transaction.getMeta(paragraphPropertySourceTransfersKey) ?? [];
 /** Carry a parser-linked paragraph owner across an immutable PM node rebuild. */
 const copyProseParagraphPropertySource = (target, source) => {
@@ -703,4 +709,4 @@ const linkParagraphPropertySourceCandidate = (target, source) => {
 const getParagraphPropertySourceCandidate = (paragraph) => paragraphPropertySourceCandidates.get(paragraph);
 const getParagraphPropertySourceTransferId = (paragraph) => paragraphPropertySourceTransferIds.get(paragraph);
 //#endregion
-export { PARAGRAPH_PROPERTY_SOURCE_VALIDATION_CODES, PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR, ParagraphPropertySourceValidationError, TABLE_CELL_PARAGRAPH_SOURCE_BINDING_ATTR, TABLE_CELL_PARAGRAPH_SOURCE_PAYLOAD_ERROR_CLASSIFICATIONS, assignDocumentParagraphPropertySourceContract, assignParagraphPropertySource, cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, cloneParagraphWithoutPropertySource, cloneTableCellsWithParagraphPropertyCaptures, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, createProseParagraphWithPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getExplicitParagraphPropertySourceTransfers, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, isParagraphPropertySourceToken, joinProseParagraphsWithRightPropertySource, linkParagraphPropertySourceCandidate, linkProseParagraphPropertySource, paragraphPropertySourceBelongsToDocument, paragraphPropertySourceMatchesEmission, paragraphPropertySourceTokenMatchesContract, proseParagraphAttrsWithoutPropertySource, recreateProseNodeWithDetachedParagraphPropertySource, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource, transportTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings };
+export { PARAGRAPH_PROPERTY_SOURCE_VALIDATION_CODES, PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR, ParagraphPropertySourceValidationError, TABLE_CELL_PARAGRAPH_SOURCE_BINDING_ATTR, TABLE_CELL_PARAGRAPH_SOURCE_PAYLOAD_ERROR_CLASSIFICATIONS, assignDocumentParagraphPropertySourceContract, assignParagraphPropertySource, cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, cloneParagraphWithoutPropertySource, cloneTableCellsWithParagraphPropertyCaptures, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, createProseParagraphWithPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getExplicitParagraphPropertySourceTransfers, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, isParagraphPropertySourceToken, joinProseParagraphsWithRightPropertySource, linkParagraphPropertySourceCandidate, linkProseParagraphPropertySource, markParagraphPropertySourceTransfers, paragraphPropertySourceBelongsToDocument, paragraphPropertySourceMatchesEmission, paragraphPropertySourceTokenMatchesContract, proseParagraphAttrsWithoutPropertySource, recreateProseNodeWithDetachedParagraphPropertySource, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource, transportTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings };

package/dist/docx/paragraphTraversal.js

@@ -126,6 +126,7 @@ const visitBlockTreeRecords = (blocks, visit) => {
 				}
 				break;
 			case "blockSdt":
+			case "blockCustomXml":
 				visitBlocks(block.content);
 				break;
 			case "preservedBlock":

package/dist/docx/parseWarningMessage.js

@@ -40,7 +40,10 @@ const PARSE_WARNING_MESSAGES = {
 	[PARSE_WARNING_CODES.outlineDashOutsideEnum]: (warning) => `Kept outline dash${quoted(warning.value)} verbatim${where(warning)}; ST_PresetLineDashVal does not declare it.`,
 	[PARSE_WARNING_CODES.styleSetDuplicateStyleId]: (warning) => `Dropped a style repeating the id${quoted(warning.value)} another style in the set already defines.`,
 	[PARSE_WARNING_CODES.styleSetInitialStyleMissing]: (warning) => `The style set names initial paragraph style${quoted(warning.value)}, which it does not contain; used the set's default instead${where(warning)}.`,
-	[PARSE_WARNING_CODES.pageBreakProjectionApproximated]: (warning) => `${warning.detail ?? "An explicit page break is laid out approximately"}${where(warning)}.`
+	[PARSE_WARNING_CODES.pageBreakProjectionApproximated]: (warning) => `${warning.detail ?? "An explicit page break is laid out approximately"}${where(warning)}.`,
+	[PARSE_WARNING_CODES.altChunkUnsupported]: (warning) => `Preserved ${plural(warning.count, "w:altChunk")}; Folio cannot import its external content. Readers show a diagnostic marker.`,
+	[PARSE_WARNING_CODES.revisionCarrierOpaque]: (warning) => `Preserved ${plural(warning.count, "block-level tracked-change wrapper")}; Folio cannot interpret its block content, so that content is unavailable to readers or edits.`,
+	[PARSE_WARNING_CODES.nestedRowOpaque]: (warning) => `Preserved ${plural(warning.count, "nested table row")} as opaque markup; readers show a diagnostic marker for its content.`
 };
 const formatParseWarning = (warning) => PARSE_WARNING_MESSAGES[warning.code](warning);
 const formatParseWarnings = (warnings) => warnings.map(formatParseWarning);