@stll/folio-core 0.11.0 → 0.12.0

package/dist/docx/server/validateDocxConformance.d.ts

@@ -0,0 +1,41 @@
+import { document_d_exports } from "../../types/document.js";
+import { DocxArchiveOptions } from "./boundedArchive.js";
+
+//#region src/docx/server/validateDocxConformance.d.ts
+declare const FOLIO_DOCX_CONFORMANCE_REPORT_VERSION: 1;
+declare const FOLIO_DOCX_CONFORMANCE_PROFILE: "folio-supported-v1";
+declare const FOLIO_DOCX_CONFORMANCE_CHECKS: readonly ["archive-safety", "required-parts", "xml-well-formedness", "package-roots", "conformance-class", "canonical-model"];
+declare const FOLIO_DOCX_CONFORMANCE_ISSUE_CODES: readonly ["archive-load-failed", "archive-invalid-options", "archive-input-too-large", "archive-too-many-entries", "archive-entry-too-large", "archive-total-too-large", "required-part-missing", "xml-doctype-forbidden", "xml-not-well-formed", "xml-read-failed", "required-xml-unreadable", "package-root-invalid", "conformance-class-unknown", "model-invalid", "model-warning", "parser-recovery", "parser-unsupported", "parser-failed", "encrypted-container", "container-not-zip"];
+type FolioDocxConformanceCheckId = (typeof FOLIO_DOCX_CONFORMANCE_CHECKS)[number];
+type FolioDocxConformanceIssueCode = (typeof FOLIO_DOCX_CONFORMANCE_ISSUE_CODES)[number];
+type FolioDocxConformanceCheckStatus = "passed" | "failed" | "indeterminate" | "not-run";
+type FolioDocxConformanceStatus = "invalid" | "conformant" | "indeterminate";
+type FolioDocxConformanceIssue = {
+  readonly check: FolioDocxConformanceCheckId;
+  readonly code: FolioDocxConformanceIssueCode;
+  readonly message: string;
+  readonly severity: "error" | "warning";
+  readonly part?: string;
+  readonly modelPath?: string;
+  readonly count?: number;
+};
+type FolioDocxConformanceCheck = {
+  readonly id: FolioDocxConformanceCheckId;
+  readonly status: FolioDocxConformanceCheckStatus;
+};
+type FolioDocxConformanceReport = {
+  readonly version: typeof FOLIO_DOCX_CONFORMANCE_REPORT_VERSION;
+  readonly profile: typeof FOLIO_DOCX_CONFORMANCE_PROFILE;
+  readonly status: FolioDocxConformanceStatus;
+  readonly conformanceClass: document_d_exports.DocxConformanceClass;
+  readonly checks: readonly FolioDocxConformanceCheck[];
+  readonly issues: readonly FolioDocxConformanceIssue[];
+  readonly unverifiedStandardsDimensions: readonly ["complete-schema-constraints", "markup-compatibility-processing", "consumer-specific-rendering"];
+};
+type ValidateDocxConformanceOptions = {
+  readonly archive?: DocxArchiveOptions;
+};
+/** Assess a DOCX package against Folio's named, versioned support profile. */
+declare const validateDocxConformance: (bytes: ArrayBuffer | Uint8Array, options?: ValidateDocxConformanceOptions) => Promise<FolioDocxConformanceReport>;
+//#endregion
+export { FOLIO_DOCX_CONFORMANCE_CHECKS, FOLIO_DOCX_CONFORMANCE_ISSUE_CODES, FOLIO_DOCX_CONFORMANCE_PROFILE, FOLIO_DOCX_CONFORMANCE_REPORT_VERSION, FolioDocxConformanceCheck, FolioDocxConformanceCheckId, FolioDocxConformanceCheckStatus, FolioDocxConformanceIssue, FolioDocxConformanceIssueCode, FolioDocxConformanceReport, FolioDocxConformanceStatus, ValidateDocxConformanceOptions, validateDocxConformance };

package/dist/docx/server/validateDocxConformance.js

@@ -0,0 +1,336 @@
+import { findChildByLocalName, getAttributeAnyPrefix, getLocalName, getNamespacePrefix, parseXmlDocument } from "../xmlParser.js";
+import { detectDocxConformanceClass } from "../conformance.js";
+import { DocxModelValidationError, validateFolioDocumentModel } from "../modelValidation.js";
+import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "../encryption/containerFormat.js";
+import { DocxParseError, parseDocx } from "../parser.js";
+import { DocxArchiveError, loadDocxArchive } from "./boundedArchive.js";
+import { getDocxXmlSafetyIssue } from "../xmlSafety.js";
+import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
+//#region src/docx/server/validateDocxConformance.ts
+const FOLIO_DOCX_CONFORMANCE_REPORT_VERSION = 1;
+const FOLIO_DOCX_CONFORMANCE_PROFILE = "folio-supported-v1";
+const FOLIO_DOCX_CONFORMANCE_CHECKS = Object.freeze([
+	"archive-safety",
+	"required-parts",
+	"xml-well-formedness",
+	"package-roots",
+	"conformance-class",
+	"canonical-model"
+]);
+const FOLIO_DOCX_CONFORMANCE_ISSUE_CODES = Object.freeze([
+	"archive-load-failed",
+	"archive-invalid-options",
+	"archive-input-too-large",
+	"archive-too-many-entries",
+	"archive-entry-too-large",
+	"archive-total-too-large",
+	"required-part-missing",
+	"xml-doctype-forbidden",
+	"xml-not-well-formed",
+	"xml-read-failed",
+	"required-xml-unreadable",
+	"package-root-invalid",
+	"conformance-class-unknown",
+	"model-invalid",
+	"model-warning",
+	"parser-recovery",
+	"parser-unsupported",
+	"parser-failed",
+	"encrypted-container",
+	"container-not-zip"
+]);
+const REQUIRED_PARTS = Object.freeze([
+	"[Content_Types].xml",
+	"_rels/.rels",
+	"word/document.xml"
+]);
+const XML_PART_PATTERN = /(?:\.xml|\.rels)$/u;
+const DOCUMENT_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+const CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+const RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+const UNVERIFIED_STANDARDS_DIMENSIONS = Object.freeze([
+	"complete-schema-constraints",
+	"markup-compatibility-processing",
+	"consumer-specific-rendering"
+]);
+const createMutableReport = () => ({
+	conformanceClass: DOCX_CONFORMANCE_CLASSES.UNKNOWN,
+	checks: new Map(FOLIO_DOCX_CONFORMANCE_CHECKS.map((id) => [id, "not-run"])),
+	issues: []
+});
+const addIssue = (report, issue) => {
+	report.issues.push(issue);
+};
+const finishReport = (report) => {
+	const checks = FOLIO_DOCX_CONFORMANCE_CHECKS.map((id) => ({
+		id,
+		status: report.checks.get(id) ?? "not-run"
+	}));
+	const hasFailedCheck = checks.some(({ status }) => status === "failed");
+	const hasIndeterminateCheck = checks.some(({ status }) => status === "indeterminate");
+	let status = "conformant";
+	if (hasFailedCheck) status = "invalid";
+	else if (hasIndeterminateCheck || checks.some(({ status: checkStatus }) => checkStatus === "not-run")) status = "indeterminate";
+	return {
+		version: 1,
+		profile: FOLIO_DOCX_CONFORMANCE_PROFILE,
+		status,
+		conformanceClass: report.conformanceClass,
+		checks,
+		issues: report.issues,
+		unverifiedStandardsDimensions: UNVERIFIED_STANDARDS_DIMENSIONS
+	};
+};
+const validateRequiredParts = (archive, report) => {
+	const entries = new Set(archive.entries);
+	const missingParts = REQUIRED_PARTS.filter((path) => !entries.has(path));
+	if (missingParts.length === 0) {
+		report.checks.set("required-parts", "passed");
+		return true;
+	}
+	report.checks.set("required-parts", "failed");
+	for (const part of missingParts) addIssue(report, {
+		check: "required-parts",
+		code: "required-part-missing",
+		message: "A required package part is missing.",
+		severity: "error",
+		part
+	});
+	return false;
+};
+const validateXmlParts = async (archive, report) => {
+	const xmlByPath = /* @__PURE__ */ new Map();
+	let hasInvalidXml = false;
+	for (const part of archive.entries.filter((path) => XML_PART_PATTERN.test(path)).toSorted()) {
+		const xml = await archive.readEntryString(part);
+		if (xml === null) continue;
+		xmlByPath.set(part, xml);
+		const safetyIssue = getDocxXmlSafetyIssue(xml);
+		if (safetyIssue === "doctype-forbidden") {
+			hasInvalidXml = true;
+			addIssue(report, {
+				check: "xml-well-formedness",
+				code: "xml-doctype-forbidden",
+				message: "XML package parts must not declare a document type.",
+				severity: "error",
+				part
+			});
+			continue;
+		}
+		if (safetyIssue === "not-well-formed") {
+			hasInvalidXml = true;
+			addIssue(report, {
+				check: "xml-well-formedness",
+				code: "xml-not-well-formed",
+				message: "An XML package part is not well formed.",
+				severity: "error",
+				part
+			});
+		}
+	}
+	if (hasInvalidXml) {
+		report.checks.set("xml-well-formedness", "failed");
+		return null;
+	}
+	report.checks.set("xml-well-formedness", "passed");
+	const contentTypesXml = xmlByPath.get("[Content_Types].xml");
+	const packageRelationshipsXml = xmlByPath.get("_rels/.rels");
+	const documentXml = xmlByPath.get("word/document.xml");
+	if (contentTypesXml === void 0 || packageRelationshipsXml === void 0 || documentXml === void 0) {
+		report.checks.set("xml-well-formedness", "indeterminate");
+		addIssue(report, {
+			check: "xml-well-formedness",
+			code: "required-xml-unreadable",
+			message: "A required XML package part could not be read.",
+			severity: "error"
+		});
+		return null;
+	}
+	return {
+		contentTypesXml,
+		packageRelationshipsXml,
+		documentXml
+	};
+};
+const hasRootNamespace = ({ name, attributes, expected }) => {
+	const prefix = getNamespacePrefix(name);
+	const attribute = prefix === null ? "xmlns" : `xmlns:${prefix}`;
+	return attributes?.[attribute] === expected;
+};
+const hasDocumentContentType = (contentTypesXml) => {
+	const root = parseXmlDocument(contentTypesXml);
+	if (root === null || getLocalName(root.name ?? "") !== "Types" || !hasRootNamespace({
+		name: root.name ?? "",
+		attributes: root.attributes,
+		expected: CONTENT_TYPES_NAMESPACE
+	})) return false;
+	return root.elements?.some((element) => element.type === "element" && getLocalName(element.name ?? "") === "Override" && getAttributeAnyPrefix(element, "PartName") === "/word/document.xml" && getAttributeAnyPrefix(element, "ContentType") === DOCUMENT_CONTENT_TYPE) ?? false;
+};
+const hasMainDocumentRelationship = (packageRelationshipsXml) => {
+	const root = parseXmlDocument(packageRelationshipsXml);
+	if (root === null || getLocalName(root.name ?? "") !== "Relationships" || !hasRootNamespace({
+		name: root.name ?? "",
+		attributes: root.attributes,
+		expected: RELATIONSHIPS_NAMESPACE
+	})) return false;
+	return root.elements?.some((element) => {
+		if (element.type !== "element" || getLocalName(element.name ?? "") !== "Relationship") return false;
+		const type = getAttributeAnyPrefix(element, "Type");
+		const target = getAttributeAnyPrefix(element, "Target")?.replace(/^\.?\//u, "");
+		return type?.endsWith("/officeDocument") === true && target === "word/document.xml" && getAttributeAnyPrefix(element, "TargetMode") !== "External";
+	}) ?? false;
+};
+const hasDocumentRoot = (documentXml) => {
+	const root = parseXmlDocument(documentXml);
+	return root !== null && getLocalName(root.name ?? "") === "document" && findChildByLocalName(root, "body") !== null;
+};
+const validatePackageRoots = (xml, report) => {
+	const invalidParts = [];
+	if (!hasDocumentContentType(xml.contentTypesXml)) invalidParts.push("[Content_Types].xml");
+	if (!hasMainDocumentRelationship(xml.packageRelationshipsXml)) invalidParts.push("_rels/.rels");
+	if (!hasDocumentRoot(xml.documentXml)) invalidParts.push("word/document.xml");
+	if (invalidParts.length === 0) {
+		report.checks.set("package-roots", "passed");
+		return true;
+	}
+	report.checks.set("package-roots", "failed");
+	for (const part of invalidParts) addIssue(report, {
+		check: "package-roots",
+		code: "package-root-invalid",
+		message: "A required package part does not declare the expected root or main document binding.",
+		severity: "error",
+		part
+	});
+	return false;
+};
+const validateConformanceClass = (documentXml, report) => {
+	report.conformanceClass = detectDocxConformanceClass(documentXml);
+	if (report.conformanceClass !== DOCX_CONFORMANCE_CLASSES.UNKNOWN) {
+		report.checks.set("conformance-class", "passed");
+		return;
+	}
+	report.checks.set("conformance-class", "indeterminate");
+	addIssue(report, {
+		check: "conformance-class",
+		code: "conformance-class-unknown",
+		message: "The main document namespace does not identify a supported conformance class.",
+		severity: "warning",
+		part: "word/document.xml"
+	});
+};
+const findModelValidationError = (error) => {
+	let current = error;
+	while (current instanceof Error) {
+		if (current instanceof DocxModelValidationError) return current;
+		current = "cause" in current ? current.cause : void 0;
+	}
+	return null;
+};
+const validateCanonicalModel = async (bytes, report) => {
+	try {
+		const document = await parseDocx(bytes, {
+			detectVariables: false,
+			preloadFonts: false
+		});
+		const validation = validateFolioDocumentModel(document);
+		const warningCount = document.warnings?.length ?? 0;
+		if (!validation.valid) report.checks.set("canonical-model", "failed");
+		else if (warningCount > 0) {
+			report.checks.set("canonical-model", "indeterminate");
+			addIssue(report, {
+				check: "canonical-model",
+				code: "parser-recovery",
+				message: "The canonical parser reported recovery or preservation warnings.",
+				severity: "warning",
+				count: warningCount
+			});
+		} else report.checks.set("canonical-model", "passed");
+		for (const issue of validation.issues) addIssue(report, {
+			check: "canonical-model",
+			code: issue.severity === "error" ? "model-invalid" : "model-warning",
+			message: issue.message,
+			severity: issue.severity,
+			modelPath: issue.path
+		});
+	} catch (error) {
+		const modelError = findModelValidationError(error);
+		if (modelError !== null) {
+			report.checks.set("canonical-model", "failed");
+			for (const issue of modelError.issues) addIssue(report, {
+				check: "canonical-model",
+				code: issue.severity === "error" ? "model-invalid" : "model-warning",
+				message: issue.message,
+				severity: issue.severity,
+				modelPath: issue.path
+			});
+			return;
+		}
+		report.checks.set("canonical-model", "indeterminate");
+		addIssue(report, {
+			check: "canonical-model",
+			code: error instanceof DocxParseError ? "parser-unsupported" : "parser-failed",
+			message: "The canonical document model could not be assessed.",
+			severity: "warning"
+		});
+	}
+};
+/** Assess a DOCX package against Folio's named, versioned support profile. */
+const validateDocxConformance = async (bytes, options = {}) => {
+	const report = createMutableReport();
+	const containerType = detectDocxContainerType(bytes);
+	if (containerType === DOCX_CONTAINER_TYPES.CFB) {
+		report.checks.set("archive-safety", "indeterminate");
+		addIssue(report, {
+			check: "archive-safety",
+			code: "encrypted-container",
+			message: "Encrypted containers require decryption before this profile can assess them.",
+			severity: "warning"
+		});
+		return finishReport(report);
+	}
+	if (containerType !== DOCX_CONTAINER_TYPES.ZIP) {
+		report.checks.set("archive-safety", "failed");
+		addIssue(report, {
+			check: "archive-safety",
+			code: "container-not-zip",
+			message: "The input is not a supported DOCX package container.",
+			severity: "error"
+		});
+		return finishReport(report);
+	}
+	let archive;
+	try {
+		archive = await loadDocxArchive(bytes, options.archive);
+		report.checks.set("archive-safety", "passed");
+	} catch (error) {
+		report.checks.set("archive-safety", "failed");
+		addIssue(report, {
+			check: "archive-safety",
+			code: error instanceof DocxArchiveError ? `archive-${error.reason}` : "archive-load-failed",
+			message: "The DOCX package could not be loaded within the configured safety limits.",
+			severity: "error"
+		});
+		return finishReport(report);
+	}
+	if (!validateRequiredParts(archive, report)) return finishReport(report);
+	let xml;
+	try {
+		xml = await validateXmlParts(archive, report);
+	} catch (error) {
+		report.checks.set("xml-well-formedness", "indeterminate");
+		addIssue(report, {
+			check: "xml-well-formedness",
+			code: error instanceof DocxArchiveError ? `archive-${error.reason}` : "xml-read-failed",
+			message: "The XML package parts could not be read within the configured safety limits.",
+			severity: "warning"
+		});
+		return finishReport(report);
+	}
+	if (xml === null) return finishReport(report);
+	if (!validatePackageRoots(xml, report)) return finishReport(report);
+	validateConformanceClass(xml.documentXml, report);
+	await validateCanonicalModel(bytes, report);
+	return finishReport(report);
+};
+//#endregion
+export { FOLIO_DOCX_CONFORMANCE_CHECKS, FOLIO_DOCX_CONFORMANCE_ISSUE_CODES, FOLIO_DOCX_CONFORMANCE_PROFILE, FOLIO_DOCX_CONFORMANCE_REPORT_VERSION, validateDocxConformance };

package/dist/docx/settingsParser.js

@@ -1,4 +1,4 @@
-import { findChild, getAttribute, parseBooleanElement, parseXmlDocument } from "./xmlParser.js";
+import { findChild, findChildren, getAttribute, parseBooleanElement, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/settingsParser.ts
 /** OOXML default per §17.6.13 when `w:defaultTabStop` is absent. */
 const DEFAULT_TAB_STOP_TWIPS = 720;
@@ -35,6 +35,8 @@ function parseSettings(xml) {
 	const noLineBreaksBefore = parseKinsokuOverride(root, "noLineBreaksBefore");
 	const noLineBreaksAfter = parseKinsokuOverride(root, "noLineBreaksAfter");
 	const compat = root ? findChild(root, "w", "compat") : null;
+	const compatibilityMode = parseCompatibilityMode(compat);
+	if (compatibilityMode !== void 0) settings.compatibilityMode = compatibilityMode;
 	const splitPageBreakAndParagraphMark = compat ? findChild(compat, "w", "splitPgBreakAndParaMark") : null;
 	if (splitPageBreakAndParagraphMark && parseBooleanElement(splitPageBreakAndParagraphMark)) settings.splitPageBreakAndParagraphMark = true;
 	const applyBreakingRules = compat ? findChild(compat, "w", "applyBreakingRules") : null;
@@ -46,6 +48,14 @@ function parseSettings(xml) {
 	};
 	return settings;
 }
+function parseCompatibilityMode(compat) {
+	if (!compat) return;
+	const setting = findChildren(compat, "w", "compatSetting").find((candidate) => getAttribute(candidate, "w", "name") === "compatibilityMode");
+	const raw = setting ? getAttribute(setting, "w", "val") : null;
+	if (raw === null || !/^\d+$/u.test(raw)) return;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
 function parseOnOffSetting(root, name) {
 	if (!root) return;
 	const element = findChild(root, "w", name);

package/dist/docx/shapeParser.js

@@ -1,5 +1,5 @@
-import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, parseNumericAttribute } from "./xmlParser.js";
 import { ShapeOutlineStyleSchema, ShapeTypeSchema, narrowEnum } from "./parserEnums.js";
+import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, parseNumericAttribute } from "./xmlParser.js";
 import { parseAnchorPosition, parseAnchorWrap, parseColorElement, parseFill } from "./drawingUtils.js";
 //#region src/docx/shapeParser.ts
 /** Convert OOXML rotation (1/60000ths of a degree) to degrees. */

package/dist/docx/styleParser.js

@@ -1,8 +1,8 @@
-import { findChild, findChildren, getAttribute, getLocalName, parseBooleanElement, parseNumericAttribute, parseTableMeasurementValue, parseXmlDocument } from "./xmlParser.js";
 import { BorderStyleSchema, ConditionalStyleTypeSchema, EmphasisMarkSchema, FontThemeSchema, HighlightColorSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, StyleTypeSchema, TabLeaderSchema, TabStopAlignmentSchema, TableCellTextDirectionSchema, TableRowHeightRuleSchema, TableWidthTypeSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
-import { resolveThemeFontRef } from "./themeParser.js";
+import { findChild, findChildren, getAttribute, getLocalName, parseBooleanElement, parseNumericAttribute, parseTableMeasurementValue, parseXmlDocument } from "./xmlParser.js";
 import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
 import { mergeParagraphFormatting } from "../utils/paragraphFormattingMerge.js";
+import { resolveThemeFontRef } from "./themeParser.js";
 //#region src/docx/styleParser.ts
 /**
 * Parse text formatting properties (w:rPr)
@@ -263,6 +263,8 @@ function parseParagraphProperties(pPr, theme) {
 	}
 	const bidi = findChild(pPr, "w", "bidi");
 	if (bidi) formatting.bidi = parseBooleanElement(bidi);
+	const snapToGrid = findChild(pPr, "w", "snapToGrid");
+	if (snapToGrid) formatting.snapToGrid = parseBooleanElement(snapToGrid);
 	const spacing = findChild(pPr, "w", "spacing");
 	if (spacing) {
 		const before = parseNumericAttribute(spacing, "w", "before");

package/dist/docx/tableParser.js

@@ -1,6 +1,6 @@
+import { BorderStyleSchema, FloatingTableXSpecSchema, FloatingTableYSpecSchema, ShadingPatternSchema, TableCellTextDirectionSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
 import { findChild, findChildByLocalName, findChildren, getAttribute, getChildElements, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseTableMeasurementValue } from "./xmlParser.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
-import { BorderStyleSchema, FloatingTableXSpecSchema, FloatingTableYSpecSchema, ShadingPatternSchema, TableCellTextDirectionSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { appendBookmarkMarkerToLastParagraphInBlocks, appendBookmarkMarkerToLastParagraphInCells, prependBookmarkMarkersToFirstParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInCell } from "./bookmarkPlacement.js";
 import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
@@ -349,10 +349,20 @@ function parseTableCellStructuralChange(tcPrElement) {
 		info: parseTrackedChangeInfo(deletion)
 	};
 	const merge = findChild(tcPrElement, "w", "cellMerge");
-	if (merge) return {
-		type: "tableCellMerge",
-		info: parseTrackedChangeInfo(merge)
-	};
+	if (merge) {
+		const verticalMerge = parseTableCellVerticalMergeRevisionValue(getAttribute(merge, "w", "vMerge"));
+		const verticalMergeOriginal = parseTableCellVerticalMergeRevisionValue(getAttribute(merge, "w", "vMergeOrig"));
+		return {
+			type: "tableCellMerge",
+			info: parseTrackedChangeInfo(merge),
+			...verticalMerge !== void 0 ? { verticalMerge } : {},
+			...verticalMergeOriginal !== void 0 ? { verticalMergeOriginal } : {}
+		};
+	}
+}
+function parseTableCellVerticalMergeRevisionValue(value) {
+	if (value === "cont") return "continue";
+	if (value === "rest") return "rest";
 }
 /**
 * Parse table row properties (w:trPr)
@@ -482,7 +492,8 @@ function parseTableCellProperties(tcPrElement) {
 	else formatting.vMerge = "continue";
 	if (parseBooleanElement(findChild(tcPrElement, "w", "tcFitText"))) formatting.fitText = true;
 	if (parseBooleanElement(findChild(tcPrElement, "w", "noWrap"))) formatting.noWrap = true;
-	if (parseBooleanElement(findChild(tcPrElement, "w", "hideMark"))) formatting.hideMark = true;
+	const hideMark = parseBooleanElement(findChild(tcPrElement, "w", "hideMark"));
+	if (hideMark !== void 0) formatting.hideMark = hideMark;
 	const conditionalFormat = parseConditionalFormatStyle(findChild(tcPrElement, "w", "cnfStyle"));
 	if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
 	if (Object.keys(formatting).length === 0) return;
@@ -508,7 +519,7 @@ function parseCellContent(tcElement, styles, theme, numbering, rels, media, opti
 		const localName = getLocalName(child.name);
 		if (localName === "p") {
 			const para = parseParagraph(child, styles, theme, numbering, rels, media, options);
-			enrichParagraphTextBoxes(para, child, styles, theme, numbering, rels, media);
+			enrichParagraphTextBoxes(para, child, styles, theme, numbering, rels, media, parseTable);
 			prependPendingBookmarkMarkers(para, pendingBookmarkMarkers);
 			content.push(para);
 		} else if (localName === "tbl") {

package/dist/docx/textBoxParser.d.ts

@@ -15,16 +15,16 @@ declare function extractTextBoxContentElements(txbxContent: XmlElement | null):
 /**
  * Type for the paragraph parser function to avoid circular imports
  */
-type ParagraphParserFn = (node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null) => document_d_exports.Paragraph;
+type ParagraphParserFn = (node: 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) => document_d_exports.Paragraph;
 /**
  * Type for the table parser function to avoid circular imports
  */
-type TableParserFn = (node: 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>) => document_d_exports.Table;
+type TableParserFn = (node: 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) => document_d_exports.Table;
 /**
  * Parse text box content with provided parser functions
  * This avoids circular dependencies by accepting parser functions as parameters
  */
-declare function parseTextBoxContent(txbxContent: XmlElement | null, parseParagraph: ParagraphParserFn, parseTable: TableParserFn | null, 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>): document_d_exports.Paragraph[];
+declare function parseTextBoxContent(txbxContent: XmlElement | null, parseParagraph: ParagraphParserFn, parseTable: TableParserFn | null, 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): (document_d_exports.Paragraph | document_d_exports.Table)[];
 /**
  * Check if a drawing element contains a text box
  * Text boxes are shapes with wps:txbx content

package/dist/docx/textBoxParser.js

@@ -44,20 +44,20 @@ function extractTextBoxContentElements(txbxContent) {
 * Parse text box content with provided parser functions
 * This avoids circular dependencies by accepting parser functions as parameters
 */
-function parseTextBoxContent(txbxContent, parseParagraph, parseTable, styles, theme, numbering, rels, _media) {
+function parseTextBoxContent(txbxContent, parseParagraph, parseTable, styles, theme, numbering, rels, media) {
 	if (!txbxContent) return [];
-	const paragraphs = [];
+	const blocks = [];
 	const children = getChildElements(txbxContent);
 	for (const child of children) {
 		const name = child.name || "";
 		const colonIdx = name.indexOf(":");
 		const localName = colonIdx !== -1 ? name.slice(colonIdx + 1) : name;
 		if (localName === "p") {
-			const paragraph = parseParagraph(child, styles, theme, numbering, rels);
-			paragraphs.push(paragraph);
-		} else if (localName === "tbl" && parseTable) {}
+			const paragraph = parseParagraph(child, styles, theme, numbering, rels, media);
+			blocks.push(paragraph);
+		} else if (localName === "tbl" && parseTable) blocks.push(parseTable(child, styles, theme, numbering, rels, media));
 	}
-	return paragraphs;
+	return blocks;
 }
 /**
 * Check if a drawing element contains a text box
@@ -232,16 +232,20 @@ function hasTextBoxContent(textBox) {
 * Get plain text from text box (helper for search/indexing)
 */
 function getTextBoxText(textBox) {
-	const parts = [];
-	for (const paragraph of textBox.content) {
+	return textBox.content.map(getTextBoxBlockText).join("\n");
+}
+const getTextBoxBlockText = (block) => {
+	if (block.type === "paragraph") {
 		const runTexts = [];
-		for (const item of paragraph.content) if (item.type === "run") {
+		for (const item of block.content) {
+			if (item.type !== "run") continue;
 			for (const content of item.content) if (content.type === "text") runTexts.push(content.text);
 		}
-		parts.push(runTexts.join(""));
+		return runTexts.join("");
 	}
-	return parts.join("\n");
-}
+	if (block.type === "table") return block.rows.map((row) => row.cells.map((cell) => cell.content.map(getTextBoxBlockText).join("\n")).join("	")).join("\n");
+	return block.content.map(getTextBoxBlockText).join("\n");
+};
 /**
 * Resolve fill color to CSS color string
 */

package/dist/docx/xmlSafety.d.ts

@@ -0,0 +1,5 @@
+//#region src/docx/xmlSafety.d.ts
+type DocxXmlSafetyIssue = "doctype-forbidden" | "not-well-formed";
+declare const getDocxXmlSafetyIssue: (xml: string) => DocxXmlSafetyIssue | null;
+//#endregion
+export { DocxXmlSafetyIssue, getDocxXmlSafetyIssue };

package/dist/docx/xmlSafety.js

@@ -0,0 +1,9 @@
+import { XMLValidator } from "fast-xml-parser";
+//#region src/docx/xmlSafety.ts
+const DOCTYPE_PATTERN = /<!DOCTYPE(?:\s|>)/iu;
+const getDocxXmlSafetyIssue = (xml) => {
+	if (DOCTYPE_PATTERN.test(xml)) return "doctype-forbidden";
+	return XMLValidator.validate(xml) === true ? null : "not-well-formed";
+};
+//#endregion
+export { getDocxXmlSafetyIssue };

package/dist/fields/resolveFieldValues.js

@@ -196,9 +196,7 @@ function collectFieldRuns(block, out) {
 	if (block.kind === "paragraph") {
 		for (const run of block.runs) if (run.kind === "field") out.push(run);
 	} else if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) for (const cellBlock of cell.blocks) collectFieldRuns(cellBlock, out);
-	else if (block.kind === "textBox") {
-		for (const paragraph of block.content) for (const run of paragraph.runs) if (run.kind === "field") out.push(run);
-	}
+	else if (block.kind === "textBox") for (const child of block.content) collectFieldRuns(child, out);
 }
 //#endregion
 export { buildHeaderFooterFieldValues, fieldValuesEqual, resolveFieldValues };