@stll/folio-core 0.20.0 → 0.22.0

package/dist/docx/paragraphParser.js

@@ -712,14 +712,16 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 				const run = parseRun(runElement, styles, theme, rels, media, inScopeXmlns);
 				const commentReferenceId = getCommentReferenceId(runElement);
 				let hasFieldBegin = false;
+				let beginFldLock = false;
+				let beginDirty = false;
 				let hasFieldSeparate = false;
 				let hasFieldEnd = false;
 				let endOriginalValue;
 				let instrText = "";
 				for (const content of run.content) if (content.type === "fieldChar") if (content.charType === "begin") {
 					hasFieldBegin = true;
-					if (content.fldLock) complexFieldLock = true;
-					if (content.dirty) complexFieldDirty = true;
+					beginFldLock = content.fldLock === true;
+					beginDirty = content.dirty === true;
 				} else if (content.charType === "separate") hasFieldSeparate = true;
 				else {
 					hasFieldEnd = true;
@@ -736,8 +738,8 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 					complexFieldInstr = "";
 					complexFieldCodeRuns = [];
 					complexFieldResultRuns = [];
-					complexFieldLock = false;
-					complexFieldDirty = false;
+					complexFieldLock = beginFldLock;
+					complexFieldDirty = beginDirty;
 					complexFieldFormatting = run.formatting;
 				}
 				if (inComplexField) {

package/dist/docx/parser.js

@@ -371,8 +371,12 @@ function parseHeadersAndFooters(raw, styles, theme, numbering, rels, media) {
 * Parse footnotes and endnotes from raw content
 */
 function parseNotesContent(raw, styles, theme, numbering, rels, media) {
-	const footnoteMap = parseFootnotes(raw.footnotesXml, styles, theme, numbering, rels, media);
-	const endnoteMap = parseEndnotes(raw.endnotesXml, styles, theme, numbering, rels, media);
+	const relsForNotePart = (partPath) => {
+		const xml = getMapCaseInsensitive(raw.allXml, getRelationshipsPathForPart(partPath));
+		return xml ? parseRelationships(xml) : rels;
+	};
+	const footnoteMap = parseFootnotes(raw.footnotesXml, styles, theme, numbering, relsForNotePart("word/footnotes.xml"), media);
+	const endnoteMap = parseEndnotes(raw.endnotesXml, styles, theme, numbering, relsForNotePart("word/endnotes.xml"), media);
 	return {
 		footnotes: footnoteMap.getNormalFootnotes(),
 		endnotes: endnoteMap.getNormalEndnotes()

package/dist/docx/rezip.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../types/document.js";
+import { BlockContent, Hyperlink } from "../types/content.js";
 import { RawDocxContent } from "./unzip.js";
 import JSZip from "jszip";
 //#region src/docx/rezip.d.ts
@@ -9,6 +10,11 @@ declare class DocxPackageFidelityError extends Error {
  * Find the highest rId number in a relationships XML string.
  */
 declare function findMaxRId(relsXml: string): number;
+/**
+ * Collect all hyperlinks that have an href but no rId from block content.
+ * These are newly created hyperlinks that need relationship entries.
+ */
+declare function collectHyperlinksWithoutRId(blocks: BlockContent[]): Hyperlink[];
 /**
  * Options for repacking DOCX
  */
@@ -126,6 +132,8 @@ declare function hasUnmaterializedHeaderFooter(doc: document_d_exports.Document)
  */
 declare function hasModelDrivenPictureWatermark(doc: document_d_exports.Document): boolean;
 declare function collectHeaderFooterUpdates(doc: document_d_exports.Document): Map<string, string>;
+/** `word/Footnotes.xml` -> `word/_rels/Footnotes.xml.rels` (casing preserved). */
+declare function notePartRelsPath(partPath: string): string;
 /** Update existing core-property values without synthesizing absent metadata. */
 declare function updateCoreProperties(corePropsXml: string, { updateModifiedDate, modifiedBy }: {
   updateModifiedDate?: boolean;
@@ -163,4 +171,4 @@ declare function createEmptyDocx(): Promise<ArrayBuffer>;
  */
 declare function createDocx(doc: document_d_exports.Document): Promise<ArrayBuffer>;
 //#endregion
-export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, DocxPackageFidelityError, RepackOptions, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, isDocxBuffer, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx };
+export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, DocxPackageFidelityError, RepackOptions, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, collectHyperlinksWithoutRId, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, isDocxBuffer, notePartRelsPath, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx };

package/dist/docx/rezip.js

@@ -6,7 +6,7 @@ import { assertValidFolioDocumentModel } from "./modelValidation.js";
 import { isNewDataUrlDrawing } from "./newImage.js";
 import { parseNumbering } from "./numberingParser.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
-import { buildParagraphOffsetIndex, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds } from "./selectiveXmlPatch.js";
+import { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNumberingDefs, collectParaIds } from "./selectiveXmlPatch.js";
 import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
@@ -14,11 +14,11 @@ import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
 import { serializeEndnotes, serializeFootnotes, serializeNewEndnotesPart, serializeNewFootnotesPart } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { serializeSettingsXml } from "./serializer/settingsSerializer.js";
-import { serializeStylesXml } from "./serializer/stylesSerializer.js";
+import { serializeStyle, serializeStylesXml } from "./serializer/stylesSerializer.js";
 import { serializeThemeXml } from "./serializer/themeSerializer.js";
 import { escapeXml } from "./serializer/xmlUtils.js";
 import { isPreservableDocxEntry } from "./unzip.js";
-import { findChild, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml } from "./xmlParser.js";
 import { assertXmlResourceLimits } from "./xmlResourceLimits.js";
 import { panic } from "better-result";
 import JSZip from "jszip";
@@ -70,8 +70,7 @@ function findMaxRId(relsXml) {
 	}
 	return maxId;
 }
-const WORDPROCESSINGML_NAMESPACES = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/wordprocessingml/2006/main", "http://purl.oclc.org/ooxml/wordprocessingml/main"]);
-const isWordprocessingElement = (element, localName) => getLocalName(element.name) === localName && WORDPROCESSINGML_NAMESPACES.has(getNamespaceUri(element) ?? "");
+const isWordprocessingElement = (element, localName) => getLocalName(element.name) === localName && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "");
 const countDocumentSections = (xml) => {
 	assertXmlResourceLimits(xml);
 	let count = 0;
@@ -212,15 +211,22 @@ function relativeTargetForPart(partPath, absoluteTarget) {
 	while (shared < fromDir.length && shared < to.length - 1 && fromDir[shared] === to[shared]) shared += 1;
 	return `${"../".repeat(fromDir.length - shared)}${to.slice(shared).join("/")}`;
 }
-function collectImageParts(doc) {
+/**
+* Every package part whose block content may mint relationships (images,
+* external hyperlinks), paired with the rels part those relationships belong
+* to. Header/footer parts own `word/_rels/<part>.rels`; footnotes and endnotes
+* own `word/_rels/<notes part>.rels`, derived from the ZIP entry the note
+* serializer resolves (case-insensitively) so a producer's casing is reused
+* instead of minting a second, lowercase rels part.
+*/
+function collectDocxParts(doc, zip) {
 	const parts = [{
 		relsPath: "word/_rels/document.xml.rels",
 		blocks: doc.package.document.content
 	}];
 	const rels = doc.package.relationships;
-	if (!rels) return parts;
 	const addHeaderFooterParts = (map, type) => {
-		if (!map) return;
+		if (!map || !rels) return;
 		for (const [rId, headerFooter] of map.entries()) {
 			const rel = rels.get(rId);
 			if (!rel || rel.type !== type || !rel.target) continue;
@@ -232,6 +238,16 @@ function collectImageParts(doc) {
 	};
 	addHeaderFooterParts(doc.package.headers, RELATIONSHIP_TYPES.header);
 	addHeaderFooterParts(doc.package.footers, RELATIONSHIP_TYPES.footer);
+	const addNoteParts = (notes, conventionalLowerPath) => {
+		if (!notes || notes.length === 0) return;
+		const partPath = findNotePartEntry(zip, conventionalLowerPath)?.name ?? conventionalLowerPath;
+		parts.push({
+			relsPath: notePartRelsPath(partPath),
+			blocks: notes.flatMap((note) => note.content)
+		});
+	};
+	addNoteParts(doc.package.footnotes, "word/footnotes.xml");
+	addNoteParts(doc.package.endnotes, "word/endnotes.xml");
 	return parts;
 }
 async function readRelsOrStub(zip, relsPath) {
@@ -360,30 +376,29 @@ function collectHyperlinksWithoutRId(blocks) {
 	for (const block of blocks) if (block.type === "paragraph") {
 		for (const item of block.content) if (item.type === "hyperlink" && item.href && !item.rId && !item.anchor) hyperlinks.push(item);
 	} else if (block.type === "table") for (const row of block.rows) for (const cell of row.cells) hyperlinks.push(...collectHyperlinksWithoutRId(cell.content));
+	else hyperlinks.push(...collectHyperlinksWithoutRId(block.content));
 	return hyperlinks;
 }
 /**
-* Process newly created hyperlinks: assign rIds and add relationship entries.
-* Mutates the hyperlinks' rId fields in-place.
+* Process newly created hyperlinks in every part: assign rIds and add
+* relationship entries to the owning part's rels. Mutates the hyperlinks' rId
+* fields in-place.
 */
-async function processNewHyperlinks(newHyperlinks, zip, compressionLevel) {
-	if (newHyperlinks.length === 0) return;
-	const relsPath = "word/_rels/document.xml.rels";
-	const relsFile = zip.file(relsPath);
-	if (!relsFile) return;
-	let relsXml = await relsFile.async("text");
-	let maxId = findMaxRId(relsXml);
-	const relEntries = [];
-	for (const hyperlink of newHyperlinks) {
-		maxId++;
-		const newRId = `rId${maxId}`;
-		if (!hyperlink.href) continue;
-		relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.hyperlink}" Target="${escapeXml(hyperlink.href)}" TargetMode="External"/>`);
-		hyperlink.rId = newRId;
-	}
-	if (relEntries.length > 0) {
-		relsXml = relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`);
-		zip.file(relsPath, relsXml, {
+async function processNewHyperlinks(parts, zip, compressionLevel) {
+	for (const { relsPath, blocks } of parts) {
+		const newHyperlinks = collectHyperlinksWithoutRId(blocks);
+		if (newHyperlinks.length === 0) continue;
+		const relsXml = await readRelsOrStub(zip, relsPath);
+		let maxId = findMaxRId(relsXml);
+		const relEntries = [];
+		for (const hyperlink of newHyperlinks) {
+			if (!hyperlink.href) continue;
+			maxId++;
+			const newRId = `rId${maxId}`;
+			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.hyperlink}" Target="${escapeXml(hyperlink.href)}" TargetMode="External"/>`);
+			hyperlink.rId = newRId;
+		}
+		zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
 			compression: "DEFLATE",
 			compressionOptions: { level: compressionLevel }
 		});
@@ -420,8 +435,9 @@ const cloneDocxZip = (source) => {
 };
 const finishRepack = async ({ document, originalZip, outputZip, originalDocumentXml, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy }) => {
 	await materializeNewHeaderFooterParts(document, outputZip, compressionLevel);
-	await processNewImages(collectImageParts(document), outputZip, compressionLevel);
-	await processNewHyperlinks(collectHyperlinksWithoutRId(document.package.document.content), outputZip, compressionLevel);
+	const parts = collectDocxParts(document, outputZip);
+	await processNewImages(parts, outputZip, compressionLevel);
+	await processNewHyperlinks(parts, outputZip, compressionLevel);
 	assertValidFolioDocumentModel(document, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(document);
 	const documentXml = serializeDocument(document);
@@ -434,6 +450,7 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	serializeHeadersFootersToZip(document, outputZip, compressionLevel);
 	await serializeNotesToZip(document, originalZip, outputZip, compressionLevel);
 	await serializeNumberingIntoZip(document, originalZip, outputZip, compressionLevel);
+	await serializeAddedStylesIntoZip(document, originalZip, outputZip, compressionLevel);
 	await serializeCommentsToZip(document, outputZip, compressionLevel);
 	if (updateModifiedDate && originalCorePropertiesXml) {
 		const updatedCoreProperties = updateCoreProperties(originalCorePropertiesXml, {
@@ -499,8 +516,9 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 		});
 	}
 	await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
-	await processNewImages(collectImageParts(exportDocument), newZip, compressionLevel);
-	await processNewHyperlinks(collectHyperlinksWithoutRId(exportDocument.package.document.content), newZip, compressionLevel);
+	const parts = collectDocxParts(exportDocument, newZip);
+	await processNewImages(parts, newZip, compressionLevel);
+	await processNewHyperlinks(parts, newZip, compressionLevel);
 	assertValidFolioDocumentModel(exportDocument, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(exportDocument);
 	const documentXml = serializeDocument(exportDocument);
@@ -513,6 +531,7 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	serializeHeadersFootersToZip(exportDocument, newZip, compressionLevel);
 	await serializeNotesToZip(exportDocument, rawContent.originalZip, newZip, compressionLevel);
 	await serializeNumberingIntoZip(exportDocument, rawContent.originalZip, newZip, compressionLevel);
+	await serializeAddedStylesIntoZip(exportDocument, rawContent.originalZip, newZip, compressionLevel);
 	await serializeCommentsToZip(exportDocument, newZip, compressionLevel);
 	if (updateModifiedDate && rawContent.corePropsXml) {
 		const updatedCoreProps = updateCoreProperties(rawContent.corePropsXml, {
@@ -768,14 +787,17 @@ function findMaxHeaderFooterNum(zip, prefix) {
 * relationship.
 */
 async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
-	const rels = doc.package.relationships;
-	if (!rels) return;
 	if (!hasUnmaterializedHeaderFooter(doc)) return;
+	doc.package.relationships ??= /* @__PURE__ */ new Map();
+	const rels = doc.package.relationships;
 	const relEntries = [];
 	const overrides = [];
 	let maxHeaderNum = findMaxHeaderFooterNum(zip, "header");
 	let maxFooterNum = findMaxHeaderFooterNum(zip, "footer");
-	let maxRId = 0;
+	const relsPath = "word/_rels/document.xml.rels";
+	const relsXml = await readRelsOrStub(zip, relsPath);
+	const zipRels = parseRelationships(relsXml);
+	let maxRId = findMaxRId(relsXml);
 	const considerNumericRId = (id) => {
 		const match = /^rId(?<num>\d+)$/u.exec(id);
 		if (match) {
@@ -792,7 +814,7 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 	const materialize = (map, relType, prefix, contentType, isHeader) => {
 		if (!map) return;
 		for (const rId of [...map.keys()]) {
-			const existing = rels.get(rId);
+			const existing = rels.get(rId) ?? zipRels.get(rId);
 			if (existing && existing.type === relType && existing.target) continue;
 			let effectiveRId = rId;
 			if (existing) {
@@ -820,8 +842,6 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 	materialize(doc.package.footers, RELATIONSHIP_TYPES.footer, "footer", FOOTER_CONTENT_TYPE, false);
 	if (relEntries.length === 0) return;
 	const compressionOptions = { level: compressionLevel };
-	const relsPath = "word/_rels/document.xml.rels";
-	const relsXml = await readRelsOrStub(zip, relsPath);
 	zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
 		compression: "DEFLATE",
 		compressionOptions
@@ -1063,14 +1083,56 @@ async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLe
 	}
 	const currentXml = serializeNumberingXml(numbering);
 	const changed = collectChangedNumberingDefs(baseline.serializedXml, currentXml);
-	if (changed.abstractNums.size === 0 && changed.nums.size === 0) return;
-	const patched = buildPatchedNumberingXml(baseline.originalXml, currentXml, changed);
+	const added = collectAddedNumberingDefs(baseline.serializedXml, currentXml);
+	const hasChanged = changed.abstractNums.size > 0 || changed.nums.size > 0;
+	const hasAdded = added.abstractNums.size > 0 || added.nums.size > 0;
+	if (!hasChanged && !hasAdded) return;
+	const spliced = buildPatchedNumberingXml(baseline.originalXml, currentXml, changed);
+	if (spliced === null) return;
+	const patched = appendNumberingDefs(spliced, currentXml, added);
 	if (patched === null) return;
 	newZip.file(file.name, patched, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
 }
+const STYLES_PART_PATH = "word/styles.xml";
+const STYLES_CLOSE_ROOT = "</w:styles>";
+const STYLE_ID_PATTERN = /<w:style\b[^>]*?\bw:styleId="(?<id>[^"]+)"/gu;
+/**
+* Append styles the model defines but the original `word/styles.xml` lacks.
+* Existing styles stay byte-exact (edits to them are not written here, the
+* part is otherwise preserved verbatim); only minted definitions, such as the
+* per-language clones a bilingual transform adds, are emitted before the root
+* close so paragraphs referencing them resolve on reopen.
+*/
+async function serializeAddedStylesIntoZip(doc, originalZip, newZip, compressionLevel) {
+	const styles = doc.package.styles;
+	if (!styles || styles.styles.length === 0) return;
+	const file = findNotePartEntry(originalZip, STYLES_PART_PATH);
+	const originalXml = file ? await file.async("text") : null;
+	const rootClose = originalXml?.lastIndexOf(STYLES_CLOSE_ROOT) ?? -1;
+	if (file === null || originalXml === null || rootClose < 0) {
+		await materializeNewNotePart({
+			contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
+			newZip,
+			partPath: STYLES_PART_PATH,
+			relationshipType: RELATIONSHIP_TYPES.styles,
+			serializedPart: serializeStylesXml(styles),
+			compressionLevel
+		});
+		return;
+	}
+	const existing = /* @__PURE__ */ new Set();
+	for (const match of originalXml.matchAll(STYLE_ID_PATTERN)) existing.add(match.groups["id"]);
+	const added = styles.styles.filter((style) => !existing.has(style.styleId));
+	if (added.length === 0) return;
+	const patched = originalXml.slice(0, rootClose) + added.map(serializeStyle).join("") + originalXml.slice(rootClose);
+	newZip.file(file.name, patched, {
+		compression: "DEFLATE",
+		compressionOptions: { level: compressionLevel }
+	});
+}
 async function patchNotePartIntoZip(conventionalLowerPath, currentXml, baselineFrom, originalZip, newZip, compressionLevel) {
 	const file = findNotePartEntry(originalZip, conventionalLowerPath);
 	if (!file) return;
@@ -1109,6 +1171,11 @@ function collectChangedNoteParaIds(baselineXml, currentXml) {
 	}
 	return changed;
 }
+/** `word/Footnotes.xml` -> `word/_rels/Footnotes.xml.rels` (casing preserved). */
+function notePartRelsPath(partPath) {
+	const lastSlash = partPath.lastIndexOf("/");
+	return `${partPath.slice(0, lastSlash + 1)}_rels/${partPath.slice(lastSlash + 1)}.rels`;
+}
 /**
 * Locate a note part in the ZIP, matching case-insensitively so a producer that
 * cased the entry differently still resolves to the existing part.
@@ -1362,4 +1429,4 @@ const assertStyleNumberingReferences = (doc) => {
 	for (const numbering of doc.package.numbering?.nums ?? []) if (!availableAbstract.has(numbering.abstractNumId)) panic(`Numbering definition ${numbering.numId} references missing abstract numbering`);
 };
 //#endregion
-export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, DocxPackageFidelityError, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, isDocxBuffer, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx };
+export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, DocxPackageFidelityError, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, collectHyperlinksWithoutRId, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, isDocxBuffer, notePartRelsPath, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx };

package/dist/docx/selectiveSave.js

@@ -182,6 +182,12 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 	if (originalBuffer.byteLength > maxBytes) return null;
 	const content = doc.package.document.content;
 	if (hasNewImagesOrHyperlinks(content)) return null;
+	for (const part of [
+		...doc.package.headers?.values() ?? [],
+		...doc.package.footers?.values() ?? [],
+		...doc.package.footnotes ?? [],
+		...doc.package.endnotes ?? []
+	]) if (hasNewImagesOrHyperlinks(part.content)) return null;
 	if (hasUnmaterializedHeaderFooter(doc)) return null;
 	if (hasModelDrivenPictureWatermark(doc)) return null;
 	if (withoutOrphanCommentRanges(doc) !== doc) return null;

package/dist/docx/selectiveXmlPatch.d.ts

@@ -129,5 +129,23 @@ declare function collectChangedNumberingDefs(baselineXml: string, currentXml: st
  * in either input (so the caller preserves the original part verbatim).
  */
 declare function buildPatchedNumberingXml(originalXml: string, currentXml: string, changed: ChangedNumberingDefs): string | null;
+/**
+ * Numbering definitions present in `currentXml` (the model's serialization)
+ * but absent from `baselineXml` (the re-parsed original): definitions a
+ * transform minted. `collectChangedNumberingDefs` deliberately skips these
+ * because they cannot be spliced by id; they are appended instead.
+ */
+declare function collectAddedNumberingDefs(baselineXml: string, currentXml: string): ChangedNumberingDefs;
+/**
+ * Append added `w:abstractNum` / `w:num` definitions from `currentXml` to
+ * `xml`. ECMA-376 §17.9 orders every `w:abstractNum` before the first `w:num`,
+ * so abstract definitions go right before the first `<w:num ` (or the root
+ * close when the part has none) and instances before the root close. A
+ * synthetic numFmt in an added abstract is restored from the original
+ * definition it was cloned from (the one with an identical body), so a custom
+ * format survives cloning. Returns null when an added id cannot be extracted
+ * or the part has no `</w:numbering>`.
+ */
+declare function appendNumberingDefs(xml: string, currentXml: string, added: ChangedNumberingDefs): string | null;
 //#endregion
-export { ChangedNumberingDefs, ParagraphOffsets, PatchSafetyOptions, PatchValidationResult, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };
+export { ChangedNumberingDefs, ParagraphOffsets, PatchSafetyOptions, PatchValidationResult, appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };

package/dist/docx/selectiveXmlPatch.js

@@ -552,8 +552,79 @@ function buildPatchedNumberingXml(originalXml, currentXml, changed) {
 	for (const { start, end, newXml } of replacements) result = result.slice(0, start) + newXml + result.slice(end);
 	return result;
 }
+/**
+* Numbering definitions present in `currentXml` (the model's serialization)
+* but absent from `baselineXml` (the re-parsed original): definitions a
+* transform minted. `collectChangedNumberingDefs` deliberately skips these
+* because they cannot be spliced by id; they are appended instead.
+*/
+function collectAddedNumberingDefs(baselineXml, currentXml) {
+	const addedForKind = (kind) => {
+		const added = /* @__PURE__ */ new Set();
+		const baselineIndex = buildNumberingElementOffsetIndex(baselineXml, kind);
+		const currentIndex = buildNumberingElementOffsetIndex(currentXml, kind);
+		for (const [id, range] of currentIndex) if (range && !baselineIndex.has(id)) added.add(id);
+		return added;
+	};
+	return {
+		abstractNums: addedForKind("abstractNum"),
+		nums: addedForKind("num")
+	};
+}
+const NUMBERING_CLOSE_ROOT = "</w:numbering>";
+/**
+* Append added `w:abstractNum` / `w:num` definitions from `currentXml` to
+* `xml`. ECMA-376 §17.9 orders every `w:abstractNum` before the first `w:num`,
+* so abstract definitions go right before the first `<w:num ` (or the root
+* close when the part has none) and instances before the root close. A
+* synthetic numFmt in an added abstract is restored from the original
+* definition it was cloned from (the one with an identical body), so a custom
+* format survives cloning. Returns null when an added id cannot be extracted
+* or the part has no `</w:numbering>`.
+*/
+function appendNumberingDefs(xml, currentXml, added) {
+	if (added.abstractNums.size === 0 && added.nums.size === 0) return xml;
+	const rootClose = xml.lastIndexOf(NUMBERING_CLOSE_ROOT);
+	if (rootClose < 0) return null;
+	const abstractXmls = [];
+	for (const id of added.abstractNums) {
+		const def = extractNumberingElementXml(currentXml, "abstractNum", id);
+		if (def === null) return null;
+		abstractXmls.push(restoreClonedLevelNumFmts(xml, currentXml, def, id));
+	}
+	const numXmls = [];
+	for (const id of added.nums) {
+		const def = extractNumberingElementXml(currentXml, "num", id);
+		if (def === null) return null;
+		numXmls.push(def);
+	}
+	const firstNum = findFirstElement(xml, NUMBERING_OPEN_LITERAL.num, NUMBERING_CLOSE_TAG.num);
+	const abstractInsertAt = firstNum ? firstNum.start : rootClose;
+	const head = xml.slice(0, abstractInsertAt);
+	const middle = xml.slice(abstractInsertAt, rootClose);
+	const tail = xml.slice(rootClose);
+	return head + abstractXmls.join("") + middle + numXmls.join("") + tail;
+}
+/**
+* For an added abstract definition that still carries a synthetic numFmt, find
+* the original abstract it was cloned from (same serialized body apart from the
+* id) and restore the level formats from it.
+*/
+function restoreClonedLevelNumFmts(originalXml, currentXml, addedDefXml, addedId) {
+	if (!SYNTHETIC_NUM_FMT_PATTERN.test(addedDefXml)) return addedDefXml;
+	const addedBody = stripAbstractNumId(addedDefXml, addedId);
+	const originalIds = collectElementIds(originalXml, NUMBERING_OPEN_LITERAL.abstractNum, NUMBERING_ID_ATTR.abstractNum);
+	for (const [id] of originalIds) {
+		const candidate = extractNumberingElementXml(currentXml, "abstractNum", id);
+		if (candidate === null || stripAbstractNumId(candidate, id) !== addedBody) continue;
+		const originalDef = extractNumberingElementXml(originalXml, "abstractNum", id);
+		if (originalDef !== null) return restoreLevelNumFmts(originalDef, addedDefXml);
+	}
+	return restoreLevelNumFmts("", addedDefXml);
+}
+const stripAbstractNumId = (defXml, id) => defXml.replace(`${NUMBERING_ID_ATTR.abstractNum}="${id}"`, "");
 function escapeRegExp(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 //#endregion
-export { buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };
+export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };

package/dist/docx/serializer/paragraphSerializer.js

@@ -263,6 +263,7 @@ function serializeComplexField(field) {
 	const rPrXml = structuralFormatting ? serializeTextFormatting(structuralFormatting) : "";
 	const beginAttrs = ["w:fldCharType=\"begin\""];
 	if (field.fldLock) beginAttrs.push("w:fldLock=\"true\"");
+	if (field.dirty) beginAttrs.push("w:dirty=\"true\"");
 	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
 	if (field.fieldCode.length > 0) parts.push(...field.fieldCode.map((run) => serializeRun(run)));
 	else if (field.instruction.length > 0) {

package/dist/docx/serializer/settingsSerializer.js

@@ -4,6 +4,7 @@ const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 const serializeSettingsXml = (settings) => {
 	const parts = [`<w:defaultTabStop w:val="${intAttr(settings.defaultTabStop)}"/>`];
 	if (settings.evenAndOddHeaders) parts.push("<w:evenAndOddHeaders/>");
+	if (settings.updateFields) parts.push("<w:updateFields w:val=\"true\"/>");
 	if (settings.themeFontLang) {
 		const attrs = [];
 		if (settings.themeFontLang.eastAsia) attrs.push(`w:eastAsia="${escapeXml(settings.themeFontLang.eastAsia)}"`);

package/dist/docx/serializer/stylesSerializer.d.ts

@@ -1,5 +1,6 @@
 import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/stylesSerializer.d.ts
 declare const serializeStylesXml: (definitions: document_d_exports.StyleDefinitions) => string;
+declare const serializeStyle: (style: document_d_exports.Style) => string;
 //#endregion
-export { serializeStylesXml };
+export { serializeStyle, serializeStylesXml };

package/dist/docx/serializer/stylesSerializer.js

@@ -53,4 +53,4 @@ const pushBooleanAttr = (attrs, name, value) => {
 	if (value !== void 0) attrs.push(`${name}="${value ? 1 : 0}"`);
 };
 //#endregion
-export { serializeStylesXml };
+export { serializeStyle, serializeStylesXml };

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

@@ -0,0 +1,103 @@
+import { document_d_exports } from "../../types/document.js";
+import { ShadingProperties } from "../../types/colors.js";
+import { Hyperlink, Paragraph, ParagraphContent, Run, Table } from "../../types/content.js";
+import { ParagraphFormatting, TextFormatting } from "../../types/formatting.js";
+//#region src/docx/server/build.d.ts
+declare const HEADING_LEVELS: readonly [1, 2, 3, 4, 5, 6];
+type HeadingLevel = (typeof HEADING_LEVELS)[number];
+declare const InvalidFolioReportBuilderOptionsError_base: import("better-result").TaggedErrorClass<"InvalidFolioReportBuilderOptionsError", {
+  message: string;
+  path: string;
+}>;
+/**
+ * A builder received a value outside the model's domain (a zero `gridSpan`,
+ * a negative column width, a reversed TOC range). Thrown at the boundary so
+ * the invalid value never reaches the serializer.
+ */
+declare class InvalidFolioReportBuilderOptionsError extends InvalidFolioReportBuilderOptionsError_base {}
+declare const run: (text: string, formatting?: TextFormatting) => Run;
+declare const paragraph: (content: string | ParagraphContent[], formatting?: ParagraphFormatting) => Paragraph;
+type HeadingOptions = {
+  text: string;
+  level: HeadingLevel;
+};
+/** A paragraph in the `Heading<level>` style. */
+declare const heading: ({ text, level }: HeadingOptions) => Paragraph;
+/** An empty paragraph carrying a hard page break. */
+declare const pageBreak: () => Paragraph;
+type HyperlinkTarget = {
+  href: string;
+  anchor?: never;
+} | {
+  anchor: string;
+  href?: never;
+};
+type HyperlinkOptions = HyperlinkTarget & {
+  text: string;
+  formatting?: TextFormatting;
+  tooltip?: string;
+};
+/**
+ * An external (`href`) or in-document (`anchor`, a bookmark name) link. The
+ * relationship for an external link is minted when the document is written.
+ */
+declare const hyperlink: ({ text, formatting, tooltip, href, anchor }: HyperlinkOptions) => Hyperlink;
+type BookmarkOptions = {
+  name: string;
+  content: ParagraphContent[];
+  /**
+   * Bookmark id, unique per document. Defaults to a process-wide counter,
+   * which is unique for documents built from scratch; pass an explicit id
+   * when adding bookmarks to a parsed document.
+   */
+  id?: number;
+};
+/** `content` wrapped in a named bookmark, the target of `hyperlink({ anchor })`. */
+declare const bookmark: ({ name, content, id }: BookmarkOptions) => ParagraphContent[];
+type TableCellSpec = string | {
+  content: Paragraph[];
+  shading?: ShadingProperties;
+  gridSpan?: number;
+  vMerge?: "restart" | "continue";
+};
+type TableOptions = {
+  /** Header row labels; rendered bold, optionally shaded and repeated per page. */
+  header?: string[];
+  rows: TableCellSpec[][];
+  /** Grid column widths in twips. Omitted: the consumer autofits. */
+  columnWidths?: number[];
+  headerShading?: ShadingProperties;
+  /** Repeat the header row at the top of every page (default true). */
+  repeatHeader?: boolean;
+};
+/**
+ * A full-width grid table in the `TableGrid` style. A string cell becomes one
+ * plain paragraph; an object cell supplies its own paragraphs plus optional
+ * shading and horizontal (`gridSpan`) or vertical (`vMerge`) merge.
+ */
+declare const table: ({ header, rows, columnWidths, headerShading, repeatHeader }: TableOptions) => Table;
+/**
+ * Register an endnote on `doc` and return the reference run to place in body
+ * text. Allocates the next free endnote id (Word reserves 0 and -1 for the
+ * separator notes) and pushes the note into `doc.package.endnotes`.
+ */
+declare const endnote: (doc: document_d_exports.Document, content: string | Paragraph[]) => Run;
+type TableOfContentsOptions = {
+  /** Heading levels to include, `1 <= from <= to <= 9` (default 1-3). */
+  levels?: {
+    from: number;
+    to: number;
+  };
+  /** Make entries hyperlinks (`\h`, default true). */
+  hyperlinks?: boolean;
+  /** Result text shown until the consumer recomputes the field. */
+  placeholderText?: string;
+};
+/**
+ * A paragraph holding a dirty `TOC` field, so the consumer recomputes the
+ * table on open. Set `package.settings.updateFields` as well to have Word
+ * recompute without prompting for each field.
+ */
+declare const createTableOfContentsField: ({ levels, hyperlinks, placeholderText }?: TableOfContentsOptions) => Paragraph;
+//#endregion
+export { HEADING_LEVELS, HeadingLevel, InvalidFolioReportBuilderOptionsError, TableCellSpec, bookmark, createTableOfContentsField, endnote, heading, hyperlink, pageBreak, paragraph, run, table };