@stll/folio-core 0.20.0 → 0.22.0

package/dist/docx/server/createBilingualDocument.js

@@ -0,0 +1,511 @@
+import { deterministicHexId } from "../../utils/hexId.js";
+import { getParagraphText } from "../paragraphParser.js";
+import { TaggedError } from "better-result";
+//#region src/docx/server/createBilingualDocument.ts
+/**
+* Bilingual document transform: body -> two-column table, one row per block.
+*
+* The left column keeps every source block untouched; the right column holds a
+* copy of the same block whose numbering and numbered paragraph styles are
+* cloned per language, so both columns count independently (1. / 1. instead of
+* 1. / 2.) and stay live in Word. Right-column paragraphs receive fresh
+* `paraId`s so callers can address each row later (for example to replace the
+* placeholder copy with a translation by block id).
+*
+* Section breaks cannot live inside a table cell, so the body is split at
+* paragraphs carrying `sectionProperties`: each section becomes its own table
+* and the break paragraph stays between the tables. A source table (parties,
+* signature block) is kept once, in a row spanning both columns: it is signed
+* and read once, and its labels are translated inline rather than duplicated.
+*/
+const STYLE_SUFFIX_PATTERN = /^[A-Za-z0-9-]+$/u;
+var InvalidBilingualDocumentOptionsError = class extends TaggedError("InvalidBilingualDocumentOptionsError")() {};
+const FULL_WIDTH_PCT = 5e3;
+const HALF_WIDTH_PCT = 2500;
+const A4_TEXT_WIDTH_TWIPS = 9072;
+const ROW_ID_NAMESPACE = "folio-bilingual";
+const GRID_BORDER = {
+	style: "single",
+	size: 4,
+	space: 0
+};
+const TABLE_BORDERS = {
+	none: {
+		top: { style: "nil" },
+		bottom: { style: "nil" },
+		left: { style: "nil" },
+		right: { style: "nil" },
+		insideH: { style: "nil" },
+		insideV: { style: "nil" }
+	},
+	grid: {
+		top: GRID_BORDER,
+		bottom: GRID_BORDER,
+		left: GRID_BORDER,
+		right: GRID_BORDER,
+		insideH: GRID_BORDER,
+		insideV: GRID_BORDER
+	}
+};
+function createBilingualDocument(source, options) {
+	if (!STYLE_SUFFIX_PATTERN.test(options.targetStyleSuffix)) throw new InvalidBilingualDocumentOptionsError({
+		message: `targetStyleSuffix must match ${STYLE_SUFFIX_PATTERN}; received ${JSON.stringify(options.targetStyleSuffix)}`,
+		option: "targetStyleSuffix"
+	});
+	const borders = options.borders ?? "none";
+	const warnings = [];
+	const styles = source.package.styles;
+	const numbering = source.package.numbering;
+	const styleById = new Map((styles?.styles ?? []).map((style) => [style.styleId, style]));
+	const blocks = flattenBlocks(source.package.document.content);
+	const cloner = createNumberingCloner({
+		numbering,
+		styleById,
+		warnings
+	});
+	const styleCloner = createStyleCloner({
+		styleById,
+		suffix: options.targetStyleSuffix,
+		cloner
+	});
+	const paraIds = createParaIdMinter(collectPackageParaIds(source.package));
+	const rows = [];
+	const content = [];
+	let sectionRows = [];
+	const textWidth = resolveTextWidthTwips(source);
+	const flushSection = () => {
+		if (sectionRows.length > 0) content.push(buildTable(sectionRows, borders, textWidth));
+		sectionRows = [];
+	};
+	const copyParagraph = (paragraph) => {
+		const targetParaId = paraIds.mint(paragraph.paraId);
+		return {
+			copy: cloneParagraphForTarget(paragraph, targetParaId, styleCloner, cloner),
+			ref: {
+				sourceParaId: paragraph.paraId,
+				targetParaId,
+				sourceText: getParagraphText(paragraph)
+			}
+		};
+	};
+	for (const block of blocks) {
+		if (block.type === "paragraph" && block.sectionProperties) {
+			flushSection();
+			content.push(block);
+			continue;
+		}
+		if (block.type === "paragraph") {
+			if (isEmptyParagraph(block)) continue;
+			const { copy, ref } = copyParagraph(block);
+			rows.push({
+				kind: classifyParagraph(block, styleById),
+				rowId: ref.targetParaId,
+				...ref
+			});
+			sectionRows.push(buildRow(block, copy));
+			continue;
+		}
+		const paragraphs = collectTableParagraphs(block).map((paragraph) => ({
+			paraId: paragraph.paraId,
+			sourceText: getParagraphText(paragraph)
+		}));
+		rows.push({
+			kind: "table",
+			rowId: paragraphs.at(0)?.paraId ?? tableRowHandle(rows.length),
+			paragraphs
+		});
+		sectionRows.push(buildSpanningRow(block));
+	}
+	flushSection();
+	return {
+		document: {
+			...source,
+			package: {
+				...source.package,
+				document: {
+					...source.package.document,
+					content
+				},
+				...cloner.hasClones() && { numbering: cloner.toDefinitions() },
+				...styleCloner.hasClones() && styles && { styles: styleCloner.toDefinitions(styles) }
+			}
+		},
+		rows,
+		warnings
+	};
+}
+/** Handle for a table row whose paragraphs carry no `paraId`: its position in
+*  the manifest, which creation and reading derive identically. */
+const tableRowHandle = (index) => `table-${index}`;
+/** Top-level body blocks with content controls flattened to their children. */
+const flattenBlocks = (content) => {
+	const out = [];
+	const visit = (block) => {
+		if (block.type === "paragraph" || block.type === "table") {
+			out.push(block);
+			return;
+		}
+		for (const child of block.content) visit(child);
+	};
+	for (const block of content) visit(block);
+	return out;
+};
+const isEmptyParagraph = (paragraph) => {
+	if (getParagraphText(paragraph).trim().length > 0) return false;
+	return paragraph.content.every((item) => item.type === "run" && item.content.every((part) => part.type === "text"));
+};
+/** Heading style families across Word UI languages (en, cs/sk, de, fr, pl). */
+const HEADING_STYLE_PATTERN = /heading|nadpis|berschrift|titre|nag[łl]/iu;
+const classifyParagraph = (paragraph, styleById) => {
+	const formatting = paragraph.formatting;
+	const style = formatting?.styleId ? styleById.get(formatting.styleId) : void 0;
+	const outlineLevel = formatting?.outlineLevel ?? resolveInheritedOutlineLevel(style, styleById);
+	if (outlineLevel !== void 0 && outlineLevel < 9) return "heading";
+	if (style && (HEADING_STYLE_PATTERN.test(style.styleId) || HEADING_STYLE_PATTERN.test(style.name ?? ""))) return "heading";
+	if (effectiveNumPr(paragraph, styleById) !== void 0) return "listItem";
+	return "paragraph";
+};
+const resolveInheritedOutlineLevel = (style, styleById) => {
+	const seen = /* @__PURE__ */ new Set();
+	let current = style;
+	while (current && !seen.has(current.styleId)) {
+		seen.add(current.styleId);
+		if (current.pPr?.outlineLevel !== void 0) return current.pPr.outlineLevel;
+		current = current.basedOn ? styleById.get(current.basedOn) : void 0;
+	}
+};
+/** The numbering a paragraph renders with: direct `numPr`, else the style chain's. */
+const effectiveNumPr = (paragraph, styleById) => {
+	const direct = paragraph.formatting?.numPr;
+	if (direct?.numId !== void 0) return direct.numId === 0 ? void 0 : direct;
+	const styleId = paragraph.formatting?.styleId;
+	return styleId ? styleNumPr(styleById.get(styleId), styleById) : void 0;
+};
+const styleNumPr = (style, styleById) => {
+	const seen = /* @__PURE__ */ new Set();
+	let current = style;
+	while (current && !seen.has(current.styleId)) {
+		seen.add(current.styleId);
+		const numPr = current.pPr?.numPr;
+		if (numPr?.numId !== void 0) return numPr.numId === 0 ? void 0 : numPr;
+		current = current.basedOn ? styleById.get(current.basedOn) : void 0;
+	}
+};
+const createNumberingCloner = ({ numbering, styleById, warnings }) => {
+	const abstractNums = numbering?.abstractNums ?? [];
+	const nums = numbering?.nums ?? [];
+	const abstractById = new Map(abstractNums.map((item) => [item.abstractNumId, item]));
+	const numById = new Map(nums.map((item) => [item.numId, item]));
+	let nextAbstractNumId = Math.max(0, ...abstractNums.map((item) => item.abstractNumId)) + 1;
+	let nextNumId = Math.max(0, ...nums.map((item) => item.numId)) + 1;
+	const clonedAbstract = /* @__PURE__ */ new Map();
+	const clonedNum = /* @__PURE__ */ new Map();
+	/**
+	* Word keys list counters by the abstract definition a `w:num` points at;
+	* two instances sharing one abstract continue the same sequence. A clone
+	* therefore needs its own abstract, and an abstract that only links to a
+	* numbering style must be materialized from that style's levels, otherwise
+	* both clones resolve to the same linked definition and share counters.
+	*/
+	const cloneAbstract = (sourceId) => {
+		const existing = clonedAbstract.get(sourceId);
+		if (existing) return existing;
+		const source = abstractById.get(sourceId);
+		if (!source) return;
+		const resolved = resolveLinkedAbstract(source);
+		const { numStyleLink: _numStyleLink, styleLink: _styleLink, ...rest } = resolved;
+		const clone = {
+			...rest,
+			abstractNumId: nextAbstractNumId,
+			levels: structuredClone(resolved.levels)
+		};
+		nextAbstractNumId += 1;
+		clonedAbstract.set(sourceId, clone);
+		return clone;
+	};
+	const resolveLinkedAbstract = (abstract) => {
+		const seen = /* @__PURE__ */ new Set();
+		let current = abstract;
+		while (current.numStyleLink && !seen.has(current.abstractNumId)) {
+			seen.add(current.abstractNumId);
+			const linkedNumId = styleById.get(current.numStyleLink)?.pPr?.numPr?.numId;
+			const linkedNum = linkedNumId === void 0 ? void 0 : numById.get(linkedNumId);
+			const linkedAbstract = linkedNum ? abstractById.get(linkedNum.abstractNumId) : void 0;
+			if (!linkedAbstract) {
+				warnings.push(`Numbering style link "${current.numStyleLink}" on abstractNum ${current.abstractNumId} could not be resolved; the clone keeps the link.`);
+				return current;
+			}
+			current = linkedAbstract;
+		}
+		return current;
+	};
+	const cloneNumId = (numId) => {
+		const existing = clonedNum.get(numId);
+		if (existing) return existing.numId;
+		const source = numById.get(numId);
+		if (!source) {
+			warnings.push(`Numbering instance ${numId} is not defined; paragraphs using it keep the source instance.`);
+			return numId;
+		}
+		const abstract = cloneAbstract(source.abstractNumId);
+		if (!abstract) warnings.push(`Numbering instance ${numId} references abstractNum ${source.abstractNumId}, which is not defined; its copy shares the source counters.`);
+		const clone = {
+			...source,
+			numId: nextNumId,
+			abstractNumId: abstract ? abstract.abstractNumId : source.abstractNumId
+		};
+		nextNumId += 1;
+		clonedNum.set(numId, clone);
+		return clone.numId;
+	};
+	return {
+		cloneNumId,
+		clonedAbstractNumId: (abstractNumId) => clonedAbstract.get(abstractNumId)?.abstractNumId,
+		hasClones: () => clonedNum.size > 0,
+		toDefinitions: () => ({
+			abstractNums: [...abstractNums, ...clonedAbstract.values()],
+			nums: [...nums, ...clonedNum.values()]
+		})
+	};
+};
+/**
+* A paragraph style is cloned only when its chain carries numbering. The clone
+* keeps `basedOn` and every other property; only `pPr.numPr` is rewritten to
+* the cloned instance, so indent precedence stays "style-sourced" exactly as
+* in the source (see `ParagraphFormatting.numPrFromStyle`).
+*/
+const createStyleCloner = ({ styleById, suffix, cloner }) => {
+	const clones = /* @__PURE__ */ new Map();
+	const styleIdFor = (styleId) => {
+		const existing = clones.get(styleId);
+		if (existing) return existing.styleId;
+		const style = styleById.get(styleId);
+		if (!style || style.type !== "paragraph") return styleId;
+		const numPr = styleNumPr(style, styleById);
+		if (numPr?.numId === void 0) return styleId;
+		const cloneId = `${styleId}-${suffix}`;
+		if (styleById.has(cloneId)) return cloneId;
+		const clone = {
+			...style,
+			styleId: cloneId,
+			name: `${style.name ?? style.styleId} (${suffix})`,
+			...style.next !== void 0 && { next: style.next === styleId ? cloneId : style.next },
+			default: false,
+			pPr: {
+				...style.pPr,
+				numPr: {
+					...numPr,
+					numId: cloner.cloneNumId(numPr.numId)
+				}
+			}
+		};
+		clones.set(styleId, clone);
+		return cloneId;
+	};
+	return {
+		styleIdFor,
+		hasClones: () => clones.size > 0,
+		toDefinitions: (styles) => ({
+			...styles,
+			styles: [...styles.styles, ...clones.values()]
+		})
+	};
+};
+const cloneParagraphForTarget = (paragraph, targetParaId, styleCloner, cloner) => {
+	const { textId: _textId, sectionProperties: _sectionProperties, ...rest } = paragraph;
+	const formatting = paragraph.formatting;
+	const nextFormatting = formatting && {
+		...formatting,
+		...formatting.styleId !== void 0 && { styleId: styleCloner.styleIdFor(formatting.styleId) },
+		...formatting.numPr?.numId !== void 0 && formatting.numPr.numId !== 0 && { numPr: {
+			...formatting.numPr,
+			numId: cloner.cloneNumId(formatting.numPr.numId)
+		} },
+		...formatting.numPrFromStyle?.numId !== void 0 && formatting.numPrFromStyle.numId !== 0 && { numPrFromStyle: {
+			...formatting.numPrFromStyle,
+			numId: cloner.cloneNumId(formatting.numPrFromStyle.numId)
+		} }
+	};
+	return {
+		...rest,
+		content: structuredClone(paragraph.content),
+		paraId: targetParaId,
+		...nextFormatting && { formatting: nextFormatting },
+		...paragraph.listRendering && { listRendering: remapListRendering(paragraph.listRendering, cloner) }
+	};
+};
+const remapListRendering = (rendering, cloner) => {
+	const clonedAbstract = rendering.abstractNumId === void 0 ? void 0 : cloner.clonedAbstractNumId(rendering.abstractNumId);
+	return {
+		...rendering,
+		numId: cloner.cloneNumId(rendering.numId),
+		...clonedAbstract !== void 0 && { abstractNumId: clonedAbstract }
+	};
+};
+const collectTableParagraphs = (table) => {
+	const out = [];
+	for (const row of table.rows) for (const cell of row.cells) for (const item of cell.content) if (item.type === "paragraph") out.push(item);
+	else out.push(...collectTableParagraphs(item));
+	return out;
+};
+const buildRow = (left, right) => ({
+	type: "tableRow",
+	formatting: { cantSplit: true },
+	cells: [buildCell(left), buildCell(right)]
+});
+const buildCell = (paragraph) => ({
+	type: "tableCell",
+	formatting: {
+		width: {
+			value: HALF_WIDTH_PCT,
+			type: "pct"
+		},
+		verticalAlign: "top"
+	},
+	content: [paragraph]
+});
+/** A source table kept once, across both columns. */
+const buildSpanningRow = (table) => ({
+	type: "tableRow",
+	formatting: { cantSplit: true },
+	cells: [{
+		type: "tableCell",
+		formatting: {
+			width: {
+				value: FULL_WIDTH_PCT,
+				type: "pct"
+			},
+			gridSpan: 2,
+			verticalAlign: "top"
+		},
+		content: [table, {
+			type: "paragraph",
+			content: []
+		}]
+	}]
+});
+const buildTable = (rows, borders, textWidth) => ({
+	type: "table",
+	formatting: {
+		width: {
+			value: FULL_WIDTH_PCT,
+			type: "pct"
+		},
+		layout: "fixed",
+		borders: TABLE_BORDERS[borders],
+		look: {
+			firstRow: false,
+			firstColumn: false,
+			noHBand: true,
+			noVBand: true
+		}
+	},
+	columnWidths: [Math.floor(textWidth / 2), Math.ceil(textWidth / 2)],
+	rows
+});
+const resolveTextWidthTwips = (doc) => {
+	const section = doc.package.document.finalSectionProperties ?? doc.package.document.sections?.at(0)?.properties;
+	if (!section?.pageWidth) return A4_TEXT_WIDTH_TWIPS;
+	const width = section.pageWidth - (section.marginLeft ?? 0) - (section.marginRight ?? 0);
+	return width > 0 ? width : A4_TEXT_WIDTH_TWIPS;
+};
+/**
+* Every `paraId` anywhere in the package (body, headers, footers, notes,
+* comments), so a minted id cannot collide with a part the body never sees.
+* Walks the model generically: any object with `type: "paragraph"` and a
+* string `paraId` counts.
+*/
+const collectPackageParaIds = (pkg) => {
+	const ids = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (typeof value !== "object" || value === null || seen.has(value)) return;
+		seen.add(value);
+		if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return;
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		if (value instanceof Map) {
+			for (const item of value.values()) visit(item);
+			return;
+		}
+		if (isParagraphWithId(value)) ids.add(value.paraId);
+		for (const child of Object.values(value)) visit(child);
+	};
+	visit(pkg);
+	return ids;
+};
+/**
+* Fresh ids derived from the source id (so re-running on the same source
+* yields the same handles), salted past any id already in the document.
+*/
+const createParaIdMinter = (taken) => {
+	let ordinal = 0;
+	return { mint: (sourceParaId) => {
+		ordinal += 1;
+		const seed = `${ROW_ID_NAMESPACE}:${sourceParaId ?? `ordinal-${ordinal}`}`;
+		let id = deterministicHexId(seed);
+		for (let salt = 1; taken.has(id); salt += 1) id = deterministicHexId(`${seed}:${salt}`);
+		taken.add(id);
+		return id;
+	} };
+};
+/**
+* Re-derive the row manifest from a document produced by
+* {@link createBilingualDocument}. Detection is structural: a top-level table
+* whose rows are all either a left | right pair of single-paragraph cells or
+* one cell spanning both columns. Rows are returned in document order; the
+* right paragraph's `paraId` is the row handle, as at creation.
+*/
+function readBilingualDocument(document) {
+	const styleById = new Map((document.package.styles?.styles ?? []).map((style) => [style.styleId, style]));
+	const rows = [];
+	for (const block of flattenBlocks(document.package.document.content)) {
+		if (block.type !== "table" || !isBilingualTable(block)) continue;
+		for (const row of block.rows) {
+			const [left, right] = row.cells;
+			if (!left) continue;
+			if (!right) {
+				const paragraphs = left.content.filter((item) => item.type === "table").flatMap(collectTableParagraphs).map((paragraph) => ({
+					paraId: paragraph.paraId,
+					sourceText: getParagraphText(paragraph)
+				}));
+				rows.push({
+					kind: "table",
+					rowId: paragraphs.at(0)?.paraId ?? tableRowHandle(rows.length),
+					paragraphs
+				});
+				continue;
+			}
+			const source = left.content.at(0);
+			const target = right.content.at(0);
+			if (source?.type !== "paragraph" || target?.type !== "paragraph" || !target.paraId) continue;
+			rows.push({
+				kind: classifyParagraph(source, styleById),
+				rowId: target.paraId,
+				sourceParaId: source.paraId,
+				targetParaId: target.paraId,
+				sourceText: getParagraphText(source)
+			});
+		}
+	}
+	return rows;
+}
+const isBilingualTable = (table) => {
+	let pairs = 0;
+	for (const row of table.rows) {
+		const cells = row.cells;
+		if (cells.length === 2) {
+			if (!cells.every((cell) => cell.content.length === 1 && cell.content[0]?.type === "paragraph")) return false;
+			pairs += 1;
+			continue;
+		}
+		if (cells.length === 1 && cells[0]?.formatting?.gridSpan === 2) continue;
+		return false;
+	}
+	return pairs > 0;
+};
+const isParagraphWithId = (value) => "type" in value && value.type === "paragraph" && "paraId" in value && typeof value.paraId === "string";
+//#endregion
+export { InvalidBilingualDocumentOptionsError, createBilingualDocument, readBilingualDocument };

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

@@ -0,0 +1,19 @@
+import { BilingualRow, CreateBilingualDocumentOptions } from "./createBilingualDocument.js";
+//#region src/docx/server/createBilingualDocx.d.ts
+type CreateBilingualDocxResult = {
+  buffer: ArrayBuffer;
+  rows: BilingualRow[];
+  warnings: string[];
+};
+/**
+ * Bytes-in / bytes-out form of {@link createBilingualDocument}: stamp every
+ * paragraph with a `paraId` (so left-column rows are addressable later), parse
+ * the DOCX (no font preloading, so it never touches the DOM), lay the body out
+ * as a two-column table, and repack onto the original package so theme, fonts,
+ * media, headers and footers carry over untouched.
+ */
+declare function createBilingualDocx(input: ArrayBuffer | Uint8Array, options: CreateBilingualDocumentOptions): Promise<CreateBilingualDocxResult>;
+/** Bytes-in form of {@link readBilingualDocument}. */
+declare function readBilingualDocx(input: ArrayBuffer | Uint8Array): Promise<BilingualRow[]>;
+//#endregion
+export { CreateBilingualDocxResult, createBilingualDocx, readBilingualDocx };

package/dist/docx/server/createBilingualDocx.js

@@ -0,0 +1,26 @@
+import { ensureParaIds } from "../ensureParaIds.js";
+import { parseDocx } from "../parser.js";
+import { createDocx } from "../rezip.js";
+import { createBilingualDocument, readBilingualDocument } from "./createBilingualDocument.js";
+//#region src/docx/server/createBilingualDocx.ts
+/**
+* Bytes-in / bytes-out form of {@link createBilingualDocument}: stamp every
+* paragraph with a `paraId` (so left-column rows are addressable later), parse
+* the DOCX (no font preloading, so it never touches the DOM), lay the body out
+* as a two-column table, and repack onto the original package so theme, fonts,
+* media, headers and footers carry over untouched.
+*/
+async function createBilingualDocx(input, options) {
+	const { document, rows, warnings } = createBilingualDocument(await parseDocx((await ensureParaIds(input)).docx, { preloadFonts: false }), options);
+	return {
+		buffer: await createDocx(document),
+		rows,
+		warnings
+	};
+}
+/** Bytes-in form of {@link readBilingualDocument}. */
+async function readBilingualDocx(input) {
+	return readBilingualDocument(await parseDocx(input, { preloadFonts: false }));
+}
+//#endregion
+export { createBilingualDocx, readBilingualDocx };

package/dist/docx/settingsParser.js

@@ -1,4 +1,4 @@
-import { findChild, findChildren, getAttribute, parseBooleanElement, parseXmlDocument } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByNamespaceUri, 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;
@@ -26,10 +26,13 @@ const MAX_KINSOKU_CHARACTERS_LENGTH = 128;
 function parseSettings(xml) {
 	const root = xml ? parseXmlDocument(xml) : null;
 	const settings = { defaultTabStop: parseDefaultTabStop(root) };
-	const evenAndOddHeaders = root ? findChild(root, "w", "evenAndOddHeaders") : null;
-	if (evenAndOddHeaders && parseBooleanElement(evenAndOddHeaders)) settings.evenAndOddHeaders = true;
-	const mirrorMargins = root ? findChild(root, "w", "mirrorMargins") : null;
-	if (mirrorMargins && parseBooleanElement(mirrorMargins)) settings.mirrorMargins = true;
+	const wordprocessingFlag = (localName) => {
+		const element = findChildByNamespaceUri(root, WORDPROCESSINGML_NAMESPACE_URIS, localName);
+		return element !== null && parseBooleanElement(element);
+	};
+	if (wordprocessingFlag("evenAndOddHeaders")) settings.evenAndOddHeaders = true;
+	if (wordprocessingFlag("mirrorMargins")) settings.mirrorMargins = true;
+	if (wordprocessingFlag("updateFields")) settings.updateFields = true;
 	const themeFontLangEl = root ? findChild(root, "w", "themeFontLang") : null;
 	const eastAsiaLang = themeFontLangEl ? getAttribute(themeFontLangEl, "w", "eastAsia") || void 0 : void 0;
 	const bidiLang = themeFontLangEl ? getAttribute(themeFontLangEl, "w", "bidi") || void 0 : void 0;

package/dist/docx/xmlParser.d.ts

@@ -96,6 +96,14 @@ declare function getLocalName(name: string | undefined): string;
 declare function getNamespacePrefix(name: string): string | null;
 /** Namespace URI resolved from the element's in-scope XML declarations. */
 declare const getNamespaceUri: (element: XmlElement) => string | undefined;
+/** WordprocessingML main namespace, Transitional and Strict (ECMA-376 Parts 1 and 4). */
+declare const WORDPROCESSINGML_NAMESPACE_URIS: ReadonlySet<string>;
+/**
+ * First child whose local name matches AND whose resolved namespace URI is
+ * one of `namespaceUris`. Unlike {@link findChild}, a same-named element
+ * from a foreign namespace is not accepted.
+ */
+declare function findChildByNamespaceUri(parent: XmlElement | null | undefined, namespaceUris: ReadonlySet<string>, localName: string): XmlElement | null;
 /** Get an attribute whose prefix resolves to one of the accepted namespace URIs. */
 declare function getAttributeByNamespaceUri(element: XmlElement | null | undefined, namespaceUris: ReadonlySet<string>, localName: string): string | null;
 /**
@@ -326,4 +334,4 @@ declare function mergeXmlnsDeclarations(inherited: Record<string, string>, eleme
  */
 declare function cloneWithXmlnsDeclarations(element: XmlElement, xmlnsDecls: Record<string, string>): XmlElement;
 //#endregion
-export { NAMESPACES, XmlElement, XmlNamespaceScope, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXml, parseXmlDocument };
+export { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, XmlElement, XmlNamespaceScope, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXml, parseXmlDocument };

package/dist/docx/xmlParser.js

@@ -196,6 +196,18 @@ function getNamespacePrefix(name) {
 }
 /** Namespace URI resolved from the element's in-scope XML declarations. */
 const getNamespaceUri = (element) => element.namespaceUri;
+/** WordprocessingML main namespace, Transitional and Strict (ECMA-376 Parts 1 and 4). */
+const WORDPROCESSINGML_NAMESPACE_URIS = /* @__PURE__ */ new Set([NAMESPACES.w, "http://purl.oclc.org/ooxml/wordprocessingml/main"]);
+/**
+* First child whose local name matches AND whose resolved namespace URI is
+* one of `namespaceUris`. Unlike {@link findChild}, a same-named element
+* from a foreign namespace is not accepted.
+*/
+function findChildByNamespaceUri(parent, namespaceUris, localName) {
+	if (!parent?.elements) return null;
+	for (const child of parent.elements) if (child.type === "element" && hasLocalName(child.name, localName) && namespaceUris.has(child.namespaceUri ?? "")) return child;
+	return null;
+}
 /** Get an attribute whose prefix resolves to one of the accepted namespace URIs. */
 function getAttributeByNamespaceUri(element, namespaceUris, localName) {
 	if (!element?.attributes) return null;
@@ -687,4 +699,4 @@ function cloneWithXmlnsDeclarations(element, xmlnsDecls) {
 	return element;
 }
 //#endregion
-export { NAMESPACES, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXml, parseXmlDocument };
+export { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXml, parseXmlDocument };