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

package/dist/docx/footnoteParser.js

@@ -0,0 +1,270 @@
+import { findChild, findChildren, getAttributes, getChildElements, getLocalName, parseXml } from "./xmlParser.js";
+import { parseSdtProperties } from "./sdtProperties.js";
+import { parseEndnoteProperties, parseFootnoteProperties } from "./notePropertiesParser.js";
+import { parseParagraph } from "./paragraphParser.js";
+import { parseTable } from "./tableParser.js";
+//#region src/docx/footnoteParser.ts
+/**
+* Parse note type attribute
+*/
+function parseNoteType(typeAttr) {
+	switch (typeAttr) {
+		case "separator": return "separator";
+		case "continuationSeparator": return "continuationSeparator";
+		case "continuationNotice": return "continuationNotice";
+		default: return "normal";
+	}
+}
+function getNoteAttribute(element, localName) {
+	for (const [name, value] of Object.entries(getAttributes(element))) if (getLocalName(name) === localName) return value;
+	return null;
+}
+function parseNoteId(element) {
+	const id = getNoteAttribute(element, "id");
+	if (id === null) return 0;
+	const parsed = Number.parseInt(id, 10);
+	return Number.isNaN(parsed) ? 0 : parsed;
+}
+function parseNoteBlockContent(element, styles, theme, numbering, rels, media) {
+	const blocks = [];
+	for (const child of getChildElements(element)) {
+		const localName = getLocalName(child.name ?? "");
+		if (localName === "p") blocks.push(parseParagraph(child, styles, theme, numbering, rels));
+		else if (localName === "tbl") blocks.push(parseTable(child, styles, theme, numbering, rels, media));
+		else if (localName === "sdt") {
+			const sdtPr = findChild(child, "w", "sdtPr");
+			const sdtEndPr = findChild(child, "w", "sdtEndPr");
+			const sdtContent = findChild(child, "w", "sdtContent");
+			blocks.push({
+				type: "blockSdt",
+				properties: parseSdtProperties(sdtPr, sdtEndPr),
+				content: sdtContent ? parseNoteBlockContent(sdtContent, styles, theme, numbering, rels, media) : []
+			});
+		}
+	}
+	return blocks;
+}
+/**
+* Parse a single footnote element (w:footnote)
+*/
+function parseFootnote(element, styles, theme, numbering, rels, media) {
+	return {
+		type: "footnote",
+		id: parseNoteId(element),
+		noteType: parseNoteType(getNoteAttribute(element, "type")),
+		content: parseNoteBlockContent(element, styles, theme, numbering, rels, media)
+	};
+}
+/**
+* Parse footnotes.xml
+*
+* @param footnotesXml - The raw XML content of word/footnotes.xml
+* @param styles - Parsed style map for applying styles
+* @param theme - Parsed theme for color resolution
+* @param numbering - Parsed numbering definitions for lists
+* @param rels - Relationships for resolving hyperlinks
+* @param media - Media files for images
+* @returns FootnoteMap with all footnotes
+*/
+function parseFootnotes(footnotesXml, styles = null, theme = null, numbering = null, rels = null, media = null) {
+	const byId = /* @__PURE__ */ new Map();
+	const footnotes = [];
+	if (!footnotesXml) return createFootnoteMap(byId, footnotes);
+	const rootElement = parseXml(footnotesXml).elements?.find((el) => el.type === "element" && (el.name === "w:footnotes" || el.name?.endsWith(":footnotes")));
+	if (!rootElement) return createFootnoteMap(byId, footnotes);
+	const footnoteElements = findChildren(rootElement, "w", "footnote");
+	for (const fnEl of footnoteElements) {
+		const footnote = parseFootnote(fnEl, styles, theme, numbering, rels, media);
+		byId.set(footnote.id, footnote);
+		footnotes.push(footnote);
+	}
+	return createFootnoteMap(byId, footnotes);
+}
+/**
+* Create FootnoteMap object with helper methods
+*/
+function createFootnoteMap(byId, footnotes) {
+	return {
+		byId,
+		footnotes,
+		getFootnote(id) {
+			return byId.get(id);
+		},
+		hasFootnote(id) {
+			return byId.has(id);
+		},
+		getNormalFootnotes() {
+			return footnotes.filter((fn) => fn.noteType === "normal");
+		},
+		getSeparator() {
+			return footnotes.find((fn) => fn.noteType === "separator");
+		},
+		getContinuationSeparator() {
+			return footnotes.find((fn) => fn.noteType === "continuationSeparator");
+		}
+	};
+}
+/**
+* Parse a single endnote element (w:endnote)
+*/
+function parseEndnote(element, styles, theme, numbering, rels, media) {
+	return {
+		type: "endnote",
+		id: parseNoteId(element),
+		noteType: parseNoteType(getNoteAttribute(element, "type")),
+		content: parseNoteBlockContent(element, styles, theme, numbering, rels, media)
+	};
+}
+/**
+* Parse endnotes.xml
+*
+* @param endnotesXml - The raw XML content of word/endnotes.xml
+* @param styles - Parsed style map for applying styles
+* @param theme - Parsed theme for color resolution
+* @param numbering - Parsed numbering definitions for lists
+* @param rels - Relationships for resolving hyperlinks
+* @param media - Media files for images
+* @returns EndnoteMap with all endnotes
+*/
+function parseEndnotes(endnotesXml, styles = null, theme = null, numbering = null, rels = null, media = null) {
+	const byId = /* @__PURE__ */ new Map();
+	const endnotes = [];
+	if (!endnotesXml) return createEndnoteMap(byId, endnotes);
+	const rootElement = parseXml(endnotesXml).elements?.find((el) => el.type === "element" && (el.name === "w:endnotes" || el.name?.endsWith(":endnotes")));
+	if (!rootElement) return createEndnoteMap(byId, endnotes);
+	const endnoteElements = findChildren(rootElement, "w", "endnote");
+	for (const enEl of endnoteElements) {
+		const endnote = parseEndnote(enEl, styles, theme, numbering, rels, media);
+		byId.set(endnote.id, endnote);
+		endnotes.push(endnote);
+	}
+	return createEndnoteMap(byId, endnotes);
+}
+/**
+* Create EndnoteMap object with helper methods
+*/
+function createEndnoteMap(byId, endnotes) {
+	return {
+		byId,
+		endnotes,
+		getEndnote(id) {
+			return byId.get(id);
+		},
+		hasEndnote(id) {
+			return byId.has(id);
+		},
+		getNormalEndnotes() {
+			return endnotes.filter((en) => en.noteType === "normal");
+		},
+		getSeparator() {
+			return endnotes.find((en) => en.noteType === "separator");
+		},
+		getContinuationSeparator() {
+			return endnotes.find((en) => en.noteType === "continuationSeparator");
+		}
+	};
+}
+/**
+* Get plain text content of a footnote.
+*
+* Recurses into block-level SDTs so a citation slot inside a note still
+* contributes its text; without recursion, the BlockSdt addition from
+* the previous commit would silently hide the slot's body from this
+* helper.
+*/
+function getFootnoteText(footnote) {
+	return collectNoteBlockTexts(footnote.content).join("\n");
+}
+/**
+* Get plain text content of an endnote.
+*/
+function getEndnoteText(endnote) {
+	return collectNoteBlockTexts(endnote.content).join("\n");
+}
+function collectNoteBlockTexts(blocks) {
+	const texts = [];
+	for (const block of blocks) if (block.type === "paragraph") {
+		const paraTexts = [];
+		for (const content of block.content) if (content.type === "run") {
+			for (const runContent of content.content) if (runContent.type === "text") paraTexts.push(runContent.text);
+		}
+		texts.push(paraTexts.join(""));
+	} else if (block.type === "blockSdt") texts.push(...collectNoteBlockTexts(block.content));
+	return texts;
+}
+/**
+* Check if a footnote is a separator (not regular content)
+*/
+function isSeparatorFootnote(footnote) {
+	return footnote.noteType === "separator" || footnote.noteType === "continuationSeparator" || footnote.noteType === "continuationNotice";
+}
+/**
+* Check if an endnote is a separator (not regular content)
+*/
+function isSeparatorEndnote(endnote) {
+	return endnote.noteType === "separator" || endnote.noteType === "continuationSeparator" || endnote.noteType === "continuationNotice";
+}
+/**
+* Get footnote number for display (excluding separators)
+* @param footnote - The footnote to get the number for
+* @param footnoteMap - The footnote map
+* @param startNumber - Starting number (default 1)
+* @returns The display number, or null for separator footnotes
+*/
+function getFootnoteDisplayNumber(footnote, footnoteMap, startNumber = 1) {
+	if (isSeparatorFootnote(footnote)) return null;
+	const index = footnoteMap.getNormalFootnotes().findIndex((fn) => fn.id === footnote.id);
+	if (index === -1) return null;
+	return startNumber + index;
+}
+/**
+* Get endnote number for display (excluding separators)
+* @param endnote - The endnote to get the number for
+* @param endnoteMap - The endnote map
+* @param startNumber - Starting number (default 1)
+* @returns The display number, or null for separator endnotes
+*/
+function getEndnoteDisplayNumber(endnote, endnoteMap, startNumber = 1) {
+	if (isSeparatorEndnote(endnote)) return null;
+	const index = endnoteMap.getNormalEndnotes().findIndex((en) => en.id === endnote.id);
+	if (index === -1) return null;
+	return startNumber + index;
+}
+/**
+* Create an empty footnote map
+*/
+function createEmptyFootnoteMap() {
+	return createFootnoteMap(/* @__PURE__ */ new Map(), []);
+}
+/**
+* Create an empty endnote map
+*/
+function createEmptyEndnoteMap() {
+	return createEndnoteMap(/* @__PURE__ */ new Map(), []);
+}
+/**
+* Merge multiple footnote maps (e.g., from different documents)
+*/
+function mergeFootnoteMaps(...maps) {
+	const byId = /* @__PURE__ */ new Map();
+	const footnotes = [];
+	for (const map of maps) for (const fn of map.footnotes) if (!byId.has(fn.id)) {
+		byId.set(fn.id, fn);
+		footnotes.push(fn);
+	}
+	return createFootnoteMap(byId, footnotes);
+}
+/**
+* Merge multiple endnote maps (e.g., from different documents)
+*/
+function mergeEndnoteMaps(...maps) {
+	const byId = /* @__PURE__ */ new Map();
+	const endnotes = [];
+	for (const map of maps) for (const en of map.endnotes) if (!byId.has(en.id)) {
+		byId.set(en.id, en);
+		endnotes.push(en);
+	}
+	return createEndnoteMap(byId, endnotes);
+}
+//#endregion
+export { createEmptyEndnoteMap, createEmptyFootnoteMap, getEndnoteDisplayNumber, getEndnoteText, getFootnoteDisplayNumber, getFootnoteText, isSeparatorEndnote, isSeparatorFootnote, mergeEndnoteMaps, mergeFootnoteMaps, parseEndnoteProperties, parseEndnotes, parseFootnoteProperties, parseFootnotes };

package/dist/docx/headerFooterParser.d.ts

@@ -0,0 +1,119 @@
+import { document_d_exports } from "../types/document.js";
+import { NumberingMap } from "./numberingParser.js";
+import { StyleMap } from "./styleParser.js";
+import { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences } from "./headerFooterRefParser.js";
+
+//#region src/docx/headerFooterParser.d.ts
+/**
+ * Map of header/footer ID to HeaderFooter content
+ */
+type HeaderFooterMap = {
+  /** Map of rId to HeaderFooter */byId: Map<string, document_d_exports.HeaderFooter>; /** Get header/footer by rId */
+  get: (rId: string) => document_d_exports.HeaderFooter | undefined; /** Check if header/footer exists */
+  has: (rId: string) => boolean; /** Get all headers/footers */
+  getAll: () => document_d_exports.HeaderFooter[]; /** Get by type */
+  getByType: (type: document_d_exports.HeaderFooterType) => document_d_exports.HeaderFooter | undefined;
+};
+/**
+ * Parse a header XML file (word/header*.xml)
+ *
+ * @param headerXml - The raw XML content of the header file
+ * @param hdrFtrType - The type of header (default, first, even)
+ * @param styles - Parsed style map for applying styles
+ * @param theme - Parsed theme for color resolution
+ * @param numbering - Parsed numbering definitions for lists
+ * @param rels - Relationships for resolving hyperlinks/images
+ * @param media - Media files for images
+ * @returns HeaderFooter object
+ */
+declare function parseHeader(headerXml: string, hdrFtrType?: document_d_exports.HeaderFooterType, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, numbering?: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null): document_d_exports.HeaderFooter;
+/**
+ * Parse a footer XML file (word/footer*.xml)
+ *
+ * @param footerXml - The raw XML content of the footer file
+ * @param hdrFtrType - The type of footer (default, first, even)
+ * @param styles - Parsed style map for applying styles
+ * @param theme - Parsed theme for color resolution
+ * @param numbering - Parsed numbering definitions for lists
+ * @param rels - Relationships for resolving hyperlinks/images
+ * @param media - Media files for images
+ * @returns HeaderFooter object
+ */
+declare function parseFooter(footerXml: string, hdrFtrType?: document_d_exports.HeaderFooterType, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, numbering?: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null): document_d_exports.HeaderFooter;
+/**
+ * Generic function to parse either header or footer
+ *
+ * @param xml - Raw XML content
+ * @param isHeader - true for header, false for footer
+ * @param hdrFtrType - The type (default, first, even)
+ * @param styles - Style map
+ * @param theme - Theme
+ * @param numbering - Numbering definitions
+ * @param rels - Relationships
+ * @param media - Media files
+ * @returns HeaderFooter object
+ */
+declare function parseHeaderFooter(xml: string, isHeader: boolean, hdrFtrType?: document_d_exports.HeaderFooterType, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, numbering?: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null): document_d_exports.HeaderFooter;
+/**
+ * Create an empty HeaderFooterMap
+ */
+declare function createEmptyHeaderFooterMap(): HeaderFooterMap;
+/**
+ * Build a HeaderFooterMap from references and XML content
+ *
+ * @param references - Header or footer references from sectPr
+ * @param xmlContents - Map of rId to XML content
+ * @param isHeader - true for headers, false for footers
+ * @param styles - Style map
+ * @param theme - Theme
+ * @param numbering - Numbering definitions
+ * @param rels - Relationships
+ * @param media - Media files
+ * @returns HeaderFooterMap with all parsed headers/footers
+ */
+declare function buildHeaderFooterMap(references: (document_d_exports.HeaderReference | document_d_exports.FooterReference)[], xmlContents: Map<string, string>, isHeader: boolean, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, numbering?: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null): HeaderFooterMap;
+/**
+ * Get plain text content of a header/footer
+ */
+declare function getHeaderFooterText(hf: document_d_exports.HeaderFooter): string;
+/**
+ * Check if header/footer is empty (no content)
+ */
+declare function isEmptyHeaderFooter(hf: document_d_exports.HeaderFooter): boolean;
+/**
+ * Check if header/footer has page number field
+ */
+declare function hasPageNumberField(hf: document_d_exports.HeaderFooter): boolean;
+/**
+ * Get the header for a given page considering type rules
+ *
+ * @param headers - Map of type to HeaderFooter
+ * @param pageNumber - 1-based page number
+ * @param isFirstPage - Whether this is the first page of the section
+ * @param hasDifferentFirstPage - Whether different first page is enabled
+ * @param hasDifferentOddEven - Whether different odd/even pages is enabled
+ * @returns The appropriate HeaderFooter or undefined
+ */
+declare function getHeaderForPage(headers: Map<document_d_exports.HeaderFooterType, document_d_exports.HeaderFooter>, pageNumber: number, isFirstPage: boolean, hasDifferentFirstPage: boolean, hasDifferentOddEven: boolean): document_d_exports.HeaderFooter | undefined;
+/**
+ * Get the footer for a given page considering type rules
+ * (Same logic as getHeaderForPage)
+ */
+declare function getFooterForPage(footers: Map<document_d_exports.HeaderFooterType, document_d_exports.HeaderFooter>, pageNumber: number, isFirstPage: boolean, hasDifferentFirstPage: boolean, hasDifferentOddEven: boolean): document_d_exports.HeaderFooter | undefined;
+/**
+ * Convert HeaderFooterMap to type-indexed Map
+ *
+ * @param map - HeaderFooterMap
+ * @returns Map indexed by HeaderFooterType
+ */
+declare function headerFooterMapToTypeMap(map: HeaderFooterMap): Map<document_d_exports.HeaderFooterType, document_d_exports.HeaderFooter>;
+/**
+ * Check if a HeaderFooter contains any images
+ */
+declare function hasImages(hf: document_d_exports.HeaderFooter): boolean;
+/**
+ * Check if a HeaderFooter contains any tables
+ */
+declare function hasTables(hf: document_d_exports.HeaderFooter): boolean;
+//#endregion
+export { HeaderFooterMap, buildHeaderFooterMap, createEmptyHeaderFooterMap, getFooterForPage, getHeaderFooterText, getHeaderForPage, hasImages, hasPageNumberField, hasTables, headerFooterMapToTypeMap, isEmptyHeaderFooter, parseFooter, parseFooterReference, parseFooterReferences, parseHeader, parseHeaderFooter, parseHeaderReference, parseHeaderReferences };

package/dist/docx/headerFooterParser.js

@@ -0,0 +1,266 @@
+import { collectXmlnsDeclarations, parseXml } from "./xmlParser.js";
+import { parseWatermark } from "./watermarkParser.js";
+import { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences } from "./headerFooterRefParser.js";
+import { parseBlockContent } from "./blockContentParser.js";
+//#region src/docx/headerFooterParser.ts
+/**
+* Parse a header XML file (word/header*.xml)
+*
+* @param headerXml - The raw XML content of the header file
+* @param hdrFtrType - The type of header (default, first, even)
+* @param styles - Parsed style map for applying styles
+* @param theme - Parsed theme for color resolution
+* @param numbering - Parsed numbering definitions for lists
+* @param rels - Relationships for resolving hyperlinks/images
+* @param media - Media files for images
+* @returns HeaderFooter object
+*/
+function parseHeader(headerXml, hdrFtrType = "default", styles = null, theme = null, numbering = null, rels = null, media = null) {
+	const result = {
+		type: "header",
+		hdrFtrType,
+		content: []
+	};
+	if (!headerXml) return result;
+	const rootElement = parseXml(headerXml).elements?.find((el) => el.type === "element" && (el.name === "w:hdr" || el.name?.endsWith(":hdr")));
+	if (!rootElement) return result;
+	const watermarkResult = parseWatermark(rootElement);
+	if (watermarkResult) {
+		result.watermark = watermarkResult.watermark;
+		result.rawWatermarkXml = watermarkResult.rawParagraphXml;
+		result.watermarkBlockIndex = watermarkResult.blockIndex;
+	}
+	result.content = parseBlockContent(watermarkResult ? withoutChild(rootElement, watermarkResult.hostingParagraph) : rootElement, styles, theme, numbering, rels, media, {
+		inHeaderFooter: true,
+		rootXmlns: collectXmlnsDeclarations(rootElement)
+	});
+	return result;
+}
+/**
+* Return a shallow copy of `parent` whose `elements` array omits the
+* single child reference `child`. Used to skip the watermark paragraph
+* when feeding the header into `parseBlockContent` — without this the
+* body parser would emit an empty placeholder paragraph where the
+* watermark sits in the source.
+*/
+function withoutChild(parent, child) {
+	return {
+		...parent,
+		elements: (parent.elements ?? []).filter((el) => el !== child)
+	};
+}
+/**
+* Parse a footer XML file (word/footer*.xml)
+*
+* @param footerXml - The raw XML content of the footer file
+* @param hdrFtrType - The type of footer (default, first, even)
+* @param styles - Parsed style map for applying styles
+* @param theme - Parsed theme for color resolution
+* @param numbering - Parsed numbering definitions for lists
+* @param rels - Relationships for resolving hyperlinks/images
+* @param media - Media files for images
+* @returns HeaderFooter object
+*/
+function parseFooter(footerXml, hdrFtrType = "default", styles = null, theme = null, numbering = null, rels = null, media = null) {
+	const result = {
+		type: "footer",
+		hdrFtrType,
+		content: []
+	};
+	if (!footerXml) return result;
+	const rootElement = parseXml(footerXml).elements?.find((el) => el.type === "element" && (el.name === "w:ftr" || el.name?.endsWith(":ftr")));
+	if (!rootElement) return result;
+	result.content = parseBlockContent(rootElement, styles, theme, numbering, rels, media, {
+		inHeaderFooter: true,
+		rootXmlns: collectXmlnsDeclarations(rootElement)
+	});
+	return result;
+}
+/**
+* Generic function to parse either header or footer
+*
+* @param xml - Raw XML content
+* @param isHeader - true for header, false for footer
+* @param hdrFtrType - The type (default, first, even)
+* @param styles - Style map
+* @param theme - Theme
+* @param numbering - Numbering definitions
+* @param rels - Relationships
+* @param media - Media files
+* @returns HeaderFooter object
+*/
+function parseHeaderFooter(xml, isHeader, hdrFtrType = "default", styles = null, theme = null, numbering = null, rels = null, media = null) {
+	if (isHeader) return parseHeader(xml, hdrFtrType, styles, theme, numbering, rels, media);
+	return parseFooter(xml, hdrFtrType, styles, theme, numbering, rels, media);
+}
+/**
+* Create a HeaderFooterMap from parsed headers/footers
+*/
+function createHeaderFooterMap(byId) {
+	return {
+		byId,
+		get(rId) {
+			return byId.get(rId);
+		},
+		has(rId) {
+			return byId.has(rId);
+		},
+		getAll() {
+			return Array.from(byId.values());
+		},
+		getByType(type) {
+			for (const hf of byId.values()) if (hf.hdrFtrType === type) return hf;
+		}
+	};
+}
+/**
+* Create an empty HeaderFooterMap
+*/
+function createEmptyHeaderFooterMap() {
+	return createHeaderFooterMap(/* @__PURE__ */ new Map());
+}
+/**
+* Build a HeaderFooterMap from references and XML content
+*
+* @param references - Header or footer references from sectPr
+* @param xmlContents - Map of rId to XML content
+* @param isHeader - true for headers, false for footers
+* @param styles - Style map
+* @param theme - Theme
+* @param numbering - Numbering definitions
+* @param rels - Relationships
+* @param media - Media files
+* @returns HeaderFooterMap with all parsed headers/footers
+*/
+function buildHeaderFooterMap(references, xmlContents, isHeader, styles = null, theme = null, numbering = null, rels = null, media = null) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const ref of references) {
+		const xml = xmlContents.get(ref.rId);
+		if (xml) {
+			const hf = parseHeaderFooter(xml, isHeader, ref.type, styles, theme, numbering, rels, media);
+			byId.set(ref.rId, hf);
+		}
+	}
+	return createHeaderFooterMap(byId);
+}
+/**
+* Get plain text content of a header/footer
+*/
+function getHeaderFooterText(hf) {
+	const texts = [];
+	for (const item of hf.content) if (item.type === "paragraph") {
+		const paraTexts = [];
+		for (const content of item.content) if (content.type === "run") {
+			for (const runContent of content.content) if (runContent.type === "text") paraTexts.push(runContent.text);
+		}
+		texts.push(paraTexts.join(""));
+	} else if (item.type === "blockSdt") texts.push(getHeaderFooterText({
+		type: hf.type,
+		hdrFtrType: hf.hdrFtrType,
+		content: item.content
+	}));
+	else for (const row of item.rows) for (const cell of row.cells) for (const cellContent of cell.content) if (cellContent.type === "paragraph") {
+		const paraTexts = [];
+		for (const content of cellContent.content) if (content.type === "run") {
+			for (const runContent of content.content) if (runContent.type === "text") paraTexts.push(runContent.text);
+		}
+		texts.push(paraTexts.join(""));
+	}
+	return texts.join("\n");
+}
+/**
+* Check if header/footer is empty (no content)
+*/
+function isEmptyHeaderFooter(hf) {
+	if (hf.content.length === 0) return true;
+	for (const item of hf.content) {
+		if (item.type === "table") return false;
+		if (item.content.length > 0) for (const content of item.content) {
+			if (content.type !== "run") return false;
+			for (const rc of content.content) {
+				if (rc.type === "text" && rc.text.length > 0) return false;
+				if (rc.type !== "text") return false;
+			}
+		}
+	}
+	return true;
+}
+/**
+* Check if header/footer has page number field
+*/
+function hasPageNumberField(hf) {
+	for (const item of hf.content) if (item.type === "paragraph") for (const content of item.content) {
+		if ((content.type === "simpleField" || content.type === "complexField") && (content.fieldType === "PAGE" || content.fieldType === "NUMPAGES")) return true;
+		if (content.type === "run") {
+			for (const rc of content.content) if (rc.type === "fieldChar" && rc.charType === "begin") continue;
+		}
+	}
+	return false;
+}
+/**
+* Get the header for a given page considering type rules
+*
+* @param headers - Map of type to HeaderFooter
+* @param pageNumber - 1-based page number
+* @param isFirstPage - Whether this is the first page of the section
+* @param hasDifferentFirstPage - Whether different first page is enabled
+* @param hasDifferentOddEven - Whether different odd/even pages is enabled
+* @returns The appropriate HeaderFooter or undefined
+*/
+function getHeaderForPage(headers, pageNumber, isFirstPage, hasDifferentFirstPage, hasDifferentOddEven) {
+	if (isFirstPage && hasDifferentFirstPage) {
+		const firstHeader = headers.get("first");
+		if (firstHeader) return firstHeader;
+	}
+	if (hasDifferentOddEven && pageNumber % 2 === 0) {
+		const evenHeader = headers.get("even");
+		if (evenHeader) return evenHeader;
+	}
+	return headers.get("default");
+}
+/**
+* Get the footer for a given page considering type rules
+* (Same logic as getHeaderForPage)
+*/
+function getFooterForPage(footers, pageNumber, isFirstPage, hasDifferentFirstPage, hasDifferentOddEven) {
+	if (isFirstPage && hasDifferentFirstPage) {
+		const firstFooter = footers.get("first");
+		if (firstFooter) return firstFooter;
+	}
+	if (hasDifferentOddEven && pageNumber % 2 === 0) {
+		const evenFooter = footers.get("even");
+		if (evenFooter) return evenFooter;
+	}
+	return footers.get("default");
+}
+/**
+* Convert HeaderFooterMap to type-indexed Map
+*
+* @param map - HeaderFooterMap
+* @returns Map indexed by HeaderFooterType
+*/
+function headerFooterMapToTypeMap(map) {
+	const result = /* @__PURE__ */ new Map();
+	for (const hf of map.getAll()) result.set(hf.hdrFtrType, hf);
+	return result;
+}
+/**
+* Check if a HeaderFooter contains any images
+*/
+function hasImages(hf) {
+	for (const item of hf.content) if (item.type === "paragraph") {
+		for (const content of item.content) if (content.type === "run") {
+			for (const rc of content.content) if (rc.type === "drawing") return true;
+		}
+	}
+	return false;
+}
+/**
+* Check if a HeaderFooter contains any tables
+*/
+function hasTables(hf) {
+	for (const item of hf.content) if (item.type === "table") return true;
+	return false;
+}
+//#endregion
+export { buildHeaderFooterMap, createEmptyHeaderFooterMap, getFooterForPage, getHeaderFooterText, getHeaderForPage, hasImages, hasPageNumberField, hasTables, headerFooterMapToTypeMap, isEmptyHeaderFooter, parseFooter, parseFooterReference, parseFooterReferences, parseHeader, parseHeaderFooter, parseHeaderReference, parseHeaderReferences };

package/dist/docx/headerFooterRefParser.d.ts

@@ -0,0 +1,22 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/headerFooterRefParser.d.ts
+/**
+ * Parse a header reference from sectPr (w:headerReference)
+ */
+declare function parseHeaderReference(element: XmlElement): document_d_exports.HeaderReference;
+/**
+ * Parse a footer reference from sectPr (w:footerReference)
+ */
+declare function parseFooterReference(element: XmlElement): document_d_exports.FooterReference;
+/**
+ * Parse all header references from a sectPr element
+ */
+declare function parseHeaderReferences(sectPr: XmlElement): document_d_exports.HeaderReference[];
+/**
+ * Parse all footer references from a sectPr element
+ */
+declare function parseFooterReferences(sectPr: XmlElement): document_d_exports.FooterReference[];
+//#endregion
+export { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences };