@stll/folio-core 0.51.0 → 0.53.0

package/dist/docx/serializer/documentSerializer.js

@@ -1,3 +1,4 @@
+import { serializeBlockCustomXml } from "./blockCustomXmlSerializer.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
@@ -45,6 +46,7 @@ function serializeBlockContent(block) {
 		case "paragraph": return serializeParagraph(block);
 		case "table": return serializeTable(block, serializeParagraph);
 		case "blockSdt": return serializeBlockSdt(block, serializeBlockContent);
+		case "blockCustomXml": return serializeBlockCustomXml(block, serializeBlockContent);
 		case "preservedBlock": return block.xml;
 		case "bookmarkStart":
 		case "bookmarkEnd": return serializeBookmarkMarker(block);

package/dist/docx/serializer/headerFooterSerializer.js

@@ -2,6 +2,7 @@ import { canReplayHeaderFooterVerbatim, getHeaderFooterVerbatimXml } from "../he
 import { isEmptyParagraph } from "../paragraphParser.js";
 import { captureVerbatimXml } from "../verbatimCapture.js";
 import { getLocalName, parseXmlDocument } from "../xmlParser.js";
+import { serializeBlockCustomXml } from "./blockCustomXmlSerializer.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
@@ -41,6 +42,7 @@ function serializeBlock(block) {
 		case "paragraph": return serializeParagraph(block);
 		case "table": return serializeTable(block, serializeParagraph);
 		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
+		case "blockCustomXml": return serializeBlockCustomXml(block, serializeBlock);
 		case "preservedBlock": return block.xml;
 		case "bookmarkStart":
 		case "bookmarkEnd": return serializeBookmarkMarker(block);

package/dist/docx/serializer/noteSerializer.js

@@ -1,3 +1,4 @@
+import { serializeBlockCustomXml } from "./blockCustomXmlSerializer.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
@@ -43,6 +44,7 @@ function serializeBlock(block) {
 		case "paragraph": return serializeParagraph(block);
 		case "table": return serializeTable(block, serializeParagraph);
 		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
+		case "blockCustomXml": return serializeBlockCustomXml(block, serializeBlock);
 		case "preservedBlock": return block.xml;
 		case "bookmarkStart":
 		case "bookmarkEnd": return serializeBookmarkMarker(block);
@@ -65,7 +67,7 @@ function serializeRequiredNoteSeparators(elementName) {
 	return `<w:${elementName} w:type="separator" w:id="-1">${NOTE_SEPARATOR_BODY}<w:r><w:separator/></w:r></w:p></w:${elementName}><w:${elementName} w:type="continuationSeparator" w:id="0">${NOTE_SEPARATOR_BODY}<w:r><w:continuationSeparator/></w:r></w:p></w:${elementName}>`;
 }
 function insertNoteReferenceMark(xml, elementName) {
-	if (xml.includes(`<w:${elementName}Ref`)) return xml;
+	if (new RegExp(`<(?:[\\w.-]+:)?${elementName}Ref[\\s/>]`, "u").test(xml)) return xml;
 	const paragraphOpen = /<w:p(?=[\s>])[^>]*>/u.exec(xml);
 	if (!paragraphOpen) return `${`<w:p><w:r><w:rPr><w:rStyle w:val="${elementName === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr><w:${elementName}Ref/></w:r></w:p>`}${xml}`;
 	const paragraphStart = paragraphOpen.index + paragraphOpen[0].length;

package/dist/docx/serializer/paragraphSerializer.js

@@ -14,7 +14,7 @@ import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { serializeTrackedChangeAttributes, trackedChangeAttributeRecord } from "./trackedChangeAttributes.js";
-import { panic } from "better-result";
+import { TaggedError, panic } from "better-result";
 import { escapeXmlAttribute, escapeXmlText } from "@stll/docx-core";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 import { SEQUENCE_CHILDREN } from "@stll/docx-core/schema";
@@ -315,27 +315,51 @@ function serializeSimpleField(field) {
 	}).join("");
 	return `<w:fldSimple ${attrs.join(" ")}>${contentXml}</w:fldSimple>`;
 }
-/**
-* Serialize a complex field
-* Complex fields are represented by multiple runs with fldChar elements,
-* so we convert them back to that structure
-*/
+const replayableFormFieldDataXml = createCapturedXmlSanitizer({
+	allowedLocalNames: /* @__PURE__ */ new Set(["ffData"]),
+	allowedNamespaceUris: WORDPROCESSINGML_NAMESPACE,
+	inheritedNamespaceScope: OOXML_NAMESPACE_SCOPE
+});
+/** Serialize a complex field as structural fldChar runs and its content runs. */
 function serializeComplexField(field) {
 	const parts = [];
 	const structuralFormatting = field.formatting ?? (field.fieldResultIsFallback ? void 0 : field.fieldResult[0]?.formatting);
 	const rPrXml = structuralFormatting ? serializeTextFormatting(structuralFormatting) : "";
 	const beginAttrs = ["w:fldCharType=\"begin\"", ...fieldStateAttributes(field)];
-	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
+	const formFieldDataXml = replayableFormFieldDataXml(field.formFieldDataXml);
+	const begin = formFieldDataXml ? `<w:fldChar ${beginAttrs.join(" ")}>${formFieldDataXml}</w:fldChar>` : `<w:fldChar ${beginAttrs.join(" ")}/>`;
+	parts.push(`<w:r>${rPrXml}${begin}</w:r>`);
 	if (field.fieldCode.length > 0) parts.push(...field.fieldCode.map((run) => serializeRun(run)));
 	else if (field.instruction.length > 0) {
 		const spaceAttr = field.instruction.startsWith(" ") || field.instruction.endsWith(" ") || field.instruction.includes("  ") ? " xml:space=\"preserve\"" : "";
 		parts.push(`<w:r>${rPrXml}<w:instrText${spaceAttr}>${escapeXmlText(field.instruction)}</w:instrText></w:r>`);
 	}
 	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="separate"/></w:r>`);
-	if (!field.fieldResultIsFallback) parts.push(...field.fieldResult.map((run) => serializeRun(run)));
+	if (!field.fieldResultIsFallback || !formFieldDataXml) parts.push(...field.fieldResult.map((run) => serializeRun(run)));
 	parts.push(`<w:r>${rPrXml}<w:fldChar w:fldCharType="end"/></w:r>`);
 	return parts.join("");
 }
+var UnrepresentableTrackedSimpleFieldError = class extends TaggedError("UnrepresentableTrackedSimpleFieldError") {};
+/** A revision can contain run-level field characters, but not `w:fldSimple`. */
+function serializeTrackedSimpleField(field) {
+	const fieldResult = [];
+	for (const item of field.content) {
+		if (item.type !== "run") throw new UnrepresentableTrackedSimpleFieldError({
+			message: `A tracked simple field with ${item.type} result content cannot be serialized as valid OOXML.`,
+			contentType: item.type
+		});
+		fieldResult.push(item);
+	}
+	return serializeComplexField({
+		type: "complexField",
+		instruction: field.instruction,
+		fieldType: field.fieldType,
+		fieldCode: [],
+		fieldResult,
+		...field.fldLock !== void 0 && { fldLock: field.fldLock },
+		...field.dirty !== void 0 && { dirty: field.dirty }
+	});
+}
 /**
 * Serialize an inline SDT (w:sdt).
 *
@@ -413,7 +437,7 @@ function serializeTrackedChange(tag, change) {
 			case "run": return serializeContentRun(item);
 			case "simpleField":
 			case "complexField": {
-				const xml = item.type === "simpleField" ? serializeSimpleField(item) : serializeComplexField(item);
+				const xml = item.type === "simpleField" ? serializeTrackedSimpleField(item) : serializeComplexField(item);
 				return disposition === "removed" ? rewriteRunTextAsDeleted(xml) : xml;
 			}
 			case "mathEquation": return item.ommlXml;

package/dist/docx/serializer/tableSerializer.js

@@ -6,6 +6,7 @@ import { TRANSITIONAL_NAME_BY_STRICT_NAME } from "../strictNames.gen.js";
 import { TABLE_LOOK_FLAGS } from "../tableLook.js";
 import { parseTableCellProperties, parseTableGrid, parseTableProperties, parseTablePropertyExceptions, parseTableRowProperties } from "../tableParser.js";
 import { OOXML_NAMESPACE_SCOPE, parseXml } from "../xmlParser.js";
+import { serializeBlockCustomXml } from "./blockCustomXmlSerializer.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeBorder } from "./borderSerializer.js";
 import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
@@ -456,56 +457,40 @@ const serializeTableGridChange = ({ id, columnWidths }) => {
 	const columns = columnWidths.map((width) => width === void 0 ? "<w:gridCol/>" : `<w:gridCol w:w="${intAttr(width)}"/>`).join("");
 	return `<w:tblGridChange w:id="${intAttr(id)}"><w:tblGrid>${columns}</w:tblGrid></w:tblGridChange>`;
 };
-/**
-* What makes two rows members of the same control.
-*
-* The control's record is on every child it held, so the wrapper is rebuilt
-* by grouping consecutive children that name the same control. Equality is
-* the record's canonical spelling rather than object identity, because the
-* editor carries these records through JSON — a Yjs sync, a snapshot, a
-* structured clone — and hands back an equal record rather than the same one.
-* A wrapper that split in two there would mint a second `w:id` for one
-* control, which is the defect, not the fix.
-*
-* The cost is the other direction: two adjacent rows the author put in two
-* separate but identically spelled controls come back as one. Word mints a
-* distinct `w:id` per control, so that needs a producer that writes none; the
-* inline wrapper stack makes the same trade for the same reason.
-*/
-const contentControlKey = (properties) => canonicalJson(properties);
-/**
-* Re-open each control around the run of children that named it, outermost
-* first.
-*
-* @param depth which layer of the stack this call is opening
-*/
-const serializeControlledChildren = (children, depth) => {
+const tableCarrierKey = (carrier) => carrier.type === "customXml" ? `customXml:${String(carrier.wrapper.id)}` : `sdt:${canonicalJson(carrier.properties)}`;
+const serializeTableCarriers = (children, depth = 0) => {
 	const parts = [];
 	let index = 0;
 	while (index < children.length) {
 		const child = children[index];
-		const control = child.controls[depth];
-		if (control === void 0) {
+		if (!child) break;
+		const carrier = child.carriers[depth];
+		if (!carrier) {
 			parts.push(child.xml);
 			index += 1;
 			continue;
 		}
-		const key = contentControlKey(control);
+		const carrierKey = tableCarrierKey(carrier);
 		let end = index + 1;
 		while (end < children.length) {
-			const next = children[end]?.controls[depth];
-			if (next === void 0 || contentControlKey(next) !== key) break;
+			const next = children[end]?.carriers[depth];
+			if ((next ? tableCarrierKey(next) : void 0) !== carrierKey) break;
 			end += 1;
 		}
-		const inner = serializeControlledChildren(children.slice(index, end), depth + 1);
-		parts.push(serializeSdtWrapper(control, inner));
+		const inner = serializeTableCarriers(children.slice(index, end), depth + 1);
+		if (carrier.type === "customXml") parts.push(`${carrier.wrapper.openingXml}${inner}${carrier.wrapper.closingXml}`);
+		else parts.push(serializeSdtWrapper(carrier.properties, inner));
 		index = end;
 	}
 	return parts.join("");
 };
+const carriersFor = (value) => value.carrierStack ?? [...(value.contentControls ?? []).map((properties) => ({
+	type: "sdt",
+	properties
+}))];
 /** A capture from the sink, with the controls it sat inside when parsed. */
 const preservedChild = (xml, child) => ({
-	controls: child.contentControls ?? [],
+	carriers: carriersFor(child),
 	xml
 });
 /**
@@ -517,6 +502,7 @@ function serializeCellContent(content, serializeParagraph) {
 			case "paragraph": return serializeParagraph(block);
 			case "table": return serializeTable(block, serializeParagraph);
 			case "blockSdt": return serializeBlockSdt(block, serializeCellBlock);
+			case "blockCustomXml": return serializeBlockCustomXml(block, serializeCellBlock);
 			case "preservedBlock": return block.xml;
 			case "bookmarkStart":
 			case "bookmarkEnd": return serializeBookmarkMarker(block);
@@ -549,10 +535,11 @@ function serializeTableCell(cell, serializeParagraph) {
 */
 const positionedChildren = (preserved, bookmarks) => {
 	if (bookmarks === void 0 || bookmarks.length === 0) return preserved;
-	return { children: [...preserved?.children ?? [], ...bookmarks.map(({ index, marker, contentControls }) => ({
+	return { children: [...preserved?.children ?? [], ...bookmarks.map(({ index, marker, contentControls, carrierStack }) => ({
 		index,
 		xml: serializeBookmarkMarker(marker),
-		...contentControls === void 0 ? {} : { contentControls }
+		...contentControls === void 0 ? {} : { contentControls },
+		...carrierStack === void 0 ? {} : { carrierStack }
 	}))] };
 };
 /**
@@ -564,8 +551,8 @@ function serializeTableRow(row, serializeParagraph) {
 	if (tblPrExXml) parts.push(tblPrExXml);
 	const trPrXml = serializeTableRowFormatting(row.formatting, row.propertyChanges, row.structuralChange);
 	if (trPrXml) parts.push(trPrXml);
-	parts.push(serializeControlledChildren(withPreservedChildren(row.cells.map((cell) => ({
-		controls: cell.contentControls ?? [],
+	parts.push(serializeTableCarriers(withPreservedChildren(row.cells.map((cell) => ({
+		carriers: carriersFor(cell),
 		xml: serializeTableCell(cell, serializeParagraph)
 	})), positionedChildren(row.preserved, row.bookmarks), preservedChild), 0));
 	const attrs = serializePreservedAttributes([], row.preservedAttributes);
@@ -581,8 +568,8 @@ function serializeTable(table, serializeParagraph) {
 	return `<w:tbl>${[
 		serializeTableFormatting(table.formatting, table.propertyChanges) || "<w:tblPr/>",
 		serializeTableGrid(table),
-		serializeControlledChildren(withPreservedChildren(table.rows.map((row) => ({
-			controls: row.contentControls ?? [],
+		serializeTableCarriers(withPreservedChildren(table.rows.map((row) => ({
+			carriers: carriersFor(row),
 			xml: serializeTableRow(row, serializeParagraph)
 		})), positionedChildren(table.preserved, table.bookmarks), preservedChild), 0)
 	].join("")}</w:tbl>`;

package/dist/docx/server/createBilingualDocument.js

@@ -203,7 +203,7 @@ const flattenBlocks = (content) => {
 			out.push(block);
 			return;
 		}
-		if (block.type !== "blockSdt") return;
+		if (block.type !== "blockSdt" && block.type !== "blockCustomXml") return;
 		for (const child of block.content) visit(child);
 	};
 	for (const block of content) visit(block);
@@ -467,7 +467,7 @@ const collectTableParagraphs = (table) => {
 	const collectBlocks = (blocks) => {
 		for (const item of blocks) if (item.type === "paragraph") out.push(item);
 		else if (item.type === "table") out.push(...collectTableParagraphs(item));
-		else if (item.type === "blockSdt") collectBlocks(item.content);
+		else if (item.type === "blockSdt" || item.type === "blockCustomXml") collectBlocks(item.content);
 	};
 	for (const row of table.rows) for (const cell of row.cells) collectBlocks(cell.content);
 	return out;
@@ -476,7 +476,7 @@ const cloneTableForTarget = ({ table, editableParagraphIds, paraIds, styleCloner
 	const paragraphs = [];
 	const cloneBlocks = (blocks) => blocks.map((item) => {
 		if (item.type === "table") return cloneTable(item);
-		if (item.type === "blockSdt") return {
+		if (item.type === "blockSdt" || item.type === "blockCustomXml") return {
 			...structuredClone(item),
 			content: cloneBlocks(item.content)
 		};

package/dist/docx/tableParser.d.ts

@@ -1,6 +1,8 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
+import { ParseContext } from "./parseContext.js";
 import { XmlElement } from "./xmlParser.js";
+import { OwnedElsewhere } from "./containerChildren.js";
 import { PreviewLedger } from "./previewBudget.js";
 import { StyleMap } from "./styleParser.js";
 //#region src/docx/tableParser.d.ts
@@ -68,6 +70,8 @@ declare function parseTableProperties(tblPrElement: XmlElement | null): document
  * {@link parseTablePropertyExceptionChanges}.
  */
 declare function parseTablePropertyExceptions(tblPrExElement: XmlElement | null): document_d_exports.TablePropertyExceptionFormatting | undefined;
+declare function isTableCellMergeRevisionValue(value: unknown): value is "continue" | "rest";
+declare function isTableCellMergeRevisionContinuation(value: "continue" | "rest" | undefined): boolean;
 /**
  * Parse table row properties (w:trPr)
  *
@@ -89,6 +93,20 @@ declare function parseConditionalFormatStyle(cnfElement: XmlElement | null): doc
  * @returns Parsed cell formatting
  */
 declare function parseTableCellProperties(tcPrElement: XmlElement | null): document_d_exports.TableCellFormatting | undefined;
+/**
+ * Record a `CT_SdtRow` / `CT_SdtCell` on the rows or cells it wrapped.
+ *
+ * Both are transparent: what they hold is ordinary rows and cells, and the
+ * control adds properties and an end mark. folio keeps the children modelled
+ * and puts the control on each of them rather than modelling a wrapper
+ * between them, because a table's children are rows and a row's are cells,
+ * and neither has a node to spare for something that is not one.
+ *
+ * Outermost first, so a control inside a control — a bound row inside a
+ * repeating section — comes back nested the way it was written. The
+ * recursion reads the inner one first, so the outer prepends.
+ */
+type TablePreservedChild = NonNullable<document_d_exports.TablePreservedMarkup["children"]>[number];
 /**
  * Parse table cell content, including nested block controls.
  *
@@ -105,6 +123,58 @@ type TableParseOptions = {
   rootXmlns?: Record<string, string>;
   /** The ledger of the package this table belongs to; a table read on its own has none. */
   previews?: PreviewLedger;
+  context?: ParseContext | undefined;
+};
+/** What a table's rows, cells and blocks read: the ledger is settled where the walk enters. */
+type TableScope = TableParseOptions & {
+  previews: PreviewLedger;
+};
+/** The parts and maps a table's content is read against. */
+type TableParseResources = {
+  styles: StyleMap | null;
+  theme: document_d_exports.Theme | null;
+  numbering: NumberingMap | null;
+  rels: document_d_exports.RelationshipMap | null;
+  media: Map<string, document_d_exports.MediaFile> | null;
+};
+/** One cell's block sequence, or a block control's inside it, as it is read. */
+type CellChildrenWalk = {
+  resources: TableParseResources;
+  options: TableScope;
+  modelled: document_d_exports.TableCellBlock[];
+  captured: document_d_exports.PreservedChild[];
+};
+declare const CELL_CONTENT_HANDLERS: {
+  readonly p: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, options, modelled }: CellChildrenWalk) => void;
+  readonly tbl: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, options, modelled }: CellChildrenWalk) => void;
+  readonly sdt: (child: XmlElement, { resources, options, modelled }: CellChildrenWalk) => "capture" | undefined;
+  readonly customXml: (child: XmlElement, { resources, options, modelled }: CellChildrenWalk) => void;
+  readonly bookmarkStart: (child: XmlElement, { modelled }: CellChildrenWalk) => void;
+  readonly bookmarkEnd: (child: XmlElement, { modelled }: CellChildrenWalk) => void;
+  readonly tcPr: OwnedElsewhere<"block-content", "tcPr">;
+  readonly sectPr: "capture";
+  readonly altChunk: "capture";
+  readonly commentRangeEnd: "capture";
+  readonly commentRangeStart: "capture";
+  readonly customXmlDelRangeEnd: "capture";
+  readonly customXmlDelRangeStart: "capture";
+  readonly customXmlInsRangeEnd: "capture";
+  readonly customXmlInsRangeStart: "capture";
+  readonly customXmlMoveFromRangeEnd: "capture";
+  readonly customXmlMoveFromRangeStart: "capture";
+  readonly customXmlMoveToRangeEnd: "capture";
+  readonly customXmlMoveToRangeStart: "capture";
+  readonly del: "capture";
+  readonly ins: "capture";
+  readonly moveFrom: "capture";
+  readonly moveFromRangeEnd: "capture";
+  readonly moveFromRangeStart: "capture";
+  readonly moveTo: "capture";
+  readonly moveToRangeEnd: "capture";
+  readonly moveToRangeStart: "capture";
+  readonly permEnd: "capture";
+  readonly permStart: "capture";
+  readonly proofErr: "capture";
 };
 /**
  * Parse a table cell (w:tc)
@@ -118,6 +188,49 @@ type TableParseOptions = {
  * @returns Parsed table cell
  */
 declare function parseTableCell(tcElement: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, options?: TableParseOptions): document_d_exports.TableCell;
+/** One row's children, or a cell-level content control's, as they are read. */
+type RowChildrenWalk = {
+  resources: TableParseResources;
+  options: TableScope;
+  row: document_d_exports.TableRow;
+  bookmarks: document_d_exports.PositionedBookmarkMarker[];
+  preservedChildren: TablePreservedChild[];
+  customXmlIdentity: {
+    next: number;
+  };
+};
+declare const ROW_CONTENT_HANDLERS: {
+  readonly commentRangeEnd: "capture";
+  readonly commentRangeStart: "capture";
+  readonly customXmlPr: "capture";
+  readonly customXmlDelRangeEnd: "capture";
+  readonly customXmlDelRangeStart: "capture";
+  readonly customXmlInsRangeEnd: "capture";
+  readonly customXmlInsRangeStart: "capture";
+  readonly customXmlMoveFromRangeEnd: "capture";
+  readonly customXmlMoveFromRangeStart: "capture";
+  readonly customXmlMoveToRangeEnd: "capture";
+  readonly customXmlMoveToRangeStart: "capture";
+  readonly del: "capture";
+  readonly ins: "capture";
+  readonly moveFrom: "capture";
+  readonly moveFromRangeEnd: "capture";
+  readonly moveFromRangeStart: "capture";
+  readonly moveTo: "capture";
+  readonly moveToRangeEnd: "capture";
+  readonly moveToRangeStart: "capture";
+  readonly permEnd: "capture";
+  readonly permStart: "capture";
+  readonly proofErr: "capture";
+  readonly tr: (child: XmlElement, { options }: RowChildrenWalk) => "capture";
+  readonly trPr: OwnedElsewhere<"row-content", "trPr">;
+  readonly tblPrEx: OwnedElsewhere<"row-content", "tblPrEx">;
+  readonly tc: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, options, row }: RowChildrenWalk) => void;
+  readonly sdt: (child: XmlElement, walk: RowChildrenWalk) => "capture" | undefined;
+  readonly customXml: (child: XmlElement, walk: RowChildrenWalk) => "capture" | undefined;
+  readonly bookmarkStart: (child: XmlElement, { row, bookmarks }: RowChildrenWalk) => void;
+  readonly bookmarkEnd: (child: XmlElement, { row, bookmarks }: RowChildrenWalk) => void;
+};
 /**
  * Parse a table row (w:tr)
  *
@@ -137,6 +250,49 @@ declare function parseTableRow(trElement: XmlElement, styles: StyleMap | null, t
  * @returns Array of column widths in twips
  */
 declare function parseTableGrid(tblGridElement: XmlElement | null): number[] | undefined;
+/** One table's children, or a row-level content control's, as they are read. */
+type TableChildrenWalk = {
+  resources: TableParseResources;
+  options: TableScope;
+  table: document_d_exports.Table;
+  rowsWithGridOffsets: Set<number>;
+  bookmarks: document_d_exports.PositionedBookmarkMarker[];
+  preservedChildren: TablePreservedChild[];
+  customXmlIdentity: {
+    next: number;
+  };
+};
+declare const TABLE_CONTENT_HANDLERS: {
+  readonly bookmarkStart: (child: XmlElement, { table, bookmarks }: TableChildrenWalk) => void;
+  readonly bookmarkEnd: (child: XmlElement, { table, bookmarks }: TableChildrenWalk) => void;
+  readonly commentRangeEnd: "capture";
+  readonly commentRangeStart: "capture";
+  readonly customXmlPr: "capture";
+  readonly customXmlDelRangeEnd: "capture";
+  readonly customXmlDelRangeStart: "capture";
+  readonly customXmlInsRangeEnd: "capture";
+  readonly customXmlInsRangeStart: "capture";
+  readonly customXmlMoveFromRangeEnd: "capture";
+  readonly customXmlMoveFromRangeStart: "capture";
+  readonly customXmlMoveToRangeEnd: "capture";
+  readonly customXmlMoveToRangeStart: "capture";
+  readonly del: "capture";
+  readonly ins: "capture";
+  readonly moveFrom: "capture";
+  readonly moveFromRangeEnd: "capture";
+  readonly moveFromRangeStart: "capture";
+  readonly moveTo: "capture";
+  readonly moveToRangeEnd: "capture";
+  readonly moveToRangeStart: "capture";
+  readonly permEnd: "capture";
+  readonly permStart: "capture";
+  readonly proofErr: "capture";
+  readonly tblPr: OwnedElsewhere<"table-content", "tblPr">;
+  readonly tblGrid: OwnedElsewhere<"table-content", "tblGrid">;
+  readonly tr: (child: XmlElement, { resources: { styles, theme, numbering, rels, media }, options, table, rowsWithGridOffsets }: TableChildrenWalk) => void;
+  readonly sdt: (child: XmlElement, walk: TableChildrenWalk) => "capture" | undefined;
+  readonly customXml: (child: XmlElement, walk: TableChildrenWalk) => "capture" | undefined;
+};
 /**
  * Parse a table element (w:tbl)
  *
@@ -215,4 +371,4 @@ declare function getHeaderRows(table: document_d_exports.Table): document_d_expo
  */
 declare function isFloatingTable(table: document_d_exports.Table): boolean;
 //#endregion
-export { MAX_TABLE_COLUMNS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };
+export { CELL_CONTENT_HANDLERS, MAX_TABLE_COLUMNS, ROW_CONTENT_HANDLERS, TABLE_CONTENT_HANDLERS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, isTableCellMergeRevisionContinuation, isTableCellMergeRevisionValue, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };