@office-open/xlsx 0.6.10 → 0.7.0

package/dist/index.mjs

@@ -87,6 +87,21 @@ var ContentTypes = class extends BaseXmlComponent {
 			key: `/xl/drawings/drawing${index}.xml`
 		});
 	}
+	addComments(index) {
+		this.dynamicEntries.push({
+			type: "Override",
+			contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
+			key: `/xl/comments${index}.xml`
+		});
+	}
+	addVmlDrawing() {
+		if (this.dynamicEntries.some((e) => e.type === "Default" && e.key === "vml")) return;
+		this.dynamicEntries.push({
+			type: "Default",
+			contentType: "application/vnd.openxmlformats-officedocument.vmlDrawing",
+			key: "vml"
+		});
+	}
 	addImageType(extension) {
 		const contentType = extension === "png" ? "image/png" : "image/jpeg";
 		if (this.dynamicEntries.some((e) => e.type === "Default" && e.key === extension)) return;
@@ -96,6 +111,27 @@ var ContentTypes = class extends BaseXmlComponent {
 			key: extension
 		});
 	}
+	addPivotTable(index) {
+		this.dynamicEntries.push({
+			type: "Override",
+			contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml",
+			key: `/xl/pivotTables/pivotTable${index}.xml`
+		});
+	}
+	addPivotCacheDefinition(index) {
+		this.dynamicEntries.push({
+			type: "Override",
+			contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml",
+			key: `/xl/pivotCache/pivotCacheDefinition${index}.xml`
+		});
+	}
+	addPivotCacheRecords(index) {
+		this.dynamicEntries.push({
+			type: "Override",
+			contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml",
+			key: `/xl/pivotCache/pivotCacheRecords${index}.xml`
+		});
+	}
 	toXml(_context) {
 		const p = ["<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">", STATIC_XML];
 		for (const e of this.dynamicEntries) if (e.type === "Default") p.push(`<Default ContentType="${e.contentType}" Extension="${e.key}"/>`);
@@ -241,6 +277,7 @@ var Styles = class extends BaseXmlComponent {
 		numFmtId: 0
 	}];
 	cellXfKeys = /* @__PURE__ */ new Map();
+	dxfs = [];
 	constructor() {
 		super("styleSheet");
 		this.fontKeys.set(fontKey(this.fonts[0]), 0);
@@ -269,6 +306,15 @@ var Styles = class extends BaseXmlComponent {
 		this.cellXfKeys.set(key, idx);
 		return idx;
 	}
+	/**
+	* Register a differential format and return its index (dxfId).
+	* Used by conditional formatting rules.
+	*/
+	registerDxf(opts) {
+		const idx = this.dxfs.length;
+		this.dxfs.push(opts);
+		return idx;
+	}
 	registerFont(opts) {
 		if (!opts) return 0;
 		const key = fontKey(opts);
@@ -357,7 +403,22 @@ var Styles = class extends BaseXmlComponent {
 		}
 		p.push("</cellXfs>");
 		p.push("<cellStyles count=\"1\"><cellStyle name=\"Normal\" xfId=\"0\" builtinId=\"0\"/></cellStyles>");
-		p.push("<dxfs count=\"0\"/>");
+		if (this.dxfs.length > 0) {
+			p.push(`<dxfs count="${this.dxfs.length}">`);
+			for (const dxf of this.dxfs) {
+				const dParts = [];
+				if (dxf.font) dParts.push(`<font>${this.fontXmlStr(dxf.font)}</font>`);
+				if (dxf.fill) {
+					const bgColor = dxf.fill.color ? `<bgColor rgb="FF${dxf.fill.color}"/>` : "";
+					const patAttrs = attrs({ patternType: dxf.fill.patternType ?? "solid" });
+					dParts.push(`<fill><patternFill${patAttrs}>${bgColor}</patternFill></fill>`);
+				}
+				if (dxf.numFmt) dParts.push(`<numFmt formatCode="${escapeXml(dxf.numFmt)}"/>`);
+				if (dParts.length > 0) p.push(`<dxf>${dParts.join("")}</dxf>`);
+				else p.push("<dxf/>");
+			}
+			p.push("</dxfs>");
+		} else p.push("<dxfs count=\"0\"/>");
 		p.push("<tableStyles count=\"0\" defaultTableStyle=\"TableStyleMedium2\" defaultPivotStyle=\"PivotStyleLight16\"/>");
 		p.push("<extLst/>");
 		p.push("</styleSheet>");
@@ -432,13 +493,17 @@ var DefaultTheme = class extends BaseXmlComponent {
 */
 var WorkbookXml = class extends BaseXmlComponent {
 	sheets;
-	constructor(sheets) {
+	pivotCaches;
+	constructor(sheets, pivotCaches) {
 		super("workbook");
 		this.sheets = sheets;
+		this.pivotCaches = pivotCaches ?? [];
 	}
 	toXml(_context) {
 		const p = [
-			"<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">",
+			"<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"x15 xr xr6 xr10 xr2\" xmlns:x15=\"http://schemas.microsoft.com/office/spreadsheetml/2010/11/main\" xmlns:xr=\"http://schemas.microsoft.com/office/spreadsheetml/2014/revision\" xmlns:xr6=\"http://schemas.microsoft.com/office/spreadsheetml/2016/revision6\" xmlns:xr10=\"http://schemas.microsoft.com/office/spreadsheetml/2016/revision10\" xmlns:xr2=\"http://schemas.microsoft.com/office/spreadsheetml/2015/revision2\">",
+			"<fileVersion appName=\"xl\" lastEdited=\"7\" lowestEdited=\"6\" rupBuild=\"29929\"/>",
+			"<workbookPr/>",
 			"<bookViews><workbookView xWindow=\"0\" yWindow=\"0\" windowWidth=\"28800\" windowHeight=\"12300\"/></bookViews>",
 			"<sheets>"
 		];
@@ -446,7 +511,14 @@ var WorkbookXml = class extends BaseXmlComponent {
 			const stateAttr = s.state && s.state !== "visible" ? ` state="${s.state}"` : "";
 			p.push(`<sheet name="${escapeXml(s.name)}" sheetId="${s.sheetId}" r:id="${s.rId}"${stateAttr}/>`);
 		}
-		p.push("</sheets><calcPr calcId=\"191029\"/></workbook>");
+		p.push("</sheets>");
+		p.push("<calcPr calcId=\"162913\"/>");
+		if (this.pivotCaches.length > 0) {
+			p.push("<pivotCaches>");
+			for (const pc of this.pivotCaches) p.push(`<pivotCache cacheId="${pc.cacheId}" r:id="${pc.rId}"/>`);
+			p.push("</pivotCaches>");
+		}
+		p.push("</workbook>");
 		return p.join("");
 	}
 };
@@ -468,22 +540,38 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 	columns;
 	mergeCells;
 	freezePanes;
+	protection;
 	autoFilter;
 	images;
 	chartOptions;
 	dataValidations;
 	conditionalFormats;
+	hyperlinks;
+	comments;
+	headerFooter;
+	pageSetup;
+	tabColor;
+	sheetView;
+	pivotTableOptions;
 	constructor(options) {
 		super("worksheet");
 		this.rows = options.rows ?? [];
 		this.columns = options.columns ?? [];
 		this.mergeCells = options.mergeCells ?? [];
 		this.freezePanes = options.freezePanes;
+		this.protection = options.protection;
 		this.autoFilter = options.autoFilter;
 		this.images = options.images ?? [];
 		this.chartOptions = options.charts ?? [];
 		this.dataValidations = options.dataValidations ?? [];
 		this.conditionalFormats = options.conditionalFormats ?? [];
+		this.hyperlinks = options.hyperlinks ?? [];
+		this.comments = options.comments ?? [];
+		this.headerFooter = options.headerFooter;
+		this.pageSetup = options.pageSetup;
+		this.tabColor = options.tabColor;
+		this.sheetView = options.sheetView;
+		this.pivotTableOptions = options.pivotTables ?? [];
 	}
 	get imageOptions() {
 		return this.images;
@@ -491,6 +579,18 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 	get charts() {
 		return this.chartOptions;
 	}
+	get hyperlinkOptions() {
+		return this.hyperlinks;
+	}
+	get worksheetRows() {
+		return this.rows;
+	}
+	get commentOptions() {
+		return this.comments;
+	}
+	get pivotTables() {
+		return this.pivotTableOptions;
+	}
 	/**
 	* Zero-allocation fast path: directly concatenate XML string.
 	* Bypasses the IXmlableObject intermediate tree entirely.
@@ -499,7 +599,22 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 		const fileData = context.fileData;
 		const sharedStrings = fileData?.sharedStrings;
 		const styles = fileData?.styles;
-		const p = ["<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">"];
+		const p = ["<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"x14ac xr xr2 xr3\" xmlns:x14ac=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac\" xmlns:xr=\"http://schemas.microsoft.com/office/spreadsheetml/2014/revision\" xmlns:xr2=\"http://schemas.microsoft.com/office/spreadsheetml/2015/revision2\" xmlns:xr3=\"http://schemas.microsoft.com/office/spreadsheetml/2016/revision3\">"];
+		const hasTabColor = !!this.tabColor;
+		const hasOutline = this.columns.some((c) => c.outlineLevel !== void 0);
+		if (hasTabColor || hasOutline) {
+			const prParts = [];
+			if (this.tabColor) {
+				const tc = this.tabColor;
+				const tcAttrs = {};
+				if (tc.rgb) tcAttrs.rgb = tc.rgb;
+				if (tc.theme !== void 0) tcAttrs.theme = tc.theme;
+				if (tc.tint !== void 0) tcAttrs.tint = tc.tint;
+				prParts.push(`<tabColor${attrs(tcAttrs)}/>`);
+			}
+			if (hasOutline) prParts.push("<outlinePr summaryBelow=\"1\" summaryRight=\"1\"/>");
+			p.push(`<sheetPr>${prParts.join("")}</sheetPr>`);
+		}
 		const maxRow = this.rows.length;
 		let maxCol = 0;
 		for (const row of this.rows) if (row.cells && row.cells.length > maxCol) maxCol = row.cells.length;
@@ -515,8 +630,12 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 			const leftCol = fp.col ? fp.col + 1 : 1;
 			const topLeftCell = this.defaultCellRef(topRow, leftCol);
 			const activePane = ySplit > 0 && xSplit > 0 ? "bottomRight" : ySplit > 0 ? "bottomLeft" : "topRight";
-			p.push("<sheetViews><sheetView tabSelected=\"1\" workbookViewId=\"0\">", `<pane ySplit="${ySplit}" xSplit="${xSplit}" topLeftCell="${topLeftCell}" activePane="${activePane}" state="frozen"/>`, "</sheetView></sheetViews>");
-		} else p.push("<sheetViews><sheetView tabSelected=\"1\" workbookViewId=\"0\"/></sheetViews>");
+			const svAttrs = this.buildSheetViewAttrs();
+			p.push(`<sheetViews><sheetView${svAttrs}>`, `<pane ySplit="${ySplit}" xSplit="${xSplit}" topLeftCell="${topLeftCell}" activePane="${activePane}" state="frozen"/>`, "</sheetView></sheetViews>");
+		} else {
+			const svAttrs = this.buildSheetViewAttrs();
+			p.push(`<sheetViews><sheetView${svAttrs}/></sheetViews>`);
+		}
 		p.push("<sheetFormatPr defaultRowHeight=\"15\"/>");
 		if (this.columns.length > 0) {
 			p.push("<cols>");
@@ -530,6 +649,8 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 					colAttrs.customWidth = 1;
 				}
 				if (col.hidden) colAttrs.hidden = 1;
+				if (col.outlineLevel !== void 0) colAttrs.outlineLevel = col.outlineLevel;
+				if (col.collapsed) colAttrs.collapsed = 1;
 				p.push(selfCloseElement("col", attrs(colAttrs)));
 			}
 			p.push("</cols>");
@@ -556,7 +677,62 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 			} else p.push(`<row${attrs(rowAttrs)}/>`);
 		}
 		p.push("</sheetData>");
-		if (this.autoFilter) p.push(selfCloseElement("autoFilter", attrs({ ref: this.autoFilter })));
+		if (this.protection) {
+			const prot = this.protection;
+			const protAttrs = {};
+			if (prot.password) protAttrs.password = this.hashPassword(prot.password);
+			if (prot.sheet) protAttrs.sheet = 1;
+			if (prot.objects) protAttrs.objects = 1;
+			if (prot.scenarios) protAttrs.scenarios = 1;
+			if (prot.formatCells === false) protAttrs.formatCells = 0;
+			if (prot.formatColumns === false) protAttrs.formatColumns = 0;
+			if (prot.formatRows === false) protAttrs.formatRows = 0;
+			if (prot.insertColumns === false) protAttrs.insertColumns = 0;
+			if (prot.insertRows === false) protAttrs.insertRows = 0;
+			if (prot.insertHyperlinks === false) protAttrs.insertHyperlinks = 0;
+			if (prot.deleteColumns === false) protAttrs.deleteColumns = 0;
+			if (prot.deleteRows === false) protAttrs.deleteRows = 0;
+			if (prot.selectLockedCells) protAttrs.selectLockedCells = 1;
+			if (prot.sort === false) protAttrs.sort = 0;
+			if (prot.autoFilter === false) protAttrs.autoFilter = 0;
+			if (prot.pivotTables === false) protAttrs.pivotTables = 0;
+			if (prot.selectUnlockedCells) protAttrs.selectUnlockedCells = 1;
+			p.push(selfCloseElement("sheetProtection", attrs(protAttrs)));
+		}
+		if (this.autoFilter) if (typeof this.autoFilter === "string") p.push(selfCloseElement("autoFilter", attrs({ ref: this.autoFilter })));
+		else {
+			const af = this.autoFilter;
+			const inner = [];
+			for (const t10 of af.top10 ?? []) {
+				const t10Attrs = { val: t10.val };
+				if (t10.top === false) t10Attrs.top = 0;
+				if (t10.percent) t10Attrs.percent = 1;
+				inner.push(`<filterColumn colId="${t10.colId}"><top10${attrs(t10Attrs)}/></filterColumn>`);
+			}
+			for (const cf of af.customFilters ?? []) {
+				const cfAttrs = {};
+				if (cf.and) cfAttrs.and = 1;
+				const filters = [];
+				if (cf.val !== void 0) {
+					const fAttrs = { val: cf.val };
+					if (cf.operator) fAttrs.operator = cf.operator;
+					filters.push(selfCloseElement("customFilter", attrs(fAttrs)));
+				}
+				if (cf.val2 !== void 0) filters.push(selfCloseElement("customFilter", attrs({ val: cf.val2 })));
+				if (filters.length > 0) inner.push(`<filterColumn colId="${cf.colId}"><customFilters${attrs(cfAttrs)}>${filters.join("")}</customFilters></filterColumn>`);
+			}
+			if (af.sort && af.sort.length > 0) {
+				const sortParts = [];
+				for (const sc of af.sort) {
+					const scAttrs = { ref: sc.ref };
+					if (sc.descending) scAttrs.descending = 1;
+					sortParts.push(selfCloseElement("sortCondition", attrs(scAttrs)));
+				}
+				inner.push(`<sortState ref="${af.ref}">${sortParts.join("")}</sortState>`);
+			}
+			if (inner.length > 0) p.push(`<autoFilter ref="${af.ref}">`, ...inner, "</autoFilter>");
+			else p.push(selfCloseElement("autoFilter", attrs({ ref: af.ref })));
+		}
 		if (this.mergeCells.length > 0) {
 			p.push(`<mergeCells count="${this.mergeCells.length}">`);
 			for (const mc of this.mergeCells) {
@@ -604,10 +780,82 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 			}
 			p.push("</dataValidations>");
 		}
+		if (this.hyperlinks.length > 0) {
+			p.push("<hyperlinks>");
+			let hlIdx = 0;
+			for (const hl of this.hyperlinks) {
+				const hlAttrs = { ref: hl.cell };
+				if (hl.target.type === "external") {
+					hlIdx++;
+					hlAttrs["r:id"] = `rId${hlIdx}`;
+				} else hlAttrs.location = hl.target.location;
+				if (hl.tooltip) hlAttrs.tooltip = hl.tooltip;
+				if (hl.display) hlAttrs.display = hl.display;
+				p.push(selfCloseElement("hyperlink", attrs(hlAttrs)));
+			}
+			p.push("</hyperlinks>");
+		}
 		p.push("<pageMargins left=\"0.75\" right=\"0.75\" top=\"1\" bottom=\"1\" header=\"0.5\" footer=\"0.5\"/>");
+		if (this.pageSetup) {
+			const ps = this.pageSetup;
+			const psAttrs = {};
+			if (ps.paperSize !== void 0) psAttrs.paperSize = ps.paperSize;
+			if (ps.orientation && ps.orientation !== "default") psAttrs.orientation = ps.orientation;
+			if (ps.scale !== void 0) psAttrs.scale = ps.scale;
+			if (ps.fitToWidth !== void 0) psAttrs.fitToWidth = ps.fitToWidth;
+			if (ps.fitToHeight !== void 0) psAttrs.fitToHeight = ps.fitToHeight;
+			if (ps.pageOrder && ps.pageOrder !== "downThenOver") psAttrs.pageOrder = ps.pageOrder;
+			if (ps.useFirstPageNumber) psAttrs.useFirstPageNumber = 1;
+			if (ps.firstPageNumber !== void 0) psAttrs.firstPageNumber = ps.firstPageNumber;
+			p.push(selfCloseElement("pageSetup", attrs(psAttrs)));
+		}
+		if (this.headerFooter) {
+			const hf = this.headerFooter;
+			const hfAttrs = {};
+			if (hf.differentOddEven) hfAttrs.differentOddEven = 1;
+			if (hf.differentFirst) hfAttrs.differentFirst = 1;
+			const inner = [];
+			if (hf.oddHeader) inner.push(`<oddHeader>${escapeXml(hf.oddHeader)}</oddHeader>`);
+			if (hf.oddFooter) inner.push(`<oddFooter>${escapeXml(hf.oddFooter)}</oddFooter>`);
+			if (hf.evenHeader) inner.push(`<evenHeader>${escapeXml(hf.evenHeader)}</evenHeader>`);
+			if (hf.evenFooter) inner.push(`<evenFooter>${escapeXml(hf.evenFooter)}</evenFooter>`);
+			if (hf.firstHeader) inner.push(`<firstHeader>${escapeXml(hf.firstHeader)}</firstHeader>`);
+			if (hf.firstFooter) inner.push(`<firstFooter>${escapeXml(hf.firstFooter)}</firstFooter>`);
+			if (inner.length > 0) p.push(`<headerFooter${attrs(hfAttrs)}>`, ...inner, "</headerFooter>");
+			else if (hfAttrs.differentOddEven || hfAttrs.differentFirst) p.push(selfCloseElement("headerFooter", attrs(hfAttrs)));
+		}
 		p.push("</worksheet>");
 		return p.join("");
 	}
+	buildSheetViewAttrs() {
+		const sv = this.sheetView;
+		const svMap = { workbookViewId: 0 };
+		if (sv?.tabSelected !== void 0) svMap.tabSelected = sv.tabSelected ? 1 : 0;
+		else svMap.tabSelected = 1;
+		if (sv?.showGridLines === false) svMap.showGridLines = 0;
+		if (sv?.showRowColHeaders === false) svMap.showRowColHeaders = 0;
+		if (sv?.showZeros === false) svMap.showZeros = 0;
+		if (sv?.zoomScale !== void 0) svMap.zoomScale = sv.zoomScale;
+		if (sv?.rightToLeft) svMap.rightToLeft = 1;
+		return attrs(svMap);
+	}
+	/**
+	* Excel legacy password hash (16-bit, little-endian hex).
+	* Matches the algorithm used by ECMA-376 Part 1, §18.2.27.
+	*/
+	hashPassword(password) {
+		let hash = 0;
+		for (let i = 0; i < password.length; i++) {
+			const c = password.charCodeAt(i);
+			hash = (hash >> 14 & 1) + (hash << 1 & 32767);
+			hash ^= c;
+			hash = hash & 16384 ? hash ^ 1 : hash;
+		}
+		hash = (hash >> 14 & 1) + (hash << 1 & 32767);
+		hash = (hash >> 14 & 1) + (hash << 1 & 32767);
+		hash ^= password.length;
+		return hash.toString(16).toUpperCase().padStart(4, "0");
+	}
 	/**
 	* Build the <f> element string for a cell formula.
 	*/
@@ -695,6 +943,7 @@ var Worksheet = class extends IgnoreIfEmptyXmlComponent {
 var File = class {
 	worksheetOptions;
 	corePropsOptions;
+	dxfOptions;
 	_coreProperties;
 	_appProperties;
 	_contentTypes;
@@ -707,9 +956,11 @@ var File = class {
 	_fileRels;
 	_workbookRels;
 	_charts;
+	_pivotCacheRefs = [];
 	constructor(options) {
 		this.worksheetOptions = options.worksheets ?? [];
 		this.corePropsOptions = options;
+		this.dxfOptions = options.dxfs ?? [];
 	}
 	get coreProperties() {
 		return this._coreProperties ??= new CoreProperties(this.corePropsOptions);
@@ -730,6 +981,13 @@ var File = class {
 	get styles() {
 		return this._styles ??= new Styles();
 	}
+	/**
+	* Register a differential format and return its dxfId.
+	* Call this before generating XML to use the ID in conditional formatting rules.
+	*/
+	registerDxf(opts) {
+		return this.styles.registerDxf(opts);
+	}
 	get theme() {
 		return this._theme ??= new DefaultTheme();
 	}
@@ -740,7 +998,7 @@ var File = class {
 				sheetId: i + 1,
 				rId: `rId${i + 1}`
 			}));
-			this._workbookXml = new WorkbookXml(sheets);
+			this._workbookXml = new WorkbookXml(sheets, this._pivotCacheRefs);
 		}
 		return this._workbookXml;
 	}
@@ -753,6 +1011,21 @@ var File = class {
 	get charts() {
 		return this._charts ??= new ChartCollection();
 	}
+	get dxfEntries() {
+		return this.dxfOptions;
+	}
+	get pivotCacheRefs() {
+		return this._pivotCacheRefs;
+	}
+	registerPivotCache(cacheId, rId) {
+		this._pivotCacheRefs.push({
+			cacheId,
+			rId
+		});
+	}
+	get worksheetConfigs() {
+		return this.worksheetOptions;
+	}
 	get worksheets() {
 		if (!this._worksheets) this._worksheets = this.worksheetOptions.map((ws) => new Worksheet(ws));
 		return this._worksheets;
@@ -779,6 +1052,41 @@ var File = class {
 	}
 };
 //#endregion
+//#region src/file/comments.ts
+/**
+* Generates xl/comments{n}.xml — cell comment data.
+*
+* @module
+*/
+var Comments = class extends BaseXmlComponent {
+	entries;
+	constructor(entries) {
+		super("comments");
+		this.entries = entries;
+	}
+	toXml(_context) {
+		const authors = this.collectAuthors();
+		const p = ["<comments xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">", `<authors>`];
+		for (const author of authors) p.push(`<author>${escapeXml(author)}</author>`);
+		p.push("</authors><commentList>");
+		for (const entry of this.entries) {
+			const authorId = authors.indexOf(entry.author);
+			p.push(`<comment ref="${entry.cell}" authorId="${authorId}"><text><t>${escapeXml(entry.text)}</t></text></comment>`);
+		}
+		p.push("</commentList></comments>");
+		return p.join("");
+	}
+	collectAuthors() {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const entry of this.entries) if (!seen.has(entry.author)) {
+			seen.add(entry.author);
+			result.push(entry.author);
+		}
+		return result.length > 0 ? result : [""];
+	}
+};
+//#endregion
 //#region src/file/drawing/drawing.ts
 /**
 * XLSX Drawing component — generates xl/drawings/drawing{n}.xml.
@@ -816,6 +1124,387 @@ var Drawing = class extends BaseXmlComponent {
 	}
 };
 //#endregion
+//#region src/file/pivot/pivot-utils.ts
+/**
+* Extract unique values from source data for a given field index.
+*/
+function collectUniqueValues(records, fieldIdx) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const row of records) {
+		const val = row[fieldIdx];
+		const key = String(val);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(val);
+		}
+	}
+	return result;
+}
+/**
+* Check if a field is numeric (all non-empty values are numbers).
+*/
+function isNumericField(records, fieldIdx) {
+	for (const row of records) {
+		const val = row[fieldIdx];
+		if (typeof val === "string" && val !== "") return false;
+	}
+	return true;
+}
+/**
+* Aggregate values using the specified function.
+*/
+function aggregate(values, func) {
+	if (values.length === 0) return 0;
+	switch (func) {
+		case "sum": return values.reduce((a, b) => a + b, 0);
+		case "count":
+		case "countNums": return values.length;
+		case "average": return values.reduce((a, b) => a + b, 0) / values.length;
+		case "max": return Math.max(...values);
+		case "min": return Math.min(...values);
+		case "product": return values.reduce((a, b) => a * b, 1);
+		case "var": return sampleVariance(values);
+		case "varp": return populationVariance(values);
+		case "stdDev": return Math.sqrt(sampleVariance(values));
+		case "stdDevp": return Math.sqrt(populationVariance(values));
+		default: return values.reduce((a, b) => a + b, 0);
+	}
+}
+function populationVariance(values) {
+	const mean = values.reduce((a, b) => a + b, 0) / values.length;
+	return values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+}
+function sampleVariance(values) {
+	if (values.length < 2) return 0;
+	const mean = values.reduce((a, b) => a + b, 0) / values.length;
+	return values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (values.length - 1);
+}
+//#endregion
+//#region src/file/pivot/pivot-cache-definition-xml.ts
+/**
+* PivotCacheDefinition XML generator.
+*
+* Generates xl/pivotCache/pivotCacheDefinition{N}.xml.
+* Follows CT_PivotCacheDefinition from sml.xsd.
+*
+* @module
+*/
+var PivotCacheDefinitionXml = class extends BaseXmlComponent {
+	sourceRef;
+	sourceSheet;
+	sourceData;
+	recordsRid;
+	constructor(_cacheIdx, sourceRef, sourceSheet, sourceData, recordsRid) {
+		super("pivotCacheDefinition");
+		this.sourceRef = sourceRef;
+		this.sourceSheet = sourceSheet;
+		this.sourceData = sourceData;
+		this.recordsRid = recordsRid;
+	}
+	toXml(_context) {
+		const p = [];
+		p.push(`<pivotCacheDefinition xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="${escapeXml(this.recordsRid)}" recordCount="${this.sourceData.records.length}" createdVersion="6" refreshedVersion="6" minRefreshableVersion="3">`);
+		p.push(`<cacheSource type="worksheet"><worksheetSource ref="${escapeXml(this.sourceRef)}" sheet="${escapeXml(this.sourceSheet)}"/></cacheSource>`);
+		const fields = this.sourceData.fieldNames;
+		p.push(`<cacheFields count="${fields.length}">`);
+		for (let i = 0; i < fields.length; i++) {
+			const fieldName = fields[i];
+			const numeric = isNumericField(this.sourceData.records, i);
+			const uniqueVals = collectUniqueValues(this.sourceData.records, i);
+			if (numeric) {
+				let min = Infinity;
+				let max = -Infinity;
+				for (const row of this.sourceData.records) {
+					const v = row[i];
+					if (typeof v === "number") {
+						if (v < min) min = v;
+						if (v > max) max = v;
+					}
+				}
+				if (!isFinite(min)) {
+					min = 0;
+					max = 0;
+				}
+				const allInteger = this.sourceData.records.every((row) => typeof row[i] === "number" && Number.isInteger(row[i]));
+				p.push(`<cacheField name="${escapeXml(fieldName)}" numFmtId="0"><sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="${allInteger ? "1" : "0"}" minValue="${min}" maxValue="${max}" count="${uniqueVals.length}"/></cacheField>`);
+			} else {
+				p.push(`<cacheField name="${escapeXml(fieldName)}" numFmtId="0"><sharedItems count="${uniqueVals.length}">`);
+				for (const v of uniqueVals) p.push(`<s v="${escapeXml(String(v))}"/>`);
+				p.push("</sharedItems></cacheField>");
+			}
+		}
+		p.push("</cacheFields>");
+		p.push("</pivotCacheDefinition>");
+		return p.join("");
+	}
+};
+//#endregion
+//#region src/file/pivot/pivot-cache-records-xml.ts
+/**
+* PivotCacheRecords XML generator.
+*
+* Generates xl/pivotCache/pivotCacheRecords{N}.xml.
+* Follows CT_PivotCacheRecords from sml.xsd.
+*
+* @module
+*/
+var PivotCacheRecordsXml = class extends BaseXmlComponent {
+	sourceData;
+	numericFields;
+	/** For string fields: value → sharedItems index */
+	fieldIndexMaps;
+	constructor(sourceData) {
+		super("pivotCacheRecords");
+		this.sourceData = sourceData;
+		this.numericFields = sourceData.fieldNames.map((_, i) => isNumericField(sourceData.records, i));
+		this.fieldIndexMaps = sourceData.fieldNames.map((_, i) => {
+			if (this.numericFields[i]) return /* @__PURE__ */ new Map();
+			const unique = collectUniqueValues(sourceData.records, i);
+			const map = /* @__PURE__ */ new Map();
+			for (let j = 0; j < unique.length; j++) map.set(String(unique[j]), j);
+			return map;
+		});
+	}
+	toXml(_context) {
+		const p = [];
+		p.push(`<pivotCacheRecords xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${this.sourceData.records.length}">`);
+		for (const row of this.sourceData.records) {
+			p.push("<r>");
+			for (let i = 0; i < row.length; i++) {
+				const val = row[i];
+				if (this.numericFields[i]) p.push(`<n v="${val}"/>`);
+				else {
+					const idx = this.fieldIndexMaps[i].get(String(val)) ?? 0;
+					p.push(`<x v="${idx}"/>`);
+				}
+			}
+			p.push("</r>");
+		}
+		p.push("</pivotCacheRecords>");
+		return p.join("");
+	}
+};
+//#endregion
+//#region src/file/pivot/pivot-table-xml.ts
+/**
+* PivotTableDefinition XML generator.
+*
+* Generates xl/pivotTables/pivotTable{N}.xml.
+* Follows CT_pivotTableDefinition from sml.xsd.
+*
+* @module
+*/
+var PivotTableXml = class extends BaseXmlComponent {
+	options;
+	sourceData;
+	cacheId;
+	constructor(options, sourceData, cacheId) {
+		super("pivotTableDefinition");
+		this.options = options;
+		this.sourceData = sourceData;
+		this.cacheId = cacheId;
+	}
+	toXml(_context) {
+		const o = this.options;
+		const fields = this.sourceData.fieldNames;
+		const rowFieldNames = o.rows;
+		const colFieldNames = o.columns ?? [];
+		const dataFields = o.data;
+		const style = o.style ?? "PivotStyleLight16";
+		const location = o.location ?? "A3";
+		const name = o.name ?? "PivotTable1";
+		const rowFieldIndices = rowFieldNames.map((n) => fields.indexOf(n));
+		const colFieldIndices = colFieldNames.map((n) => fields.indexOf(n));
+		const dataFieldIndices = dataFields.map((df) => fields.indexOf(df.field));
+		const pivotFieldsXml = this.buildPivotFields(rowFieldIndices, colFieldIndices, dataFieldIndices);
+		const rowFieldsXml = this.buildRowFields(rowFieldIndices);
+		const rowItemsXml = this.buildRowItems(rowFieldIndices);
+		const colFieldsXml = this.buildColFields(colFieldIndices);
+		const colItemsXml = this.buildColItems(colFieldIndices, dataFields);
+		const dataFieldsXml = this.buildDataFields(dataFields, dataFieldIndices);
+		const locationRef = this.computeLocationRef(location, rowFieldIndices, colFieldIndices, dataFields);
+		const p = [];
+		p.push(`<pivotTableDefinition xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" name="${escapeXml(name)}" cacheId="${this.cacheId}" dataCaption="Values" updatedVersion="6" minRefreshableVersion="3" createdVersion="6" applyNumberFormats="0" applyBorderFormats="0" applyFontFormats="0" applyPatternFormats="0" applyAlignmentFormats="0" applyWidthHeightFormats="1" autoFormatId="0" useAutoFormatting="1" itemPrintTitles="1" indent="0" outline="1" outlineData="1" compact="1" compactData="1" rowGrandTotals="1" colGrandTotals="1">`);
+		p.push(`<location ref="${escapeXml(locationRef)}" firstHeaderRow="1" firstDataRow="${colFieldIndices.length + 1}" firstDataCol="${rowFieldIndices.length}"/>`);
+		p.push(pivotFieldsXml);
+		p.push(rowFieldsXml);
+		p.push(rowItemsXml);
+		if (colFieldIndices.length > 0) p.push(colFieldsXml);
+		p.push(colItemsXml);
+		if (dataFields.length > 0) p.push(dataFieldsXml);
+		p.push(`<pivotTableStyleInfo name="${escapeXml(style)}" showRowHeaders="1" showColHeaders="1" showRowStripes="0" showColStripes="0" showLastColumn="1"/>`);
+		p.push("</pivotTableDefinition>");
+		return p.join("");
+	}
+	buildPivotFields(rowIndices, colIndices, dataIndices) {
+		const fields = this.sourceData.fieldNames;
+		const parts = [`<pivotFields count="${fields.length}">`];
+		for (let i = 0; i < fields.length; i++) {
+			const isRow = rowIndices.includes(i);
+			const isCol = colIndices.includes(i);
+			if (dataIndices.includes(i)) parts.push(`<pivotField dataField="1" showAll="0"/>`);
+			else if (isRow) {
+				const uniqueVals = collectUniqueValues(this.sourceData.records, i);
+				parts.push(`<pivotField axis="axisRow" showAll="0">`);
+				parts.push(`<items count="${uniqueVals.length + 1}">`);
+				for (let j = 0; j < uniqueVals.length; j++) parts.push(`<item x="${j}"/>`);
+				parts.push(`<item t="default"/>`);
+				parts.push("</items></pivotField>");
+			} else if (isCol) {
+				const uniqueVals = collectUniqueValues(this.sourceData.records, i);
+				parts.push(`<pivotField axis="axisCol" showAll="0">`);
+				parts.push(`<items count="${uniqueVals.length + 1}">`);
+				for (let j = 0; j < uniqueVals.length; j++) parts.push(`<item x="${j}"/>`);
+				parts.push(`<item t="default"/>`);
+				parts.push("</items></pivotField>");
+			} else parts.push(`<pivotField showAll="0"/>`);
+		}
+		parts.push("</pivotFields>");
+		return parts.join("");
+	}
+	buildRowFields(rowIndices) {
+		if (rowIndices.length === 0) return "<rowFields count=\"0\"/>";
+		const parts = [`<rowFields count="${rowIndices.length}">`];
+		for (const idx of rowIndices) parts.push(`<field x="${idx}"/>`);
+		parts.push("</rowFields>");
+		return parts.join("");
+	}
+	buildRowItems(rowIndices) {
+		if (rowIndices.length === 0) return "<rowItems count=\"1\"><i/></rowItems>";
+		const allUniqueCounts = [];
+		for (const idx of rowIndices) {
+			const vals = collectUniqueValues(this.sourceData.records, idx);
+			allUniqueCounts.push(vals.length);
+		}
+		if (rowIndices.length === 1) {
+			const count = allUniqueCounts[0];
+			const parts = [`<rowItems count="${count + 1}">`];
+			for (let i = 0; i < count; i++) parts.push(`<i><x v="${i}"/></i>`);
+			parts.push(`<i t="grand"><x/></i>`);
+			parts.push("</rowItems>");
+			return parts.join("");
+		}
+		const combos = cartesianOfCounts(allUniqueCounts);
+		const rowItems = [];
+		for (const combo of combos) {
+			const xParts = combo.map((v) => `<x v="${v}"/>`).join("");
+			rowItems.push(`<i>${xParts}</i>`);
+		}
+		rowItems.push(`<i t="grand">${rowIndices.map(() => "<x/>").join("")}</i>`);
+		return `<rowItems count="${rowItems.length}">${rowItems.join("")}</rowItems>`;
+	}
+	buildColFields(colIndices) {
+		if (colIndices.length === 0) return "<colFields count=\"0\"/>";
+		const parts = [`<colFields count="${colIndices.length}">`];
+		for (const idx of colIndices) parts.push(`<field x="${idx}"/>`);
+		parts.push("</colFields>");
+		return parts.join("");
+	}
+	buildColItems(colIndices, dataFields) {
+		if (colIndices.length > 0) {
+			const allUniqueCounts = [];
+			for (const idx of colIndices) {
+				const vals = collectUniqueValues(this.sourceData.records, idx);
+				allUniqueCounts.push(vals.length);
+			}
+			const combos = cartesianOfCounts(allUniqueCounts);
+			const items = [];
+			for (const combo of combos) {
+				const xParts = combo.map((v) => `<x v="${v}"/>`).join("");
+				items.push(`<i>${xParts}</i>`);
+			}
+			items.push(`<i t="grand">${colIndices.map(() => "<x/>").join("")}</i>`);
+			return `<colItems count="${items.length}">${items.join("")}</colItems>`;
+		}
+		if (dataFields.length > 1) {
+			const items = dataFields.map((_, i) => `<i><x v="${i}"/></i>`);
+			return `<colItems count="${items.length}">${items.join("")}</colItems>`;
+		}
+		return "<colItems count=\"1\"><i/></colItems>";
+	}
+	buildDataFields(dataFields, dataFieldIndices) {
+		if (dataFields.length === 0) return "<dataFields count=\"0\"/>";
+		const parts = [`<dataFields count="${dataFields.length}">`];
+		for (let i = 0; i < dataFields.length; i++) {
+			const df = dataFields[i];
+			const subtotal = df.summarize ?? "sum";
+			const name = df.name ?? `${subtotal === "sum" ? "Sum" : subtotal} of ${df.field}`;
+			parts.push(`<dataField name="${escapeXml(name)}" fld="${dataFieldIndices[i]}" subtotal="${subtotal}"/>`);
+		}
+		parts.push("</dataFields>");
+		return parts.join("");
+	}
+	computeLocationRef(location, rowFieldIndices, colFieldIndices, dataFields) {
+		const match = location.split(":")[0].match(/^([A-Z]+)(\d+)$/);
+		if (!match) return location;
+		const startCol = match[1];
+		const startRow = parseInt(match[2], 10);
+		let rowCount = 1;
+		if (rowFieldIndices.length > 0) rowCount += collectUniqueValues(this.sourceData.records, rowFieldIndices[0]).length;
+		rowCount += 1;
+		let colCount = Math.max(rowFieldIndices.length, 1);
+		if (colFieldIndices.length > 0) colCount += collectUniqueValues(this.sourceData.records, colFieldIndices[0]).length;
+		else if (dataFields.length > 1) colCount += dataFields.length - 1;
+		colCount += 1;
+		return `${startCol}${startRow}:${colIndexToLetter(letterToColIndex(startCol) + colCount - 1)}${startRow + rowCount - 1}`;
+	}
+};
+function letterToColIndex(letters) {
+	let col = 0;
+	for (let i = 0; i < letters.length; i++) col = col * 26 + (letters.charCodeAt(i) - 64);
+	return col;
+}
+function colIndexToLetter(col) {
+	let result = "";
+	let n = col;
+	while (n > 0) {
+		n--;
+		result = String.fromCharCode(65 + n % 26) + result;
+		n = Math.floor(n / 26);
+	}
+	return result;
+}
+/** Cartesian product from counts: e.g. [2, 3] → [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2]] */
+function cartesianOfCounts(counts) {
+	if (counts.length === 0) return [[]];
+	let result = [[]];
+	for (const count of counts) {
+		const next = [];
+		for (const prefix of result) for (let i = 0; i < count; i++) next.push([...prefix, i]);
+		result = next;
+	}
+	return result;
+}
+//#endregion
+//#region src/file/vml-notes.ts
+var VmlNotes = class {
+	comments;
+	constructor(comments) {
+		this.comments = comments;
+	}
+	toXml() {
+		const p = [
+			"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+			"<xml xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:x=\"urn:schemas-microsoft-com:office:excel\">",
+			"<o:shapelayout v:ext=\"edit\"><o:idmap v:ext=\"edit\" data=\"1\"/></o:shapelayout>",
+			"<v:shapetype id=\"_x0000_t202\" coordsize=\"21600,21600\" o:spt=\"202\" path=\"m,l,21600r21600,l21600,xe\">",
+			"<v:stroke joinstyle=\"miter\"/>",
+			"<v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/>",
+			"</v:shapetype>"
+		];
+		for (let i = 0; i < this.comments.length; i++) {
+			const c = this.comments[i];
+			const col = c.cell.charCodeAt(0) - 65;
+			const row = parseInt(c.cell.slice(1), 10) - 1;
+			const anchor = `${col}, 0, ${row}, 0, ${col + 2}, 0, ${row + 2}, 0`;
+			p.push(`<v:shape id="_x0000_s${1025 + i}" type="#_x0000_t202" style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:1;visibility:hidden" fillcolor="infoBackground [80]" strokecolor="none [81]" o:insetmode="auto">`, `<v:fill color2="infoBackground [80]"/>`, `<v:shadow color="none [81]" obscured="t"/>`, `<v:path o:connecttype="none"/>`, `<v:textbox style="mso-direction-alt:auto"><div style="text-align:left"/></v:textbox>`, `<x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/>`, `<x:Anchor>${anchor}</x:Anchor>`, `<x:AutoFill>False</x:AutoFill>`, `<x:Row>${row}</x:Row>`, `<x:Column>${col}</x:Column>`, `</x:ClientData>`, `</v:shape>`);
+		}
+		p.push("</xml>");
+		return p.join("");
+	}
+};
+//#endregion
 //#region src/export/packer/next-compiler.ts
 /**
 * XLSX Compiler — compiles a File object into a Zippable structure.
@@ -844,23 +1533,34 @@ var Compiler = class {
 			data: fmt(file.fileRelationships),
 			path: "_rels/.rels"
 		};
-		mapping["Workbook"] = {
-			data: fmt(file.workbookXml),
-			path: "xl/workbook.xml"
-		};
-		mapping["WorkbookRelationships"] = {
-			data: fmt(file.workbookRelationships),
-			path: "xl/_rels/workbook.xml.rels"
-		};
 		const worksheets = file.worksheets;
 		let globalMediaIdx = 0;
 		let globalChartIdx = 0;
+		let globalPivotIdx = 0;
+		let globalPivotCacheIdx = 0;
+		const pivotCacheDataMap = /* @__PURE__ */ new Map();
 		for (let i = 0; i < worksheets.length; i++) {
 			const ws = worksheets[i];
 			const imgOpts = ws.imageOptions;
 			const chartOpts = ws.charts;
+			const hlOpts = ws.hyperlinkOptions;
+			const sheetName = file.worksheetConfigs[i]?.name ?? `Sheet${i + 1}`;
 			let sheetXml = fmt(ws);
-			if (imgOpts.length > 0 || chartOpts.length > 0) {
+			const hasMedia = imgOpts.length > 0 || chartOpts.length > 0;
+			const hasExternalHyperlinks = hlOpts.some((h) => h.target.type === "external");
+			const commentOpts = ws.commentOptions;
+			const hasComments = commentOpts.length > 0;
+			const pivotOpts = ws.pivotTables;
+			const hasPivots = pivotOpts.length > 0;
+			let wsRels;
+			let nextRid = 0;
+			if (hasMedia || hasExternalHyperlinks || hasComments || hasPivots) wsRels = new Relationships();
+			if (hasExternalHyperlinks) for (const hl of hlOpts) {
+				if (hl.target.type !== "external") continue;
+				const rid = ++nextRid;
+				wsRels.addRelationship(rid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", hl.target.url, "External");
+			}
+			if (hasMedia) {
 				const drawingImages = [];
 				const drawingCharts = [];
 				const drawingRels = new Relationships();
@@ -909,25 +1609,121 @@ var Compiler = class {
 					data: fmt(drawingRels),
 					path: `xl/drawings/_rels/drawing${drawingIdx}.xml.rels`
 				};
-				sheetXml = sheetXml.slice(0, -12) + `<drawing r:id="rId${rid}"/></worksheet>`;
-				const wsRels = new Relationships();
-				wsRels.addRelationship(rid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing", `../drawings/drawing${drawingIdx}.xml`);
-				mapping[`WorksheetRels${i}`] = {
-					data: fmt(wsRels),
-					path: `xl/worksheets/_rels/sheet${i + 1}.xml.rels`
-				};
+				const drawingRid = ++nextRid;
+				sheetXml = sheetXml.slice(0, -12) + `<drawing r:id="rId${drawingRid}"/></worksheet>`;
+				wsRels.addRelationship(drawingRid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing", `../drawings/drawing${drawingIdx}.xml`);
 				file.contentTypes.addDrawing(drawingIdx);
 			}
+			if (hasComments) {
+				const commentsIdx = i + 1;
+				const commentsXml = new Comments(commentOpts);
+				mapping[`Comments${i}`] = {
+					data: fmt(commentsXml),
+					path: `xl/comments${commentsIdx}.xml`
+				};
+				const vmlNotes = new VmlNotes(commentOpts);
+				mapping[`VmlDrawing${i}`] = {
+					data: vmlNotes.toXml(),
+					path: `xl/drawings/vmlDrawing${commentsIdx}.vml`
+				};
+				const commentsRid = ++nextRid;
+				wsRels.addRelationship(commentsRid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", `../comments${commentsIdx}.xml`);
+				const vmlRid = ++nextRid;
+				wsRels.addRelationship(vmlRid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing", `../drawings/vmlDrawing${commentsIdx}.vml`);
+				sheetXml = sheetXml.slice(0, -12) + `<legacyDrawing r:id="rId${vmlRid}"/></worksheet>`;
+				file.contentTypes.addComments(commentsIdx);
+				file.contentTypes.addVmlDrawing();
+			}
+			if (hasPivots) for (const pt of pivotOpts) {
+				globalPivotIdx++;
+				const pivotIdx = globalPivotIdx;
+				const sourceSheet = pt.sourceSheet ?? sheetName;
+				const sourceWsIdx = file.worksheetConfigs.findIndex((ws) => (ws.name ?? `Sheet${file.worksheetConfigs.indexOf(ws) + 1}`) === sourceSheet);
+				if (sourceWsIdx === -1) continue;
+				const sourceWs = worksheets[sourceWsIdx];
+				const sourceData = extractPivotSourceData(sourceWs.worksheetRows, pt.source);
+				const cacheKey = `${sourceSheet}:${pt.source}`;
+				let cacheId;
+				let cacheIdx;
+				const existing = pivotCacheDataMap.get(cacheKey);
+				if (existing) {
+					cacheId = existing.cacheId;
+					cacheIdx = existing.cacheIdx;
+				} else {
+					globalPivotCacheIdx++;
+					cacheIdx = globalPivotCacheIdx;
+					cacheId = cacheIdx - 1;
+					pivotCacheDataMap.set(cacheKey, {
+						cacheId,
+						cacheIdx
+					});
+					const cacheDefRels = new Relationships();
+					cacheDefRels.addRelationship(1, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords", "pivotCacheRecords1.xml");
+					const cacheDef = new PivotCacheDefinitionXml(cacheIdx, pt.source.split(":")[0] ? pt.source : "A1", sourceSheet, sourceData, "rId1");
+					mapping[`PivotCacheDef${cacheIdx}`] = {
+						data: fmt(cacheDef),
+						path: `xl/pivotCache/pivotCacheDefinition${cacheIdx}.xml`
+					};
+					mapping[`PivotCacheDefRels${cacheIdx}`] = {
+						data: fmt(cacheDefRels),
+						path: `xl/pivotCache/_rels/pivotCacheDefinition${cacheIdx}.xml.rels`
+					};
+					const cacheRecords = new PivotCacheRecordsXml(sourceData);
+					mapping[`PivotCacheRecords${cacheIdx}`] = {
+						data: fmt(cacheRecords),
+						path: `xl/pivotCache/pivotCacheRecords${cacheIdx}.xml`
+					};
+					file.contentTypes.addPivotCacheDefinition(cacheIdx);
+					file.contentTypes.addPivotCacheRecords(cacheIdx);
+					const wbPivotRid = file.workbookRelationships.relationshipCount + 1;
+					file.workbookRelationships.addRelationship(wbPivotRid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition", `pivotCache/pivotCacheDefinition${cacheIdx}.xml`);
+					file.registerPivotCache(cacheId, `rId${wbPivotRid}`);
+				}
+				const pivotTable = new PivotTableXml(pt, sourceData, cacheId);
+				mapping[`PivotTable${pivotIdx}`] = {
+					data: fmt(pivotTable),
+					path: `xl/pivotTables/pivotTable${pivotIdx}.xml`
+				};
+				const ptRels = new Relationships();
+				ptRels.addRelationship(1, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition", `../pivotCache/pivotCacheDefinition${cacheIdx}.xml`);
+				mapping[`PivotTableRels${pivotIdx}`] = {
+					data: fmt(ptRels),
+					path: `xl/pivotTables/_rels/pivotTable${pivotIdx}.xml.rels`
+				};
+				const ptRid = ++nextRid;
+				wsRels.addRelationship(ptRid, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable", `../pivotTables/pivotTable${pivotIdx}.xml`);
+				file.contentTypes.addPivotTable(pivotIdx);
+			}
+			if (hasPivots) {
+				const rendered = renderPivotSheetData(pivotOpts, worksheets, file.sharedStrings, file.worksheetConfigs, sheetName);
+				if (rendered.sheetData.length > 0) {
+					sheetXml = sheetXml.replace(/<sheetData\/>|<sheetData><\/sheetData>/, rendered.sheetData);
+					if (!sheetXml.includes("<dimension")) sheetXml = sheetXml.replace("<sheetViews", `<dimension ref="${rendered.dimensionRef}"/><sheetViews`);
+				}
+			}
+			if (wsRels) mapping[`WorksheetRels${i}`] = {
+				data: fmt(wsRels),
+				path: `xl/worksheets/_rels/sheet${i + 1}.xml.rels`
+			};
 			mapping[`Worksheet${i}`] = {
 				data: sheetXml,
 				path: `xl/worksheets/sheet${i + 1}.xml`
 			};
 		}
+		mapping["Workbook"] = {
+			data: fmt(file.workbookXml),
+			path: "xl/workbook.xml"
+		};
+		mapping["WorkbookRelationships"] = {
+			data: fmt(file.workbookRelationships),
+			path: "xl/_rels/workbook.xml.rels"
+		};
 		const sharedStrings = file.sharedStrings;
 		if (sharedStrings.count > 0) mapping["SharedStrings"] = {
 			data: fmt(sharedStrings),
 			path: "xl/sharedStrings.xml"
 		};
+		for (const dxf of file.dxfEntries) file.registerDxf(dxf);
 		mapping["Styles"] = {
 			data: fmt(file.styles),
 			path: "xl/styles.xml"
@@ -964,6 +1760,174 @@ var Compiler = class {
 		return compileMapping(mapping, overrides, mediaFiles, mediaLevel);
 	}
 };
+/**
+* Extract source data from worksheet rows for pivot cache generation.
+*/
+function extractPivotSourceData(rows, sourceRef) {
+	const parts = sourceRef.split(":");
+	const startMatch = parts[0]?.match(/^([A-Z]+)(\d+)$/);
+	const endMatch = parts[1]?.match(/^([A-Z]+)(\d+)$/);
+	if (!startMatch) return {
+		fieldNames: [],
+		records: []
+	};
+	const startRow = parseInt(startMatch[2], 10) - 1;
+	const endRow = endMatch ? parseInt(endMatch[2], 10) - 1 : startRow;
+	const startCol = colLetterToIndex(startMatch[1]);
+	const endCol = endMatch ? colLetterToIndex(endMatch[1]) : startCol;
+	const colCount = endCol - startCol + 1;
+	const headerRow = rows[startRow];
+	const fieldNames = [];
+	if (headerRow?.cells) for (let c = startCol; c <= endCol && c < headerRow.cells.length; c++) fieldNames.push(String(headerRow.cells[c]?.value ?? `Col${c}`));
+	const records = [];
+	for (let r = startRow + 1; r <= endRow; r++) {
+		const row = rows[r];
+		if (!row?.cells) continue;
+		const record = [];
+		for (let c = startCol; c <= endCol; c++) {
+			const val = row.cells[c]?.value;
+			if (typeof val === "number") record.push(val);
+			else if (val instanceof Date) record.push(val.getTime());
+			else record.push(String(val ?? ""));
+		}
+		if (record.length === colCount) records.push(record);
+	}
+	return {
+		fieldNames,
+		records
+	};
+}
+function colLetterToIndex(letters) {
+	let col = 0;
+	for (let i = 0; i < letters.length; i++) col = col * 26 + (letters.charCodeAt(i) - 64);
+	return col - 1;
+}
+/**
+* Pre-render pivot table output as sheetData cells.
+* Excel requires this so the pivot table is visible on open without manual refresh.
+*/
+function renderPivotSheetData(pivotOpts, worksheets, sharedStrings, worksheetConfigs, currentSheetName) {
+	const rowCells = /* @__PURE__ */ new Map();
+	let maxRow = 0;
+	let maxCol = 0;
+	let minRow = Infinity;
+	let minCol = Infinity;
+	for (const pt of pivotOpts) {
+		const locMatch = (pt.location ?? "A3").match(/^([A-Z]+)(\d+)$/);
+		if (!locMatch) continue;
+		const startCol = colLetterToIndex(locMatch[1]);
+		const startRow = parseInt(locMatch[2], 10);
+		const rowFieldNames = pt.rows;
+		const dataFields = pt.data;
+		const sourceSheetName = pt.sourceSheet ?? currentSheetName;
+		const sourceWsIdx = worksheetConfigs.findIndex((ws) => (ws.name ?? `Sheet${worksheetConfigs.indexOf(ws) + 1}`) === sourceSheetName);
+		if (sourceWsIdx === -1) continue;
+		const sourceData = extractPivotSourceData(worksheets[sourceWsIdx]?.worksheetRows ?? [], pt.source);
+		if (sourceData.fieldNames.length === 0) continue;
+		const fields = sourceData.fieldNames;
+		const rowFieldIndices = rowFieldNames.map((n) => fields.indexOf(n));
+		const dataFieldIndices = dataFields.map((df) => fields.indexOf(df.field));
+		if (rowFieldIndices.some((idx) => idx === -1)) continue;
+		if (dataFieldIndices.some((idx) => idx === -1)) continue;
+		const groupMap = /* @__PURE__ */ new Map();
+		for (const record of sourceData.records) {
+			const groupKey = rowFieldIndices.map((fi) => String(record[fi])).join("|");
+			let group = groupMap.get(groupKey);
+			if (!group) {
+				group = {
+					keys: rowFieldIndices.map((fi) => record[fi]),
+					values: dataFieldIndices.map(() => [])
+				};
+				groupMap.set(groupKey, group);
+			}
+			for (let di = 0; di < dataFieldIndices.length; di++) {
+				const val = record[dataFieldIndices[di]];
+				if (typeof val === "number") group.values[di].push(val);
+			}
+		}
+		const endCol = startCol + rowFieldNames.length + dataFields.length - 1;
+		minCol = Math.min(minCol, startCol);
+		maxCol = Math.max(maxCol, endCol);
+		const addCells = (rowIdx, cells) => {
+			let arr = rowCells.get(rowIdx);
+			if (!arr) {
+				arr = [];
+				rowCells.set(rowIdx, arr);
+			}
+			arr.push(...cells);
+			minRow = Math.min(minRow, rowIdx);
+			maxRow = Math.max(maxRow, rowIdx);
+		};
+		const headerCells = [];
+		for (const rfName of rowFieldNames) {
+			const cellRef = colIndexToLetterCompiler(startCol + headerCells.length) + startRow;
+			const strIdx = sharedStrings.register(rfName);
+			headerCells.push(`<c r="${cellRef}" t="s"><v>${strIdx}</v></c>`);
+		}
+		for (const df of dataFields) {
+			const cellRef = colIndexToLetterCompiler(startCol + headerCells.length) + startRow;
+			const subtotal = df.summarize ?? "sum";
+			const dfName = df.name ?? `${subtotal === "sum" ? "Sum" : subtotal} of ${df.field}`;
+			const strIdx = sharedStrings.register(dfName);
+			headerCells.push(`<c r="${cellRef}" t="s"><v>${strIdx}</v></c>`);
+		}
+		addCells(startRow, headerCells);
+		let currentRow = startRow + 1;
+		for (const [, group] of groupMap) {
+			const cells = [];
+			for (let ri = 0; ri < group.keys.length; ri++) {
+				const cellRef = colIndexToLetterCompiler(startCol + ri) + currentRow;
+				const strIdx = sharedStrings.register(String(group.keys[ri]));
+				cells.push(`<c r="${cellRef}" t="s"><v>${strIdx}</v></c>`);
+			}
+			for (let di = 0; di < dataFields.length; di++) {
+				const cellRef = colIndexToLetterCompiler(startCol + (rowFieldNames.length + di)) + currentRow;
+				const subtotal = dataFields[di].summarize ?? "sum";
+				const result = aggregate(group.values[di], subtotal);
+				cells.push(`<c r="${cellRef}"><v>${result}</v></c>`);
+			}
+			addCells(currentRow, cells);
+			currentRow++;
+		}
+		const gtCells = [];
+		const gtStrIdx = sharedStrings.register("Grand Total");
+		gtCells.push(`<c r="${colIndexToLetterCompiler(startCol)}${currentRow}" t="s"><v>${gtStrIdx}</v></c>`);
+		for (let di = 0; di < dataFields.length; di++) {
+			const cellRef = colIndexToLetterCompiler(startCol + (rowFieldNames.length + di)) + currentRow;
+			const subtotal = dataFields[di].summarize ?? "sum";
+			const result = aggregate(sourceData.records.map((r) => r[dataFieldIndices[di]]).filter((v) => typeof v === "number"), subtotal);
+			gtCells.push(`<c r="${cellRef}"><v>${result}</v></c>`);
+		}
+		addCells(currentRow, gtCells);
+	}
+	if (rowCells.size === 0) return {
+		sheetData: "",
+		dimensionRef: ""
+	};
+	const parts = ["<sheetData>"];
+	const sortedRows = [...rowCells.entries()].sort((a, b) => a[0] - b[0]);
+	for (const [rowIdx, cells] of sortedRows) {
+		parts.push(`<row r="${rowIdx}" x14ac:dyDescent="0.25">`);
+		parts.push(...cells);
+		parts.push("</row>");
+	}
+	parts.push("</sheetData>");
+	const dimensionRef = `${colIndexToLetterCompiler(minCol === Infinity ? 0 : minCol)}${minRow === Infinity ? 1 : minRow}:${colIndexToLetterCompiler(maxCol)}${maxRow}`;
+	return {
+		sheetData: parts.join(""),
+		dimensionRef
+	};
+}
+function colIndexToLetterCompiler(col) {
+	let result = "";
+	let n = col + 1;
+	while (n > 0) {
+		n--;
+		result = String.fromCharCode(65 + n % 26) + result;
+		n = Math.floor(n / 26);
+	}
+	return result;
+}
 //#endregion
 //#region src/export/packer/packer.ts
 /**