@stll/folio-core 0.48.0 → 0.49.0

package/dist/docx/paragraphParser.js

@@ -676,6 +676,81 @@ const FIELD_INLINE_WRAPPER_HANDLERS = {
 	pPr: CAPTURE
 };
 /**
+* 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,
+* a content control, a revision, a wrapper, an equation) that `fieldResult`
+* has no place for.
+*/
+const FIELD_TRANSPARENT_CHILDREN = /* @__PURE__ */ new Set([
+	"r",
+	"pPr",
+	"smartTagPr",
+	"customXmlPr",
+	"bookmarkStart",
+	"bookmarkEnd",
+	"commentRangeStart",
+	"commentRangeEnd",
+	"moveFromRangeStart",
+	"moveFromRangeEnd",
+	"moveToRangeStart",
+	"moveToRangeEnd",
+	"proofErr",
+	"permStart",
+	"permEnd",
+	"customXmlDelRangeStart",
+	"customXmlDelRangeEnd",
+	"customXmlInsRangeStart",
+	"customXmlInsRangeEnd",
+	"customXmlMoveFromRangeStart",
+	"customXmlMoveFromRangeEnd",
+	"customXmlMoveToRangeStart",
+	"customXmlMoveToRangeEnd"
+]);
+const isWordprocessingChild = (child) => {
+	const namespace = getNamespaceUri(child);
+	return namespace === void 0 || WORDPROCESSINGML_NAMESPACE_URIS.has(namespace);
+};
+/**
+* The `w:r` children whose `begin` opens a complex field that this container's
+* walk closes.
+*
+* 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.
+*/
+const assembledFieldBeginsOf = (container) => {
+	const assembled = /* @__PURE__ */ new Set();
+	let 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;
+			continue;
+		}
+		let hasBegin = false;
+		let hasEnd = false;
+		for (const runChild of getChildElements(child)) {
+			if (getLocalName(runChild.name) !== "fldChar" || !isWordprocessingChild(runChild)) continue;
+			const charType = getAttribute(runChild, "w", "fldCharType");
+			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;
+		}
+	}
+	return assembled;
+};
+/**
 * A transparent wrapper at paragraph level. All four hold ordinary inline
 * content and say something about it rather than about the text, so the
 * recursion is this same walk and `inlineWrapperOf` reads what the element
@@ -714,8 +789,12 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 		}
 		else if (content.type === "instrText") instrText += content.text;
 		if (hasFieldBegin) {
-			if (scan.inComplexField && scan.afterSeparator) {
-				contents.push(...scan.complexFieldResultRuns);
+			scan.assembledFieldBegins ??= assembledFieldBeginsOf(scan.container);
+			if (!scan.assembledFieldBegins.has(child)) hasFieldBegin = false;
+		}
+		if (hasFieldBegin) {
+			if (scan.inComplexField) {
+				contents.push(...scan.complexFieldOpenRuns);
 				scan.inComplexField = false;
 			}
 			scan.inComplexField = true;
@@ -751,7 +830,11 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 			}
 			if (hasFieldEnd) {
 				let resultRuns = scan.complexFieldResultRuns;
-				if (resultRuns.length === 0 && scan.complexFieldFallbackDisplay !== void 0 && isLegacyFormCheckboxInstruction(scan.complexFieldInstr)) resultRuns = [createLegacyFormCheckboxResultRun(scan.complexFieldFallbackDisplay, scan.complexFieldFormatting)];
+				let resultIsFallback = false;
+				if (resultRuns.length === 0 && scan.complexFieldFallbackDisplay !== void 0 && isLegacyFormCheckboxInstruction(scan.complexFieldInstr)) {
+					resultRuns = [createLegacyFormCheckboxResultRun(scan.complexFieldFallbackDisplay, scan.complexFieldFormatting)];
+					resultIsFallback = true;
+				}
 				if (resultRuns.length === 0 && !scan.afterSeparator && endOriginalValue !== void 0) resultRuns = [{
 					type: "run",
 					content: [{
@@ -767,6 +850,7 @@ const PARAGRAPH_CONTENT_HANDLERS = {
 					fieldResult: resultRuns,
 					...scan.complexFieldState
 				};
+				if (resultIsFallback) complexField.fieldResultIsFallback = true;
 				if (scan.complexFieldFormatting) complexField.formatting = scan.complexFieldFormatting;
 				contents.push(complexField);
 				if (commentReferenceId !== null) contents.push({
@@ -922,7 +1006,9 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 		afterSeparator: false,
 		complexFieldState: {},
 		complexFieldFallbackDisplay: void 0,
-		complexFieldFormatting: void 0
+		complexFieldFormatting: void 0,
+		container: paraElement,
+		assembledFieldBegins: void 0
 	};
 	const preserved = dispatchChildrenWithContext({
 		element: paraElement,
@@ -1096,9 +1182,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 					if (!paragraph.formatting) paragraph.formatting = {};
 					const directInd = pPr ? findChild(pPr, "w", "ind") : null;
 					const hasDirectLeft = hasAttributeAnySpelling(directInd, "CT_Ind @left");
-					const directFirstLine = directInd ? parseNumericAttribute(directInd, "w", "firstLine") : void 0;
-					const directHanging = directInd ? parseNumericAttribute(directInd, "w", "hanging") : void 0;
-					const hasDirectFirstLineOrHanging = directFirstLine !== void 0 && directFirstLine !== 0 || directHanging !== void 0 && directHanging !== 0;
+					const hasDirectFirstLineOrHanging = parseNumericAttribute(directInd, "w", "firstLine") !== void 0 || parseNumericAttribute(directInd, "w", "hanging") !== void 0;
 					if (!hasDirectLeft && !chainInd.left && level.pPr.indentLeft !== void 0) paragraph.formatting.indentLeft = level.pPr.indentLeft;
 					if (!hasDirectFirstLineOrHanging && !chainInd.firstLine && numberingLevelHasMarkerSlot(level)) {
 						if (level.pPr.indentFirstLine !== void 0) paragraph.formatting.indentFirstLine = level.pPr.indentFirstLine;

package/dist/docx/paragraphTextBoxEnrichment.js

@@ -1,9 +1,12 @@
 import { pixelsToEmu } from "../utils/units.js";
+import { groupTextContentFingerprint, groupXmlFingerprint } from "./drawingGroupChildren.js";
+import { groupPreviewTextBoxes } from "./groupDrawingParser.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { consolidateParagraphContent } from "./runConsolidator.js";
-import { getTextBoxContentElement, parseTextBox, parseTextBoxContent, scanRunForTextBoxDrawings } from "./textBoxParser.js";
+import { captureShapeAlternateContent } from "./shapeAlternateContent.js";
+import { getTextBoxContentElement, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, scanRunForTextBoxDrawings } from "./textBoxParser.js";
 import { isVmlPictParsedByRunParser } from "./vmlImageParser.js";
-import { findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
+import { findChildByLocalName, findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
 //#region src/docx/paragraphTextBoxEnrichment.ts
 const VML_HORIZONTAL_RELATIVES = /* @__PURE__ */ new Set([
 	"character",
@@ -134,8 +137,120 @@ const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering,
 		previews,
 		context
 	});
+	liftGroupTextBoxes(paragraph.content, {
+		styles,
+		theme,
+		numbering,
+		rels,
+		media,
+		parseTable,
+		previews
+	});
 	paragraph.content = consolidateParagraphContent(paragraph.content);
 };
+/** Previews whose text boxes were already lifted, so a second pass adds none. */
+const liftedGroupPreviews = /* @__PURE__ */ new WeakSet();
+/**
+* Lift the text boxes out of every group preview in the paragraph, each into
+* a text box shape right after the group's drawing in the same run.
+*
+* The group keeps drawing its other children; a lifted text box is laid out
+* and painted like any anchored text box, placed at the group's offset plus
+* the child's frame, and it records where in the group it came from so the
+* writer can put its text back there.
+*/
+const liftGroupTextBoxes = (content, parsers) => {
+	for (const item of content) switch (item.type) {
+		case "run":
+			liftGroupTextBoxesInRun(item, parsers);
+			break;
+		case "hyperlink":
+			liftGroupTextBoxes(item.children, parsers);
+			break;
+		case "inlineSdt":
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo":
+			liftGroupTextBoxes(item.content, parsers);
+			break;
+		default: break;
+	}
+};
+const liftGroupTextBoxesInRun = (run, parsers) => {
+	if (!run.content.some((item) => item.type === "drawing")) return;
+	const lifted = [];
+	for (const item of run.content) {
+		lifted.push(item);
+		if (item.type !== "drawing" || item.rawXml === void 0) continue;
+		const frames = groupPreviewTextBoxes(item.image);
+		if (!frames || liftedGroupPreviews.has(item.image)) continue;
+		liftedGroupPreviews.add(item.image);
+		const group = groupXmlFingerprint(item.rawXml);
+		for (const frame of frames) {
+			const shape = groupTextBoxShape(item.image, frame, group, parsers);
+			if (shape) lifted.push({
+				type: "shape",
+				shape
+			});
+		}
+	}
+	run.content = lifted;
+};
+const groupTextBoxShape = (groupImage, frame, group, { styles, theme, numbering, rels, media, parseTable, previews }) => {
+	const position = groupImage.position;
+	const horizontalOffset = position?.horizontal.posOffset;
+	const verticalOffset = position?.vertical.posOffset;
+	if (!position || horizontalOffset === void 0 || verticalOffset === void 0) return;
+	const size = {
+		width: Math.round(frame.width),
+		height: Math.round(frame.height)
+	};
+	const textBox = parseTextBoxFromShape(frame.wsp, size);
+	const content = parseTextBoxContent(findChildByLocalName(findChildByLocalName(frame.wsp, "txbx"), "txbxContent"), parseParagraph, parseTable, styles, theme, numbering, rels, media, previews);
+	const transform = frame.rotation !== 0 || frame.flipH || frame.flipV ? {
+		...frame.rotation !== 0 ? { rotation: frame.rotation } : {},
+		...frame.flipH ? { flipH: true } : {},
+		...frame.flipV ? { flipV: true } : {}
+	} : void 0;
+	const shape = {
+		type: "shape",
+		shapeType: "textBox",
+		size,
+		...textBox?.name !== void 0 ? { name: textBox.name } : {},
+		...textBox?.alt !== void 0 ? { alt: textBox.alt } : {},
+		...textBox?.title !== void 0 ? { title: textBox.title } : {},
+		position: {
+			horizontal: {
+				relativeTo: position.horizontal.relativeTo,
+				posOffset: Math.round(horizontalOffset + frame.x)
+			},
+			vertical: {
+				relativeTo: position.vertical.relativeTo,
+				posOffset: Math.round(verticalOffset + frame.y)
+			}
+		},
+		wrap: { type: groupImage.wrap.type === "behind" ? "behind" : "inFront" },
+		...groupImage.anchor !== void 0 ? { anchor: { ...groupImage.anchor } } : {},
+		...textBox?.fill !== void 0 ? { fill: textBox.fill } : {},
+		...textBox?.outline !== void 0 ? { outline: textBox.outline } : {},
+		...transform !== void 0 ? { transform } : {},
+		textBody: {
+			content,
+			...textBox?.autoFit !== void 0 ? { autoFit: textBox.autoFit } : {},
+			...textBox?.textWrap !== void 0 ? { textWrap: textBox.textWrap } : {},
+			...textBox?.verticalAlign !== void 0 ? { anchor: textBox.verticalAlign } : {},
+			...textBox?.margins !== void 0 ? { margins: textBox.margins } : {}
+		},
+		groupChild: {
+			path: frame.path,
+			group,
+			content: groupTextContentFingerprint(content)
+		}
+	};
+	if (textBox?.id) shape.id = textBox.id;
+	return shape;
+};
 const trackedChangeTypeFromXml = (localName) => {
 	if (localName === "ins") return "insertion";
 	if (localName === "del") return "deletion";
@@ -199,7 +314,7 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 		const targetRun = parsedRun ?? (hasNonTextBoxContent ? lastConsumedRun : void 0);
 		const targetRunMatchesXml = targetRun !== void 0 && (hasNonTextBoxContent || parsedRun?.content.length === 0);
 		const fillsEmptyCarrier = targetRunMatchesXml && !hasNonTextBoxContent && parsedRun !== void 0;
-		for (const runEl of textBoxDrawings) {
+		for (const { drawing: runEl, alternateContent: source } of textBoxDrawings) {
 			const textBox = parseTextBox(runEl, context);
 			if (!textBox) continue;
 			const wsp = findDeep(runEl, "wps", "wsp");
@@ -229,9 +344,16 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 				}
 			};
 			if (textBox.id) shape.id = textBox.id;
+			const alternateContent = source && captureShapeAlternateContent({
+				shape,
+				alternateContent: source.element,
+				branch: source.branch,
+				drawing: runEl
+			});
 			const shapeContent = {
 				type: "shape",
-				shape
+				shape,
+				...alternateContent ? { alternateContent } : {}
 			};
 			if (targetRunMatchesXml) targetRun.content.push(shapeContent);
 			else {

package/dist/docx/runParser.js

@@ -10,6 +10,7 @@ import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSche
 import { preserveRunChild } from "./preservedRunContent.js";
 import { standalonePreviewLedger } from "./previewBudget.js";
 import { parseShading } from "./shadingParser.js";
+import { captureShapeAlternateContent } from "./shapeAlternateContent.js";
 import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapeParser.js";
 import { isTextBoxDrawing } from "./textBoxParser.js";
 import { parseThemeColorAttribute } from "./themeColorAttribute.js";
@@ -696,6 +697,15 @@ function parseRunContents(runElement, rels, media, previews, rootXmlns = {}) {
 					const innerDrawing = parseDrawingContent(innerChild, rels, media, previews);
 					if (innerDrawing) {
 						if (innerDrawing.type === "drawing" && (innerDrawing.rawXml !== void 0 || !innerDrawing.image.src)) innerDrawing.rawXml = captureVerbatimXml(child);
+						if (innerDrawing.type === "shape") {
+							const alternateContent = captureShapeAlternateContent({
+								shape: innerDrawing.shape,
+								alternateContent: child,
+								branch: targetEl,
+								drawing: innerChild
+							});
+							if (alternateContent) innerDrawing.alternateContent = alternateContent;
+						}
 						contents.push(innerDrawing);
 					}
 				} else if (innerName === "pict") {

package/dist/docx/selectiveSaveFlags.d.ts

@@ -2,8 +2,11 @@
 /**
  * Selective Save Feature Flags
  *
- * Operational controls for the selective save path. Default values keep the
- * existing full-repack behavior in place so hosts opt in explicitly.
+ * Operational controls for the selective save path. Selective save is on by
+ * default: every save attempts it first and falls back to a full repack
+ * whenever the patch-safety checks refuse (structural changes, untracked
+ * changes, oversized buffers, or an unmodelled part). Hosts that need the
+ * previous behavior can opt back into full repacking on every save.
  *
  * - `selectiveSave` — gate the selective branch entirely.
  * - `selectiveSaveTripwire` — run selective + full and compare bytes for CI
@@ -13,7 +16,11 @@
  *   the dominant cost.
  */
 type FolioSelectiveSaveFlags = {
-  /** Enable the selective save path. Default: false (full repack only). */
+  /**
+   * Enable the selective save path. Default: true. A save always succeeds:
+   * when the patch-safety checks refuse, the caller falls back to a full
+   * repack automatically. Set to `false` to always full-repack.
+   */
   selectiveSave?: boolean;
   /**
    * Run selective save and full repack on every save, compare bytes, and emit

package/dist/docx/selectiveSaveFlags.js

@@ -2,7 +2,7 @@
 const DEFAULT_SELECTIVE_SAVE_MAX_BYTES = 100 * 1024 * 1024;
 function resolveSelectiveSaveFlags(flags) {
 	return {
-		selectiveSave: flags?.selectiveSave ?? false,
+		selectiveSave: flags?.selectiveSave ?? true,
 		selectiveSaveTripwire: flags?.selectiveSaveTripwire ?? false,
 		selectiveSaveMaxBytes: flags?.selectiveSaveMaxBytes ?? 104857600
 	};

package/dist/docx/selectiveXmlPatch.d.ts

@@ -54,22 +54,48 @@ type ParagraphOffsets = {
  * function would return null.
  */
 declare function buildParagraphOffsetIndex(xml: string): Map<string, ParagraphOffsets>;
-/** One `<w:p>` of a part: its byte range and the paraId its open tag carries. */
+/**
+ * The containers a `<w:p>` sits in, as far as a splice has to care.
+ *
+ * A paragraph is addressed inside one *story*: the main flow of the part (its
+ * body, table cells and block-level content controls included), or the text
+ * of a text box (`w:txbxContent`, DrawingML or VML). The two are separate
+ * ordinal spaces, because the model can legitimately represent a text box
+ * differently from the source (a VML box read as DrawingML, a box it cannot
+ * read at all) without that saying anything about the main flow.
+ *
+ * `mc:Fallback` is a copy of its `mc:Choice` for consumers that cannot read
+ * the Choice. The model reads the Choice and owns nothing in the Fallback, so
+ * a Fallback paragraph is never addressed: it is neither a splice target nor
+ * an ordinal, which is also the rule `ensureParaIds` stamps by.
+ */
+type ParagraphContainer = {
+  /** Inside `mc:Fallback`. */
+  inFallback: boolean;
+  /** Inside `mc:AlternateContent`, whose Fallback repeats this paragraph. */
+  inAlternateContent: boolean;
+  /** How many text-box stories (`w:txbxContent`) enclose the paragraph. */
+  textBoxDepth: number;
+  /** How many table cells (`w:tc`) enclose the paragraph. */
+  tableDepth: number;
+};
+/** One `<w:p>` of a part: its byte range, the paraId its open tag carries, and where it sits. */
 type ScannedParagraph = ParagraphOffsets & {
   paraId: string | undefined;
+  container: ParagraphContainer;
 };
 /**
  * Every `<w:p>` element of `xml`, in the document order of its opening tags,
- * with the `w14:paraId` that tag carries.
+ * with the `w14:paraId` that tag carries and the containers around it.
  *
- * Document order is what makes the array an ordinal space: the *n*th entry of
- * the source part and the *n*th entry of the model's serialization name the
- * same paragraph, which is the only way to address a paragraph the producer
- * gave no id. A `<w:p>` nested inside another (inside `mc:AlternateContent`,
- * a text box) is one entry of its own, exactly as
- * {@link countParagraphElements} counts it, so the two never disagree about
- * what an ordinal is. An unterminated paragraph keeps `end === start`: it
- * occupies its ordinal but no splice can be built from it.
+ * Document order is what makes the array an ordinal space: within one story
+ * (see {@link ParagraphContainer}), the *n*th paragraph of the source part and
+ * the *n*th paragraph of the model's serialization name the same paragraph,
+ * which is the only way to address a paragraph the producer gave no id. A
+ * `<w:p>` nested inside another (inside `mc:AlternateContent`, a text box) is
+ * one entry of its own, exactly as {@link countParagraphElements} counts it.
+ * An unterminated paragraph keeps `end === start`: it occupies its ordinal but
+ * no splice can be built from it.
  */
 declare function scanParagraphs(xml: string): ScannedParagraph[];
 /**
@@ -85,32 +111,26 @@ type PatchValidationResult = {
   safe: boolean;
   reason?: string;
 };
-type PatchSafetyOptions = {
-  /**
-   * Require the original and serialized XML to hold the same number of `<w:p>`
-   * elements. Guards document.xml against structural drift. Notes disable it:
-   * the model only retains the normal notes, so a serialized note part
-   * legitimately has fewer paragraphs than the original (which still carries
-   * the separator notes). See {@link buildPatchedNoteXml}.
-   */
-  checkParagraphCount?: boolean;
-};
 /**
- * Validate that a selective patch can be safely applied.
+ * Validate that a selective patch can be safely applied: every changed
+ * paragraph routes to exactly one region of the original part (see
+ * {@link routeChangedParagraphs} for what is refused and why).
  *
- * Checks:
- * - Every changed paraId routes to one region of the original XML, by its
- *   authored id or, when the producer wrote none, by its paragraph ordinal
- * - All changed paraIds exist in serialized XML (exactly once)
- * - Paragraph count matches between original and serialized (unless disabled)
+ * The rest of the part does not have to match the model's serialization. The
+ * splice keeps every unchanged byte of the source, so a paragraph the model
+ * represents differently elsewhere (a text box it re-reads, a Fallback it
+ * does not own) is simply kept as the source wrote it.
  */
-declare function validatePatchSafety(originalXml: string, serializedXml: string, changedIds: Set<string>, options?: PatchSafetyOptions): PatchValidationResult;
+declare function validatePatchSafety(originalXml: string, serializedXml: string, changedIds: Set<string>): PatchValidationResult;
 /**
  * Build a patched document.xml by splicing new paragraph XML into
  * the original at the correct offsets. Only changed paragraphs
  * are replaced; everything else is preserved byte-for-byte.
  *
- * Returns null if any step fails.
+ * Returns null when a changed paragraph cannot be routed (see
+ * {@link validatePatchSafety}) or {@link spliceXml} refuses the result; the
+ * caller then falls back to a full repack, whose parts are all re-serialized
+ * from one model.
  */
 declare function buildPatchedDocumentXml(originalXml: string, serializedXml: string, changedIds: Set<string>): string | null;
 /**
@@ -118,11 +138,13 @@ declare function buildPatchedDocumentXml(originalXml: string, serializedXml: str
  * splicing edited note paragraphs into the original, preserving unchanged
  * content byte-for-byte.
  *
- * Unlike {@link buildPatchedDocumentXml} this does NOT require the paragraph
- * counts to match: the document model only retains the normal notes, so the
- * serialized note XML omits the separator / continuationSeparator paragraphs
- * the original part still carries. Splicing by `paraId` keeps those separators
- * and every unedited note byte-exact while replacing only the edited ones.
+ * The routing is the document's: the model only retains the normal notes, so
+ * the serialized note XML omits the separator / continuationSeparator
+ * paragraphs the original part still carries, and splicing by `paraId` keeps
+ * those separators and every unedited note byte-exact while replacing only the
+ * edited ones. (An id-less note paragraph does not route here, because the
+ * separators misalign its story's ordinals; {@link buildPatchedNotePartXml}
+ * addresses it by note instead.)
  *
  * Returns null if any changed id is missing or ambiguous in either input, so
  * the caller can fall back to preserving the original part verbatim.
@@ -241,4 +263,4 @@ declare const patchNumberingDefinitions: ({ originalXml, baselineXml, currentXml
  */
 declare function appendNumberingDefs(xml: string, currentXml: string, added: ChangedNumberingDefs): string | null;
 //#endregion
-export { ChangedNumberingDefs, NotePartPatch, NotePartPatchRefusal, ParagraphOffsets, PatchSafetyOptions, PatchValidationResult, ScannedParagraph, XmlSplice, appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, patchNumberingDefinitions, scanParagraphs, spliceXml, validatePatchSafety };
+export { ChangedNumberingDefs, NotePartPatch, NotePartPatchRefusal, ParagraphContainer, ParagraphOffsets, PatchValidationResult, ScannedParagraph, XmlSplice, appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, patchNumberingDefinitions, scanParagraphs, spliceXml, validatePatchSafety };