@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

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

@@ -0,0 +1,31 @@
+import { Comment } from "../../types/content.js";
+
+//#region src/docx/serializer/commentSerializer.d.ts
+/**
+ * Serialize comments array to comments.xml content. Returns a valid empty
+ * `<w:comments/>` document for an empty array so callers can overwrite an
+ * existing `word/comments.xml` part when the editor has removed the last
+ * comment — leaving the previous file in place would otherwise re-emit
+ * the orphaned comment threads on every save.
+ */
+declare function serializeComments(comments: Comment[]): string;
+/**
+ * Assign a deterministic `w14:paraId` to the LAST paragraph of every comment
+ * that needs a commentsExtended entry (a reply, a reply's parent, or a resolved
+ * comment) but has none. A document authored or loaded without comment paraIds
+ * would otherwise have no stable key to thread through commentsExtended.xml, and
+ * the thread link would be silently dropped. Word-authored ids are preserved;
+ * only threaded, id-less paragraphs are filled. Deterministic (content- and
+ * id-derived) so repeated saves mint the SAME id. MUST run before serializing
+ * BOTH comments.xml and commentsExtended.xml so the two reference the same id.
+ */
+declare function ensureThreadedCommentParaIds(comments: readonly Comment[]): void;
+/**
+ * Serialize `commentsExtended.xml` (`w15:commentsEx`) for reply threading and
+ * resolved state, or `null` when no comment needs an entry (see
+ * {@link buildCommentExtendedEntries}). This is the part that makes Word render
+ * a comment as a REPLY rather than a separate top-level thread.
+ */
+declare function serializeCommentsExtended(comments: readonly Comment[]): string | null;
+//#endregion
+export { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended };

package/dist/docx/serializer/commentSerializer.js

@@ -0,0 +1,184 @@
+import { deterministicHexId } from "../../utils/hexId.js";
+import { escapeXml } from "./xmlUtils.js";
+//#region src/docx/serializer/commentSerializer.ts
+/**
+* Comment Serializer
+*
+* Serializes Comment[] to OOXML comments.xml format.
+*/
+function serializeRunContent(run) {
+	let xml = "<w:r>";
+	const rPr = [];
+	if (run.formatting?.bold) rPr.push("<w:b/>");
+	if (run.formatting?.italic) rPr.push("<w:i/>");
+	if (rPr.length > 0) xml += `<w:rPr>${rPr.join("")}</w:rPr>`;
+	for (const c of run.content) if (c.type === "text") {
+		const preserveSpace = c.text !== c.text.trim() || c.text.includes("  ");
+		xml += preserveSpace ? `<w:t xml:space="preserve">${escapeXml(c.text)}</w:t>` : `<w:t>${escapeXml(c.text)}</w:t>`;
+	} else if (c.type === "break") xml += "<w:br/>";
+	xml += "</w:r>";
+	return xml;
+}
+/**
+* `w14:paraId` / `w14:textId` open tag for a comment paragraph. Word keys
+* commentsExtended.xml (reply threading) and commentsExtensible.xml (UTC
+* dates) on the paraId of a comment's LAST paragraph, so the id must survive
+* serialization; the parser stores it on `Paragraph.paraId`.
+*/
+function commentParagraphOpenTag(p) {
+	const attrs = [];
+	if (p.paraId) attrs.push(`w14:paraId="${p.paraId}"`);
+	if (p.textId) attrs.push(`w14:textId="${p.textId}"`);
+	return attrs.length > 0 ? `<w:p ${attrs.join(" ")}>` : "<w:p>";
+}
+function serializeParagraph(p) {
+	let xml = commentParagraphOpenTag(p);
+	for (const item of p.content) if (item.type === "run") xml += serializeRunContent(item);
+	xml += "</w:p>";
+	return xml;
+}
+/** Serialize a paragraph, prepending an annotationRef run (required by Word in first paragraph of a comment) */
+function serializeParagraphWithAnnotationRef(p) {
+	let xml = commentParagraphOpenTag(p);
+	xml += "<w:r><w:rPr><w:rStyle w:val=\"CommentReference\"/></w:rPr><w:annotationRef/></w:r>";
+	for (const item of p.content) if (item.type === "run") xml += serializeRunContent(item);
+	xml += "</w:p>";
+	return xml;
+}
+function serializeComment(comment) {
+	const attrs = [`w:id="${comment.id}"`];
+	if (comment.author) attrs.push(`w:author="${escapeXml(comment.author)}"`);
+	if (comment.initials) attrs.push(`w:initials="${escapeXml(comment.initials)}"`);
+	if (comment.date) attrs.push(`w:date="${escapeXml(comment.date)}"`);
+	let xml = `<w:comment ${attrs.join(" ")}>`;
+	if (comment.content.length > 0) {
+		xml += serializeParagraphWithAnnotationRef(comment.content[0]);
+		for (let i = 1; i < comment.content.length; i++) xml += serializeParagraph(comment.content[i]);
+	} else xml += "<w:p><w:r><w:rPr><w:rStyle w:val=\"CommentReference\"/></w:rPr><w:annotationRef/></w:r></w:p>";
+	xml += "</w:comment>";
+	return xml;
+}
+const COMMENTS_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<w:comments xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" mc:Ignorable=\"w14 wp14\">";
+/**
+* Serialize comments array to comments.xml content. Returns a valid empty
+* `<w:comments/>` document for an empty array so callers can overwrite an
+* existing `word/comments.xml` part when the editor has removed the last
+* comment — leaving the previous file in place would otherwise re-emit
+* the orphaned comment threads on every save.
+*/
+function serializeComments(comments) {
+	const topLevel = [];
+	const replies = [];
+	for (const c of comments) {
+		const { parentId } = c;
+		(parentId === null || parentId === void 0 ? topLevel : replies).push(c);
+	}
+	let xml = COMMENTS_HEADER;
+	for (const comment of topLevel) xml += serializeComment(comment);
+	for (const reply of replies) xml += serializeComment(reply);
+	xml += "</w:comments>";
+	return xml;
+}
+/** The `w14:paraId` Word threads a comment by: its LAST paragraph's paraId. */
+function commentThreadParaId(comment) {
+	return comment.content?.at(-1)?.paraId;
+}
+/**
+* The ids of comments that need a `commentsExtended.xml` entry: a reply, a
+* reply's parent (the thread root), or any comment carrying a resolved state.
+* A plain top-level comment set yields an empty set, so no part is written.
+*/
+function threadedCommentIds(comments) {
+	const replyParents = /* @__PURE__ */ new Set();
+	for (const comment of comments) if (comment.parentId !== void 0) replyParents.add(comment.parentId);
+	const ids = /* @__PURE__ */ new Set();
+	for (const comment of comments) if (comment.parentId !== void 0 || replyParents.has(comment.id) || comment.done !== void 0) ids.add(comment.id);
+	return ids;
+}
+const commentPlainText = (comment) => {
+	let text = "";
+	for (const paragraph of comment.content ?? []) for (const item of paragraph.content ?? []) {
+		if (item.type !== "run") continue;
+		for (const runItem of item.content ?? []) if (runItem.type === "text") text += runItem.text;
+	}
+	return text;
+};
+/**
+* Assign a deterministic `w14:paraId` to the LAST paragraph of every comment
+* that needs a commentsExtended entry (a reply, a reply's parent, or a resolved
+* comment) but has none. A document authored or loaded without comment paraIds
+* would otherwise have no stable key to thread through commentsExtended.xml, and
+* the thread link would be silently dropped. Word-authored ids are preserved;
+* only threaded, id-less paragraphs are filled. Deterministic (content- and
+* id-derived) so repeated saves mint the SAME id. MUST run before serializing
+* BOTH comments.xml and commentsExtended.xml so the two reference the same id.
+*/
+function ensureThreadedCommentParaIds(comments) {
+	const threaded = threadedCommentIds(comments);
+	if (threaded.size === 0) return;
+	const used = /* @__PURE__ */ new Set();
+	for (const comment of comments) for (const paragraph of comment.content ?? []) if (paragraph.paraId) used.add(paragraph.paraId.toUpperCase());
+	for (const comment of comments) {
+		if (!threaded.has(comment.id)) continue;
+		const last = (comment.content ?? []).at(-1);
+		if (!last || last.paraId) continue;
+		let paraId = deterministicHexId(`comment:${comment.id}:${commentPlainText(comment)}`);
+		for (let salt = 1; used.has(paraId.toUpperCase()); salt++) paraId = deterministicHexId(`comment:${comment.id}:${salt}`);
+		used.add(paraId.toUpperCase());
+		last.paraId = paraId;
+	}
+}
+/**
+* Build the `commentsExtended.xml` entries for the comments that participate in
+* a thread or carry a resolved state. Returns `null` when no comment needs an
+* entry (no replies, no parents-of-replies, no `done` state) so callers can
+* leave any existing part untouched — a plain top-level comment set gets no
+* `commentsExtended.xml`, matching how Word omits it.
+*
+* A `w15:commentEx` keys on the comment's LAST paragraph paraId; a reply's
+* `w15:paraIdParent` points at its parent comment's last-paragraph paraId. Ids
+* are guaranteed present by {@link ensureThreadedCommentParaIds}; the `!paraId`
+* skip is a last-ditch safety for a malformed model.
+*/
+function buildCommentExtendedEntries(comments) {
+	const threaded = threadedCommentIds(comments);
+	if (threaded.size === 0) return null;
+	const paraIdByCommentId = /* @__PURE__ */ new Map();
+	for (const comment of comments) {
+		const paraId = commentThreadParaId(comment);
+		if (paraId) paraIdByCommentId.set(comment.id, paraId);
+	}
+	const entries = [];
+	for (const comment of comments) {
+		if (!threaded.has(comment.id)) continue;
+		const paraId = paraIdByCommentId.get(comment.id);
+		if (!paraId) continue;
+		const parentParaId = comment.parentId !== void 0 ? paraIdByCommentId.get(comment.parentId) : void 0;
+		entries.push({
+			paraId,
+			...parentParaId !== void 0 ? { paraIdParent: parentParaId } : {},
+			done: comment.done ?? false
+		});
+	}
+	return entries.length > 0 ? entries : null;
+}
+const COMMENTS_EXTENDED_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<w15:commentsEx xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" mc:Ignorable=\"w15\">";
+/**
+* Serialize `commentsExtended.xml` (`w15:commentsEx`) for reply threading and
+* resolved state, or `null` when no comment needs an entry (see
+* {@link buildCommentExtendedEntries}). This is the part that makes Word render
+* a comment as a REPLY rather than a separate top-level thread.
+*/
+function serializeCommentsExtended(comments) {
+	const entries = buildCommentExtendedEntries(comments);
+	if (!entries) return null;
+	let xml = COMMENTS_EXTENDED_HEADER;
+	for (const entry of entries) {
+		const parentAttr = entry.paraIdParent !== void 0 ? ` w15:paraIdParent="${entry.paraIdParent}"` : "";
+		xml += `<w15:commentEx w15:paraId="${entry.paraId}"${parentAttr} w15:done="${entry.done ? "1" : "0"}"/>`;
+	}
+	xml += "</w15:commentsEx>";
+	return xml;
+}
+//#endregion
+export { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended };

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

@@ -0,0 +1,65 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/documentSerializer.d.ts
+/**
+ * Serialize a DocumentBody to document.xml body content
+ *
+ * @param body - The document body to serialize
+ * @returns XML string for the body element (without body tags)
+ */
+declare function serializeDocumentBody(body: document_d_exports.DocumentBody): string;
+/**
+ * Serialize a complete Document to valid document.xml
+ *
+ * @param doc - The document to serialize
+ * @returns Complete XML string for document.xml
+ */
+declare function serializeDocument(doc: document_d_exports.Document): string;
+/**
+ * Serialize just the document body (useful for partial updates)
+ *
+ * @param body - The document body to serialize
+ * @returns XML string for the w:body element
+ */
+declare function serializeDocumentBodyElement(body: document_d_exports.DocumentBody): string;
+/**
+ * Check if document has any content
+ */
+declare function hasDocumentContent(doc: document_d_exports.Document): boolean;
+/**
+ * Check if document has sections
+ */
+declare function hasDocumentSections(doc: document_d_exports.Document): boolean;
+/**
+ * Check if document has section properties
+ */
+declare function hasSectionProperties(doc: document_d_exports.Document): boolean;
+/**
+ * Get document content count (paragraphs + tables)
+ */
+declare function getDocumentContentCount(doc: document_d_exports.Document): number;
+/**
+ * Get paragraph count in document
+ */
+declare function getDocumentParagraphCount(doc: document_d_exports.Document): number;
+/**
+ * Get table count in document
+ */
+declare function getDocumentTableCount(doc: document_d_exports.Document): number;
+/**
+ * Get plain text from document (for comparison/debugging)
+ */
+declare function getDocumentPlainText(doc: document_d_exports.Document): string;
+/**
+ * Create an empty document
+ */
+declare function createEmptyDocument(): document_d_exports.Document;
+/**
+ * Create a simple document with text content
+ */
+declare function createSimpleDocument(paragraphs: {
+  text: string;
+  styleId?: string;
+}[]): document_d_exports.Document;
+//#endregion
+export { createEmptyDocument, createSimpleDocument, getDocumentContentCount, getDocumentParagraphCount, getDocumentPlainText, getDocumentTableCount, hasDocumentContent, hasDocumentSections, hasSectionProperties, serializeDocument, serializeDocumentBody, serializeDocumentBodyElement };

package/dist/docx/serializer/documentSerializer.js

@@ -0,0 +1,199 @@
+import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { resetAutoIdCounter } from "./runSerializer.js";
+import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
+import { serializeParagraph } from "./paragraphSerializer.js";
+import { serializeTable } from "./tableSerializer.js";
+//#region src/docx/serializer/documentSerializer.ts
+/**
+* Standard OOXML namespaces for document.xml
+*/
+const NAMESPACES = {
+	wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+	cx: "http://schemas.microsoft.com/office/drawing/2014/chartex",
+	cx1: "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex",
+	cx2: "http://schemas.microsoft.com/office/drawing/2015/10/21/chartex",
+	cx3: "http://schemas.microsoft.com/office/drawing/2016/5/9/chartex",
+	cx4: "http://schemas.microsoft.com/office/drawing/2016/5/10/chartex",
+	cx5: "http://schemas.microsoft.com/office/drawing/2016/5/11/chartex",
+	cx6: "http://schemas.microsoft.com/office/drawing/2016/5/12/chartex",
+	cx7: "http://schemas.microsoft.com/office/drawing/2016/5/13/chartex",
+	cx8: "http://schemas.microsoft.com/office/drawing/2016/5/14/chartex",
+	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+	aink: "http://schemas.microsoft.com/office/drawing/2016/ink",
+	am3d: "http://schemas.microsoft.com/office/drawing/2017/model3d",
+	o: "urn:schemas-microsoft-com:office:office",
+	oel: "http://schemas.microsoft.com/office/2019/extlst",
+	r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+	m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+	v: "urn:schemas-microsoft-com:vml",
+	wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+	wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+	w10: "urn:schemas-microsoft-com:office:word",
+	w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+	w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+	w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+	w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
+	w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+	w16: "http://schemas.microsoft.com/office/word/2018/wordml",
+	w16sdtdh: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
+	w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
+	wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+	wpi: "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+	wne: "http://schemas.microsoft.com/office/word/2006/wordml",
+	wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
+};
+/**
+* Build namespace declaration string for document element
+*/
+function buildNamespaceDeclarations() {
+	const declared = {
+		wpc: NAMESPACES.wpc,
+		mc: NAMESPACES.mc,
+		o: NAMESPACES.o,
+		r: NAMESPACES.r,
+		m: NAMESPACES.m,
+		v: NAMESPACES.v,
+		wp14: NAMESPACES.wp14,
+		wp: NAMESPACES.wp,
+		w10: NAMESPACES.w10,
+		w: NAMESPACES.w,
+		w14: NAMESPACES.w14,
+		w15: NAMESPACES.w15,
+		w16: NAMESPACES.w16,
+		w16cex: NAMESPACES.w16cex,
+		w16cid: NAMESPACES.w16cid,
+		w16sdtdh: NAMESPACES.w16sdtdh,
+		w16se: NAMESPACES.w16se,
+		wpg: NAMESPACES.wpg,
+		wps: NAMESPACES.wps
+	};
+	return Object.entries(declared).map(([prefix, uri]) => `xmlns:${prefix}="${uri}"`).join(" ");
+}
+/**
+* Serialize a single block content item (paragraph, table, or block-level SDT).
+*/
+function serializeBlockContent(block) {
+	if (block.type === "paragraph") return serializeParagraph(block);
+	if (block.type === "table") return serializeTable(block);
+	return serializeBlockSdt(block, serializeBlockContent);
+}
+/**
+* Serialize document body content
+*/
+function serializeBodyContent(content) {
+	return content.map((block) => serializeBlockContent(block)).join("");
+}
+/**
+* Serialize a DocumentBody to document.xml body content
+*
+* @param body - The document body to serialize
+* @returns XML string for the body element (without body tags)
+*/
+function serializeDocumentBody(body) {
+	const parts = [];
+	parts.push(serializeBodyContent(body.content));
+	if (body.finalSectionProperties) parts.push(serializeSectionProperties(body.finalSectionProperties));
+	return parts.join("");
+}
+/**
+* Serialize a complete Document to valid document.xml
+*
+* @param doc - The document to serialize
+* @returns Complete XML string for document.xml
+*/
+function serializeDocument(doc) {
+	resetAutoIdCounter();
+	const parts = [];
+	parts.push("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
+	const nsDecl = buildNamespaceDeclarations();
+	parts.push(`<w:document ${nsDecl} mc:Ignorable="w14 w15 wp14">`);
+	parts.push("<w:body>");
+	parts.push(serializeDocumentBody(doc.package.document));
+	parts.push("</w:body>");
+	parts.push("</w:document>");
+	return parts.join("");
+}
+/**
+* Serialize just the document body (useful for partial updates)
+*
+* @param body - The document body to serialize
+* @returns XML string for the w:body element
+*/
+function serializeDocumentBodyElement(body) {
+	return `<w:body>${serializeDocumentBody(body)}</w:body>`;
+}
+/**
+* Check if document has any content
+*/
+function hasDocumentContent(doc) {
+	return doc.package.document.content.length > 0;
+}
+/**
+* Check if document has sections
+*/
+function hasDocumentSections(doc) {
+	return (doc.package.document.sections?.length ?? 0) > 0;
+}
+/**
+* Check if document has section properties
+*/
+function hasSectionProperties(doc) {
+	return doc.package.document.finalSectionProperties !== void 0;
+}
+/**
+* Get document content count (paragraphs + tables)
+*/
+function getDocumentContentCount(doc) {
+	return doc.package.document.content.length;
+}
+/**
+* Get paragraph count in document
+*/
+function getDocumentParagraphCount(doc) {
+	return doc.package.document.content.filter((b) => b.type === "paragraph").length;
+}
+/**
+* Get table count in document
+*/
+function getDocumentTableCount(doc) {
+	return doc.package.document.content.filter((b) => b.type === "table").length;
+}
+/**
+* Get plain text from document (for comparison/debugging)
+*/
+function getDocumentPlainText(doc) {
+	const texts = [];
+	for (const block of doc.package.document.content) if (block.type === "paragraph") {
+		for (const content of block.content) if (content.type === "run") {
+			for (const item of content.content) if (item.type === "text") texts.push(item.text);
+			else if (item.type === "tab") texts.push("	");
+			else if (item.type === "break") texts.push("\n");
+		}
+		texts.push("\n");
+	}
+	return texts.join("");
+}
+/**
+* Create an empty document
+*/
+function createEmptyDocument() {
+	return { package: { document: { content: [] } } };
+}
+/**
+* Create a simple document with text content
+*/
+function createSimpleDocument(paragraphs) {
+	return { package: { document: { content: paragraphs.map((p) => ({
+		type: "paragraph",
+		...p.styleId ? { formatting: { styleId: p.styleId } } : {},
+		content: [{
+			type: "run",
+			content: [{
+				type: "text",
+				text: p.text
+			}]
+		}]
+	})) } } };
+}
+//#endregion
+export { createEmptyDocument, createSimpleDocument, getDocumentContentCount, getDocumentParagraphCount, getDocumentPlainText, getDocumentTableCount, hasDocumentContent, hasDocumentSections, hasSectionProperties, serializeDocument, serializeDocumentBody, serializeDocumentBodyElement };

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

@@ -0,0 +1,12 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/headerFooterSerializer.d.ts
+/**
+ * Serialize a HeaderFooter object to valid OOXML XML
+ *
+ * @param hf - HeaderFooter object to serialize
+ * @returns Complete XML string for header*.xml or footer*.xml
+ */
+declare function serializeHeaderFooter(hf: document_d_exports.HeaderFooter): string;
+//#endregion
+export { serializeHeaderFooter };

package/dist/docx/serializer/headerFooterSerializer.js

@@ -0,0 +1,84 @@
+import { escapeXml } from "./xmlUtils.js";
+import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeParagraph } from "./paragraphSerializer.js";
+import { serializeTable } from "./tableSerializer.js";
+//#region src/docx/serializer/headerFooterSerializer.ts
+const NAMESPACES = {
+	wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+	o: "urn:schemas-microsoft-com:office:office",
+	r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+	m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+	v: "urn:schemas-microsoft-com:vml",
+	a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+	pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
+	wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+	wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+	w10: "urn:schemas-microsoft-com:office:word",
+	w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+	w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+	w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+	w16: "http://schemas.microsoft.com/office/word/2018/wordml",
+	w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
+	w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+	w16sdtdh: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
+	w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
+	wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+	wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
+};
+function buildNamespaceDeclarations() {
+	return Object.entries(NAMESPACES).map(([prefix, uri]) => `xmlns:${prefix}="${uri}"`).join(" ");
+}
+/**
+* Serialize a block content item (paragraph, table, or block-level SDT) for
+* header/footer.
+*/
+function serializeBlock(block) {
+	if (block.type === "paragraph") return serializeParagraph(block);
+	if (block.type === "table") return serializeTable(block);
+	return serializeBlockSdt(block, serializeBlock);
+}
+/**
+* Serialize a HeaderFooter object to valid OOXML XML
+*
+* @param hf - HeaderFooter object to serialize
+* @returns Complete XML string for header*.xml or footer*.xml
+*/
+function serializeHeaderFooter(hf) {
+	const rootTag = hf.type === "header" ? "w:hdr" : "w:ftr";
+	const nsDecl = buildNamespaceDeclarations();
+	const watermarkXml = serializeWatermarkParagraph(hf);
+	const watermarkInsertIndex = hf.watermarkBlockIndex !== void 0 ? Math.max(0, Math.min(hf.watermarkBlockIndex, hf.content.length)) : 0;
+	const blocksXml = hf.content.map((block) => serializeBlock(block));
+	let contentXml;
+	if (watermarkXml) contentXml = blocksXml.slice(0, watermarkInsertIndex).join("") + watermarkXml + blocksXml.slice(watermarkInsertIndex).join("");
+	else contentXml = blocksXml.join("");
+	if (!contentXml) contentXml = "<w:p><w:pPr/></w:p>";
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<${rootTag} ${nsDecl}>${contentXml}</${rootTag}>`;
+}
+function serializeWatermarkParagraph(hf) {
+	if (hf.rawWatermarkXml) return hf.rawWatermarkXml;
+	if (hf.watermark) return synthesizeWatermarkParagraph(hf.watermark);
+	return "";
+}
+function synthesizeWatermarkParagraph(watermark) {
+	if (watermark.kind === "text") return synthesizeTextWatermark(watermark);
+	return synthesizePictureWatermark(watermark);
+}
+function synthesizeTextWatermark(watermark) {
+	const rotation = watermark.diagonal === false ? 0 : 315;
+	const fillcolor = watermark.color && watermark.color !== "auto" ? `#${watermark.color}` : "#C0C0C0";
+	const fontFamily = watermark.font ?? "Calibri";
+	const text = escapeXml(watermark.text);
+	return `<w:p><w:r><w:pict><v:shape id="PowerPlusWaterMarkObject1" type="#_x0000_t136" style="position:absolute;margin-left:0;margin-top:0;width:415pt;height:207pt;rotation:${rotation};z-index:-251658240;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin" fillcolor="${fillcolor}" stroked="f">${watermark.opacity !== void 0 ? `<v:fill opacity="${watermark.opacity}"/>` : ""}<v:textpath style="font-family:&quot;${escapeXml(fontFamily)}&quot;;font-size:1pt" string="${text}"/></v:shape></w:pict></w:r></w:p>`;
+}
+const PICTURE_WATERMARK_DEFAULT_WIDTH_PT = 415;
+const PICTURE_WATERMARK_DEFAULT_HEIGHT_PT = 207;
+const PICTURE_WATERMARK_WASHOUT_GAIN = "19661f";
+const PICTURE_WATERMARK_WASHOUT_BLACKLEVEL = "22938f";
+function synthesizePictureWatermark(watermark) {
+	const rId = escapeXml(watermark.imageRId);
+	return `<w:p><w:r><w:pict><v:shape id="WordPictureWatermark1" type="#_x0000_t75" style="position:absolute;margin-left:0;margin-top:0;width:${watermark.scale === void 0 ? watermark.widthPt ?? PICTURE_WATERMARK_DEFAULT_WIDTH_PT : PICTURE_WATERMARK_DEFAULT_WIDTH_PT * watermark.scale}pt;height:${watermark.scale === void 0 ? watermark.heightPt ?? PICTURE_WATERMARK_DEFAULT_HEIGHT_PT : PICTURE_WATERMARK_DEFAULT_HEIGHT_PT * watermark.scale}pt;z-index:-251658240;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin"><v:imagedata r:id="${rId}" o:title=""${watermark.washout === false ? "" : ` gain="${PICTURE_WATERMARK_WASHOUT_GAIN}" blacklevel="${PICTURE_WATERMARK_WASHOUT_BLACKLEVEL}"`}/></v:shape></w:pict></w:r></w:p>`;
+}
+//#endregion
+export { serializeHeaderFooter };

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

@@ -0,0 +1,19 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/noteSerializer.d.ts
+/**
+ * Serialize footnotes to a complete word/footnotes.xml string.
+ *
+ * @param footnotes - Notes to serialize (the model's normal footnotes).
+ * @returns Complete footnotes.xml string.
+ */
+declare function serializeFootnotes(footnotes: readonly document_d_exports.Footnote[]): string;
+/**
+ * Serialize endnotes to a complete word/endnotes.xml string.
+ *
+ * @param endnotes - Notes to serialize (the model's normal endnotes).
+ * @returns Complete endnotes.xml string.
+ */
+declare function serializeEndnotes(endnotes: readonly document_d_exports.Endnote[]): string;
+//#endregion
+export { serializeEndnotes, serializeFootnotes };