reamkit 1.12.0 → 1.14.0

package/dist/esm/core/document-model/types.d.ts

@@ -235,6 +235,8 @@ export interface CellBorders {
     readonly left?: Border;
     readonly insideH?: Border;
     readonly insideV?: Border;
+    readonly diagonalDown?: Border;
+    readonly diagonalUp?: Border;
 }
 export interface CellMargins {
     readonly top?: Pt;
@@ -275,6 +277,7 @@ export interface CellProperties {
     readonly dataBar?: CellDataBar;
     readonly icon?: CellIcon;
     readonly sparkline?: CellSparkline;
+    readonly dropdown?: boolean;
 }
 export interface RowProperties {
     readonly height?: Pt;

package/dist/esm/core/ir/sheet.d.ts

@@ -1,15 +1,55 @@
-import { Chart, DocumentInfo } from '../document-model/index.js';
-import { DefinedName, ParsedWorksheet, XlsxStyles } from '../spreadsheet-model/index.js';
-import { ResourceStore } from './resources.js';
+import { Chart, DocumentInfo, ShapeBlock } from '../document-model/index.js';
+import { DefinedName, MergedRange, ParsedWorksheet, SheetRichRun, XlsxStyles } from '../spreadsheet-model/index.js';
+import { ResourceId, ResourceStore } from './resources.js';
 export interface SheetChartRef {
     readonly chartPartPath: string;
     readonly widthPt: number;
     readonly heightPt: number;
 }
+export interface SheetImageRef {
+    readonly resourceId: ResourceId;
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+export interface SheetSlicerItem {
+    readonly label: string;
+    readonly selected: boolean;
+}
+export interface SheetSlicer {
+    readonly caption: string;
+    readonly columnCount: number;
+    readonly items: ReadonlyArray<SheetSlicerItem>;
+    readonly headerHex?: string;
+    readonly selectedHex?: string;
+    readonly headerTextHex?: string;
+    readonly selectedTextHex?: string;
+}
+export interface SheetHyperlink {
+    readonly ref: MergedRange;
+    readonly url: string;
+}
+export interface SheetComment {
+    readonly ref: string;
+    readonly author?: string;
+    readonly text: string;
+    readonly threaded: boolean;
+}
+export interface SheetFormControl {
+    readonly name?: string;
+    readonly objectType?: string;
+    readonly checked?: boolean;
+    readonly value?: number;
+}
 export interface Sheet {
     readonly name: string;
     readonly grid: ParsedWorksheet;
     readonly charts?: ReadonlyArray<SheetChartRef>;
+    readonly images?: ReadonlyArray<SheetImageRef>;
+    readonly shapes?: ReadonlyArray<ShapeBlock>;
+    readonly hyperlinks?: ReadonlyArray<SheetHyperlink>;
+    readonly slicers?: ReadonlyArray<SheetSlicer>;
+    readonly comments?: ReadonlyArray<SheetComment>;
+    readonly formControls?: ReadonlyArray<SheetFormControl>;
 }
 export interface SheetDoc {
     readonly kind: 'sheet';
@@ -18,6 +58,12 @@ export interface SheetDoc {
     readonly styles: XlsxStyles;
     /** §18.4 shared string table; a cell with type 's' indexes into it. */
     readonly sharedStrings: ReadonlyArray<string>;
+    /**
+     * §18.4.4 per-index rich-text runs (E-SHEET W6), parallel to sharedStrings —
+     * `[i]` is defined only when shared string i carries per-run formatting.
+     * Render-only: the writer flattens to plain text, so it is absent on round-trip.
+     */
+    readonly sharedStringRuns?: ReadonlyArray<ReadonlyArray<SheetRichRun> | undefined>;
     /** §18.2.5 workbook defined names (print areas/titles, named ranges). */
     readonly definedNames: ReadonlyArray<DefinedName>;
     /** §18.2.28 1904 date system (serial-to-date epoch). */

package/dist/esm/core/spreadsheet-model/index.d.ts

@@ -1 +1 @@
-export type { CellType, WorksheetCell, ColumnWidth, MergedRange, RowHeight, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, ParsedWorksheet, XlsxFont, XlsxFill, XlsxBorderStyleName, XlsxBorderEdge, XlsxBorder, XlsxHorizontalAlign, XlsxVerticalAlign, XlsxCellAlignment, XlsxCellXf, XlsxStyles, DefinedName, Dxf, CfOperator, CfRuleCellIs, CfvoType, Cfvo, CfRuleColorScale, CfRuleDataBar, CfRuleIconSet, CfRule, ConditionalFormat, SparklineKind, ParsedSparkline, ExcelTable, PivotTable, SheetPane, } from './types.js';
+export type { CellType, WorksheetCell, ColumnWidth, MergedRange, RowHeight, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, ParsedWorksheet, XlsxFont, XlsxFill, XlsxBorderStyleName, XlsxBorderEdge, XlsxBorder, XlsxHorizontalAlign, XlsxVerticalAlign, XlsxCellAlignment, XlsxCellXf, XlsxStyles, DefinedName, Dxf, CfOperator, CfRuleCellIs, CfvoType, Cfvo, CfRuleColorScale, CfRuleDataBar, CfRuleIconSet, CfRuleTop10, CfRuleAboveAverage, CfRuleDupUnique, CfRuleText, CfRule, ConditionalFormat, DataValidationType, DataValidation, HyperlinkRef, HeaderFooter, FormControlRef, SheetRichRun, SparklineKind, ParsedSparkline, ExcelTable, PivotTable, SheetPane, } from './types.js';

package/dist/esm/core/spreadsheet-model/types.d.ts

@@ -58,6 +58,10 @@ export interface ParsedWorksheet {
     readonly colBreaks?: ReadonlyArray<number>;
     readonly drawingRelId?: string;
     readonly conditionalFormats?: ReadonlyArray<ConditionalFormat>;
+    readonly dataValidations?: ReadonlyArray<DataValidation>;
+    readonly hyperlinks?: ReadonlyArray<HyperlinkRef>;
+    readonly headerFooter?: HeaderFooter;
+    readonly formControls?: ReadonlyArray<FormControlRef>;
     readonly sparklines?: ReadonlyArray<ParsedSparkline>;
     readonly tablePartRelIds?: ReadonlyArray<string>;
     readonly tables?: ReadonlyArray<ExcelTable>;
@@ -127,6 +131,9 @@ export interface XlsxBorder {
     readonly right?: XlsxBorderEdge;
     readonly bottom?: XlsxBorderEdge;
     readonly left?: XlsxBorderEdge;
+    readonly diagonal?: XlsxBorderEdge;
+    readonly diagonalUp?: boolean;
+    readonly diagonalDown?: boolean;
 }
 export type XlsxHorizontalAlign = 'left' | 'center' | 'right' | 'fill' | 'justify' | 'centerContinuous' | 'distributed';
 export type XlsxVerticalAlign = 'top' | 'center' | 'bottom' | 'justify' | 'distributed';
@@ -134,6 +141,9 @@ export interface XlsxCellAlignment {
     readonly horizontal?: XlsxHorizontalAlign;
     readonly vertical?: XlsxVerticalAlign;
     readonly wrapText?: boolean;
+    readonly indent?: number;
+    readonly textRotation?: number;
+    readonly shrinkToFit?: boolean;
 }
 export interface XlsxCellXf {
     readonly numFmtId: number;
@@ -198,8 +208,77 @@ export interface CfRuleIconSet {
     readonly cfvos: ReadonlyArray<Cfvo>;
     readonly reverse?: boolean;
 }
-export type CfRule = CfRuleCellIs | CfRuleColorScale | CfRuleDataBar | CfRuleIconSet;
+export interface CfRuleTop10 {
+    readonly type: 'top10';
+    readonly priority: number;
+    readonly rank: number;
+    readonly percent: boolean;
+    readonly bottom: boolean;
+    readonly dxfId: number;
+}
+export interface CfRuleAboveAverage {
+    readonly type: 'aboveAverage';
+    readonly priority: number;
+    readonly aboveAverage: boolean;
+    readonly equalAverage: boolean;
+    readonly stdDev?: number;
+    readonly dxfId: number;
+}
+export interface CfRuleDupUnique {
+    readonly type: 'duplicateValues' | 'uniqueValues';
+    readonly priority: number;
+    readonly dxfId: number;
+}
+export interface CfRuleText {
+    readonly type: 'containsText' | 'notContainsText' | 'beginsWith' | 'endsWith';
+    readonly priority: number;
+    readonly text: string;
+    readonly dxfId: number;
+    readonly formula?: string;
+}
+export type CfRule = CfRuleCellIs | CfRuleColorScale | CfRuleDataBar | CfRuleIconSet | CfRuleTop10 | CfRuleAboveAverage | CfRuleDupUnique | CfRuleText;
 export interface ConditionalFormat {
     readonly ranges: ReadonlyArray<MergedRange>;
     readonly rules: ReadonlyArray<CfRule>;
 }
+export interface HyperlinkRef {
+    readonly ref: string;
+    readonly relId?: string;
+    readonly location?: string;
+    readonly display?: string;
+    readonly tooltip?: string;
+}
+export interface HeaderFooter {
+    readonly oddHeader?: string;
+    readonly oddFooter?: string;
+}
+export interface FormControlRef {
+    readonly name?: string;
+    readonly relId: string;
+}
+export interface SheetRichRun {
+    readonly text: string;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underline?: boolean;
+    readonly colorHex?: string;
+    readonly sizePt?: number;
+    readonly vertAlign?: 'superscript' | 'subscript';
+}
+export type DataValidationType = 'none' | 'whole' | 'decimal' | 'list' | 'date' | 'time' | 'textLength' | 'custom';
+export interface DataValidation {
+    readonly type: DataValidationType;
+    readonly ranges: ReadonlyArray<MergedRange>;
+    readonly operator?: string;
+    readonly allowBlank?: boolean;
+    readonly showDropDown?: boolean;
+    readonly showInputMessage?: boolean;
+    readonly showErrorMessage?: boolean;
+    readonly errorStyle?: string;
+    readonly formula1?: string;
+    readonly formula2?: string;
+    readonly promptTitle?: string;
+    readonly prompt?: string;
+    readonly errorTitle?: string;
+    readonly error?: string;
+}

package/dist/esm/excel/comments-parser.d.ts

@@ -0,0 +1,4 @@
+import { SheetComment } from '../core/ir/sheet.js';
+export declare function parseLegacyComments(data: Uint8Array): Array<SheetComment>;
+export declare function parsePersons(data: Uint8Array): Map<string, string>;
+export declare function parseThreadedComments(data: Uint8Array, persons: ReadonlyMap<string, string>): Array<SheetComment>;

package/dist/esm/excel/comments-parser.js

@@ -0,0 +1,104 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/comments-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false,
+	removeNSPrefix: true
+});
+function parseLegacyComments(data) {
+	const root = asObject(parser.parse(decoder.decode(data))["comments"]);
+	if (!root) return [];
+	const authors = toArray(asObject(root["authors"])?.["author"]).map((a) => textOf(a));
+	const out = [];
+	for (const c of toArray(asObject(root["commentList"])?.["comment"])) {
+		const obj = asObject(c);
+		if (!obj) continue;
+		const ref = strAttr(obj, "ref");
+		if (!ref) continue;
+		const authorIdx = Number(strAttr(obj, "authorId"));
+		const author = Number.isInteger(authorIdx) ? authors[authorIdx] : void 0;
+		const text = stripAuthorPrefix(richText(obj["text"]), author);
+		if (text.length === 0 && !author) continue;
+		out.push({
+			ref,
+			...author ? { author } : {},
+			text,
+			threaded: false
+		});
+	}
+	return out;
+}
+function parsePersons(data) {
+	const root = asObject(parser.parse(decoder.decode(data))["personList"]);
+	const map = /* @__PURE__ */ new Map();
+	if (!root) return map;
+	for (const p of toArray(root["person"])) {
+		const obj = asObject(p);
+		const id = obj ? strAttr(obj, "id") : void 0;
+		const name = obj ? strAttr(obj, "displayName") : void 0;
+		if (id && name) map.set(id, name);
+	}
+	return map;
+}
+function parseThreadedComments(data, persons) {
+	const root = asObject(parser.parse(decoder.decode(data))["ThreadedComments"]);
+	if (!root) return [];
+	const out = [];
+	for (const c of toArray(root["threadedComment"])) {
+		const obj = asObject(c);
+		if (!obj) continue;
+		const ref = strAttr(obj, "ref");
+		if (!ref) continue;
+		const personId = strAttr(obj, "personId");
+		const author = personId ? persons.get(personId) : void 0;
+		const text = textOf(obj["text"]);
+		if (text.length === 0) continue;
+		out.push({
+			ref,
+			...author ? { author } : {},
+			text,
+			threaded: true
+		});
+	}
+	return out;
+}
+function richText(node) {
+	const obj = asObject(node);
+	if (!obj) return textOf(node);
+	const direct = textOf(obj["t"]);
+	if (direct) return direct;
+	return toArray(obj["r"]).map((r) => textOf(asObject(r)?.["t"])).join("");
+}
+function stripAuthorPrefix(text, author) {
+	if (!author) return text;
+	const prefix = `${author}:`;
+	if (text.startsWith(prefix)) return text.slice(prefix.length).replace(/^\s+/, "");
+	return text;
+}
+function asObject(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function toArray(v) {
+	return Array.isArray(v) ? v : v !== void 0 ? [v] : [];
+}
+function strAttr(obj, key) {
+	const v = obj[`@_${key}`];
+	return typeof v === "string" ? v : void 0;
+}
+function textOf(node) {
+	if (typeof node === "string") return node;
+	if (typeof node === "number") return String(node);
+	const obj = asObject(node);
+	if (!obj) return "";
+	const inner = obj["#text"];
+	if (typeof inner === "string") return inner;
+	if (typeof inner === "number") return String(inner);
+	return "";
+}
+//#endregion
+export { parseLegacyComments, parsePersons, parseThreadedComments };

package/dist/esm/excel/conditional-format.d.ts

@@ -12,5 +12,5 @@ export interface CfOverride {
     };
     readonly icon?: CellIcon;
 }
-export type CellConditionalFormatter = (row: number, col: number, numericValue: number | undefined) => CfOverride | undefined;
-export declare function buildConditionalFormatter(conditionalFormats: ReadonlyArray<ConditionalFormat> | undefined, styles: XlsxStyles, cells: ReadonlyArray<WorksheetCell>): CellConditionalFormatter | undefined;
+export type CellConditionalFormatter = (row: number, col: number, numericValue: number | undefined, text: string | undefined) => CfOverride | undefined;
+export declare function buildConditionalFormatter(conditionalFormats: ReadonlyArray<ConditionalFormat> | undefined, styles: XlsxStyles, cells: ReadonlyArray<WorksheetCell>, resolveText?: (cell: WorksheetCell) => string): CellConditionalFormatter | undefined;

package/dist/esm/excel/conditional-format.js

@@ -1,5 +1,5 @@
 //#region src/excel/conditional-format.ts
-function buildConditionalFormatter(conditionalFormats, styles, cells) {
+function buildConditionalFormatter(conditionalFormats, styles, cells, resolveText) {
 	if (!conditionalFormats || conditionalFormats.length === 0) return void 0;
 	const dxfs = styles.dxfs ?? [];
 	const flat = [];
@@ -18,41 +18,72 @@ function buildConditionalFormatter(conditionalFormats, styles, cells) {
 		rule,
 		iconThresholds: resolveIconThresholds(rule, cf.ranges, cells)
 	});
+	else if (rule.type === "top10") flat.push({
+		ranges: cf.ranges,
+		rule,
+		threshold: resolveTop10(rule, cf.ranges, cells)
+	});
+	else if (rule.type === "aboveAverage") flat.push({
+		ranges: cf.ranges,
+		rule,
+		threshold: resolveAboveAverage(rule, cf.ranges, cells)
+	});
+	else if (rule.type === "duplicateValues" || rule.type === "uniqueValues") flat.push({
+		ranges: cf.ranges,
+		rule,
+		dupKeys: resolveDupUnique(rule, cf.ranges, cells, resolveText)
+	});
 	else flat.push({
 		ranges: cf.ranges,
 		rule
 	});
 	flat.sort((a, b) => a.rule.priority - b.rule.priority);
-	return (row, col, value) => {
-		if (value === void 0) return void 0;
+	return (row, col, value, text) => {
+		if (value === void 0 && (text === void 0 || text.length === 0)) return void 0;
+		const dupKey = dupKeyOf(value, text);
 		let textFmt;
 		let textClaimed = false;
 		let bar;
 		let icon;
-		for (const { ranges, rule, scale, bar: resolved, iconThresholds } of flat) {
+		const claim = (dxfId) => {
+			textFmt = dxfToOverride(dxfs[dxfId]);
+			textClaimed = true;
+		};
+		for (const { ranges, rule, scale, bar: resolved, iconThresholds, threshold, dupKeys } of flat) {
 			if (!coversCell(ranges, row, col)) continue;
 			switch (rule.type) {
 				case "cellIs":
-					if (!textClaimed && cellIsMatches(rule.operator, value, rule.formulas)) {
-						textFmt = dxfToOverride(dxfs[rule.dxfId]);
-						textClaimed = true;
-					}
+					if (!textClaimed && value !== void 0 && cellIsMatches(rule.operator, value, rule.formulas)) claim(rule.dxfId);
 					break;
 				case "colorScale":
-					if (!textClaimed && scale) {
+					if (!textClaimed && value !== void 0 && scale) {
 						textFmt = { fillHex: rgbHex(colorScaleColor(scale, value)) };
 						textClaimed = true;
 					}
 					break;
 				case "dataBar":
-					if (!bar && resolved) bar = dataBarBar(resolved, value);
+					if (!bar && value !== void 0 && resolved) bar = dataBarBar(resolved, value);
 					break;
 				case "iconSet":
-					if (!icon && iconThresholds) {
+					if (!icon && value !== void 0 && iconThresholds) {
 						const bucket = iconBucket(iconThresholds, value);
 						icon = iconToCell(rule.iconSet, iconThresholds.length, bucket, rule.reverse ?? false);
 					}
 					break;
+				case "top10":
+				case "aboveAverage":
+					if (!textClaimed && value !== void 0 && threshold && thresholdMatches(threshold, value)) claim(rule.dxfId);
+					break;
+				case "duplicateValues":
+				case "uniqueValues":
+					if (!textClaimed && dupKey !== void 0 && dupKeys?.has(dupKey)) claim(rule.dxfId);
+					break;
+				case "containsText":
+				case "notContainsText":
+				case "beginsWith":
+				case "endsWith":
+					if (!textClaimed && text !== void 0 && textRuleMatches(rule, text)) claim(rule.dxfId);
+					break;
 			}
 		}
 		if (!bar && !icon) return textFmt;
@@ -63,6 +94,26 @@ function buildConditionalFormatter(conditionalFormats, styles, cells) {
 		};
 	};
 }
+function dupKeyOf(value, text) {
+	if (value !== void 0) return `n:${value}`;
+	if (text === void 0) return void 0;
+	const k = text.trim().toLowerCase();
+	return k.length > 0 ? `s:${k}` : void 0;
+}
+function textRuleMatches(rule, text) {
+	const hay = text.toLowerCase();
+	const needle = rule.text.toLowerCase();
+	switch (rule.type) {
+		case "containsText": return hay.includes(needle);
+		case "notContainsText": return !hay.includes(needle);
+		case "beginsWith": return hay.startsWith(needle);
+		case "endsWith": return hay.endsWith(needle);
+	}
+}
+function thresholdMatches(t, value) {
+	if (t.below) return t.orEqual ? value <= t.threshold : value < t.threshold;
+	return t.orEqual ? value >= t.threshold : value > t.threshold;
+}
 function coversCell(ranges, row, col) {
 	for (const r of ranges) if (row >= r.startRow && row <= r.endRow && col >= r.startColumn && col <= r.endColumn) return true;
 	return false;
@@ -323,5 +374,56 @@ function iconColor(count, e) {
 	const ramp = ICON_RAMPS[count] ?? ICON_RAMPS[3];
 	return ramp[Math.max(0, Math.min(ramp.length - 1, e))];
 }
+function resolveTop10(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const n = vals.length;
+	const raw = rule.percent ? Math.floor(n * rule.rank / 100) : rule.rank;
+	const count = Math.max(1, Math.min(n, raw));
+	return {
+		threshold: [...vals].sort((a, b) => rule.bottom ? a - b : b - a)[count - 1],
+		below: rule.bottom,
+		orEqual: true
+	};
+}
+function resolveAboveAverage(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const mean = vals.reduce((s, v) => s + v, 0) / vals.length;
+	let threshold = mean;
+	if (rule.stdDev !== void 0 && rule.stdDev > 0) {
+		const variance = vals.reduce((s, v) => s + (v - mean) * (v - mean), 0) / vals.length;
+		const sd = Math.sqrt(variance);
+		threshold = rule.aboveAverage ? mean + rule.stdDev * sd : mean - rule.stdDev * sd;
+	}
+	return {
+		threshold,
+		below: !rule.aboveAverage,
+		orEqual: rule.equalAverage
+	};
+}
+function resolveDupUnique(rule, ranges, cells, resolveText) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const cell of cells) {
+		if (!coversCell(ranges, cell.row, cell.column)) continue;
+		const key = cellDupKey(cell, resolveText);
+		if (key === void 0) continue;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	if (counts.size === 0) return void 0;
+	const qualifies = rule.type === "duplicateValues" ? (c) => c >= 2 : (c) => c === 1;
+	const out = /* @__PURE__ */ new Set();
+	for (const [k, c] of counts) if (qualifies(c)) out.add(k);
+	return out;
+}
+function cellDupKey(cell, resolveText) {
+	if (cell.type === "n") {
+		const n = Number(cell.rawValue);
+		return Number.isFinite(n) ? `n:${n}` : void 0;
+	}
+	if (!resolveText) return void 0;
+	const k = resolveText(cell).trim().toLowerCase();
+	return k.length > 0 ? `s:${k}` : void 0;
+}
 //#endregion
 export { buildConditionalFormatter };

package/dist/esm/excel/form-control-parser.d.ts

@@ -0,0 +1,6 @@
+export interface FormControlProps {
+    readonly objectType?: string;
+    readonly checked?: boolean;
+    readonly value?: number;
+}
+export declare function parseFormControlProps(data: Uint8Array): FormControlProps;

package/dist/esm/excel/form-control-parser.js

@@ -0,0 +1,29 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/form-control-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	removeNSPrefix: true
+});
+function parseFormControlProps(data) {
+	const pr = parser.parse(decoder.decode(data))["formControlPr"];
+	const obj = pr && typeof pr === "object" ? pr : void 0;
+	if (!obj) return {};
+	const objectType = strAttr(obj, "objectType");
+	const checkedRaw = strAttr(obj, "checked");
+	const valRaw = strAttr(obj, "val");
+	const value = valRaw !== void 0 && /^-?\d+$/.test(valRaw) ? Number(valRaw) : void 0;
+	return {
+		...objectType ? { objectType } : {},
+		...checkedRaw !== void 0 ? { checked: checkedRaw === "Checked" || checkedRaw === "1" } : {},
+		...value !== void 0 ? { value } : {}
+	};
+}
+function strAttr(obj, key) {
+	const v = obj[`@_${key}`];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+export { parseFormControlProps };

package/dist/esm/excel/header-footer.d.ts

@@ -0,0 +1,2 @@
+import { BodyElement } from '../core/document-model/index.js';
+export declare function buildHeaderFooterContent(formatString: string, sheetName: string): Array<BodyElement>;

package/dist/esm/excel/header-footer.js

@@ -0,0 +1,127 @@
+//#region src/excel/header-footer.ts
+function buildHeaderFooterContent(formatString, sheetName) {
+	const regions = parseHeaderFooterString(formatString, sheetName);
+	const out = [];
+	const para = (runs, alignment) => {
+		if (runs.length > 0) out.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: { alignment },
+				runs: [...runs]
+			}
+		});
+	};
+	para(regions.left, "left");
+	para(regions.center, "center");
+	para(regions.right, "right");
+	return out;
+}
+function parseHeaderFooterString(s, sheetName) {
+	const regions = {
+		left: [],
+		center: [],
+		right: []
+	};
+	let current = regions.center;
+	let bold = false;
+	let italic = false;
+	let buf = "";
+	const runProps = () => ({
+		...bold ? { bold: true } : {},
+		...italic ? { italic: true } : {}
+	});
+	const flush = () => {
+		if (buf.length > 0) {
+			current.push({
+				text: buf,
+				properties: runProps()
+			});
+			buf = "";
+		}
+	};
+	const pushField = (field) => {
+		flush();
+		current.push({
+			text: "1",
+			properties: runProps(),
+			field
+		});
+	};
+	let i = 0;
+	while (i < s.length) {
+		const ch = s[i];
+		if (ch !== "&") {
+			buf += ch;
+			i++;
+			continue;
+		}
+		const next = s[i + 1];
+		if (next === void 0) {
+			buf += "&";
+			break;
+		}
+		if (next === "&") {
+			buf += "&";
+			i += 2;
+			continue;
+		}
+		if (next === "L" || next === "C" || next === "R") {
+			flush();
+			current = next === "L" ? regions.left : next === "R" ? regions.right : regions.center;
+			i += 2;
+			continue;
+		}
+		if (next === "P") {
+			pushField("PAGE");
+			i += 2;
+			continue;
+		}
+		if (next === "N") {
+			pushField("NUMPAGES");
+			i += 2;
+			continue;
+		}
+		if (next === "A") {
+			buf += sheetName;
+			i += 2;
+			continue;
+		}
+		if (next === "B") {
+			flush();
+			bold = !bold;
+			i += 2;
+			continue;
+		}
+		if (next === "I") {
+			flush();
+			italic = !italic;
+			i += 2;
+			continue;
+		}
+		if (next === "K") {
+			i += 2;
+			let n = 0;
+			while (n < 6 && i < s.length && /[0-9A-Fa-f]/.test(s[i])) {
+				i++;
+				n++;
+			}
+			continue;
+		}
+		if (next === "\"") {
+			i += 2;
+			while (i < s.length && s[i] !== "\"") i++;
+			if (i < s.length) i++;
+			continue;
+		}
+		if (next >= "0" && next <= "9") {
+			i += 1;
+			while (i < s.length && s[i] >= "0" && s[i] <= "9") i++;
+			continue;
+		}
+		i += 2;
+	}
+	flush();
+	return regions;
+}
+//#endregion
+export { buildHeaderFooterContent };

package/dist/esm/excel/index.d.ts

@@ -7,7 +7,7 @@ export { parseWorkbook } from './workbook-parser.js';
 export type { ParsedWorkbook, SheetReference } from './workbook-parser.js';
 export type { DefinedName } from '../core/spreadsheet-model/index.js';
 export { parseWorksheet } from './worksheet-parser.js';
-export type { CellType, ColumnWidth, ExcelTable, MergedRange, ParsedWorksheet, RowHeight, WorksheetCell, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, } from '../core/spreadsheet-model/index.js';
+export type { CellType, ColumnWidth, DataValidation, DataValidationType, HeaderFooter, HyperlinkRef, ExcelTable, MergedRange, ParsedWorksheet, RowHeight, SheetRichRun, WorksheetCell, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, } from '../core/spreadsheet-model/index.js';
 export { parseXlsxStyles, EMPTY_XLSX_STYLES } from './styles-parser.js';
 export type { XlsxBorder, XlsxBorderEdge, XlsxBorderStyleName, XlsxCellAlignment, XlsxCellXf, XlsxFill, XlsxFont, XlsxHorizontalAlign, XlsxStyles, XlsxVerticalAlign, } from '../core/spreadsheet-model/index.js';
 export { applyNumberFormat } from './number-format.js';