reamkit 1.15.3 → 1.16.0

package/dist/esm/excel/sheet-to-flow.js

@@ -1,7 +1,7 @@
 import { pt } from "../core/ir/units.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
-import { resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, slicerTable, worksheetToBody } from "./print-model.js";
+import { cellPaintsVisibly, printableHeightPt, printableWidthPt, resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, slicerTable, worksheetToBody } from "./print-model.js";
 import { buildHeaderFooterContent } from "./header-footer.js";
 //#region src/excel/sheet-to-flow.ts
 var HEADER_REL = "_xlsxHeaderDefault";
@@ -9,8 +9,8 @@ var FOOTER_REL = "_xlsxFooterDefault";
 /**
 * Project a {@link SheetDoc} into a {@link FlowDoc} (E-SHEET SA2): each grid sheet
 * becomes flow blocks (a table + chart/picture/shape/slicer frames, then comment
-* / control listings), with sheets after the first starting on a new page. The
-* first sheet's page geometry + header/footer drive the document section.
+* / control listings), with sheets after the first starting on a new page. Each
+* sheet gets its own section — its page geometry and its own header/footer.
 *
 * @param sheet   The SpreadsheetML IR tree.
 * @param options Projection knobs (the W9 reference date).
@@ -23,64 +23,117 @@ function projectSheetDoc(sheet, options = {}) {
 	let firstSheetSection;
 	const headersFooters = /* @__PURE__ */ new Map();
 	const sheetGrids = new Map(sheet.sheets.map((s) => [s.name, s.grid]));
+	let printed = 0;
+	let printableSheets = sheet.sheets.filter((s) => !s.hidden).length;
+	const visible = sheet.sheets.filter((s) => !s.hidden);
+	const fallbackSheet = visible.some((s) => sheetPrintsAnything(s, sheet.styles)) ? void 0 : visible.find((s) => hasHeaderOrFooter(s)) ?? visible[0];
 	for (let sheetIdx = 0; sheetIdx < sheet.sheets.length; sheetIdx++) {
 		const ws = sheet.sheets[sheetIdx];
-		const sheetSection = sheetIdx === 0 ? withHeaderFooter(sectionFromWorksheet(ws.grid), ws, headersFooters) : sectionFromWorksheet(ws.grid);
-		if (sheetIdx === 0) firstSheetSection = sheetSection;
-		sheetSections.push(sheetSection);
-		if (sheetIdx > 0) body.push({
-			kind: "paragraph",
-			paragraph: {
-				properties: { pageBreakBefore: true },
-				runs: []
-			}
-		});
+		if (ws.hidden) continue;
+		if (!sheetPrintsAnything(ws, sheet.styles) && ws !== fallbackSheet) {
+			printableSheets--;
+			continue;
+		}
+		const scaleSink = { value: 1 };
+		const bandSink = { lefts: [0] };
+		const drawingExtentPt = drawingReachPt(ws);
 		const printArea = resolvePrintArea(sheet.definedNames, sheetIdx);
 		const titleRows = resolvePrintTitleRows(sheet.definedNames, sheetIdx);
-		const gridLines = ws.grid.printOptions?.gridLines === true;
-		body.push(...worksheetToBody(ws.grid, sheet.sharedStrings, sheet.styles, sheet.date1904, {
+		const gridBody = worksheetToBody(ws.grid, sheet.sharedStrings, sheet.styles, sheet.date1904, {
 			...printArea ? { printArea } : {},
 			...titleRows ? { titleRows } : {},
-			gridLines,
+			gridLines: ws.grid.printOptions?.gridLines === true,
 			sheetGrids,
 			sheetName: ws.name,
 			definedNames: sheet.definedNames,
 			...ws.hyperlinks ? { hyperlinks: ws.hyperlinks } : {},
 			...sheet.sharedStringRuns ? { sharedStringRuns: sheet.sharedStringRuns } : {},
 			...options.now ? { now: options.now } : {},
-			...options.losses ? { losses: options.losses } : {}
-		}));
-		for (const ref of ws.charts ?? []) body.push({
+			...options.digitWidthPt !== void 0 ? { digitWidthPt: options.digitWidthPt } : {},
+			...sheet.styles.fonts[0]?.sizePt !== void 0 ? { defaultFontPt: sheet.styles.fonts[0].sizePt } : {},
+			...options.losses ? { losses: options.losses } : {},
+			scaleSink,
+			bandSink,
+			...drawingExtentPt ? { drawingExtentPt } : {}
+		});
+		const sheetSection = withHeaderFooter(sectionFromWorksheet(ws.grid), ws, headersFooters, scaleSink.value, sheet.styles.fonts[0]?.sizePt, printed, options.fileName, sheet.themePalette, options.now);
+		if (printed === 0) firstSheetSection = sheetSection;
+		sheetSections.push(sheetSection);
+		if (printed > 0) body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: { pageBreakBefore: true },
+				runs: []
+			}
+		});
+		const drawings = [];
+		for (const ref of ws.charts ?? []) drawings.push({
 			kind: "chart",
 			chart: {
+				...anchorFloat(ref.xPt, ref.yPt, scaleSink.value),
 				chartRelId: ref.chartPartPath,
-				width: pt(ref.widthPt),
-				height: pt(ref.heightPt),
+				width: pt(ref.widthPt * scaleSink.value),
+				height: pt(ref.heightPt * scaleSink.value),
 				paragraphProperties: {}
 			}
 		});
-		for (const img of ws.images ?? []) body.push({
+		for (const img of ws.images ?? []) drawings.push({
 			kind: "image",
 			image: {
+				...anchorFloat(img.xPt, img.yPt, scaleSink.value),
 				resource: img.resourceId,
-				width: pt(img.widthPt),
-				height: pt(img.heightPt),
+				width: pt(img.widthPt * scaleSink.value),
+				height: pt(img.heightPt * scaleSink.value),
 				paragraphProperties: {}
 			}
 		});
-		for (const shape of ws.shapes ?? []) body.push({
+		for (const shape of ws.shapes ?? []) drawings.push({
 			kind: "shape",
-			shape
+			shape: centreShape(scaleShape(shape, scaleSink.value), ws.grid, drawingExtentPt, scaleSink.value)
 		});
+		const controlBlocks = controlShapeBlocks(ws.formControls, ws.activeXControls);
+		const drawingBands = gridBody.length === 0 ? bandDrawings(controlBlocks, printableHeightPt(ws.grid), scaleSink.value, DOWN).flatMap((row) => bandDrawings(row, printableWidthPt(ws.grid), scaleSink.value)) : [controlBlocks];
+		for (let band = 0; band < drawingBands.length; band++) {
+			if (band > 0) drawings.push({
+				kind: "paragraph",
+				paragraph: {
+					properties: { pageBreakBefore: true },
+					runs: []
+				}
+			});
+			for (const shape of drawingBands[band]) drawings.push({
+				kind: "shape",
+				shape: centreShape(scaleShape(shape, scaleSink.value), ws.grid, drawingExtentPt, scaleSink.value)
+			});
+		}
+		body.push(...withDrawingsByBand(drawings, gridBody, bandSink.lefts));
 		for (const slicer of ws.slicers ?? []) body.push({
 			kind: "table",
 			table: slicerTable(slicer)
 		});
-		if (ws.comments && ws.comments.length > 0) body.push(...commentBlocks(ws.comments));
+		const printComments = ws.grid.pageSetup?.cellComments === "atEnd" || ws.grid.pageSetup?.cellComments === "asDisplayed";
+		if (ws.comments && ws.comments.length > 0) if (printComments) body.push(...commentBlocks(ws.comments));
+		else options.losses?.push({
+			severity: "dropped",
+			feature: "comments",
+			detail: `${ws.comments.length} cell note(s) not printed — <pageSetup cellComments> is "${ws.grid.pageSetup?.cellComments ?? "none"}"`,
+			where: `sheet "${ws.name}"`
+		});
 		if (ws.formControls && ws.formControls.length > 0) body.push(...formControlBlocks(ws.formControls));
 		if (ws.activeXControls && ws.activeXControls.length > 0) body.push(...activeXBlocks(ws.activeXControls));
 		sheetEnds.push(body.length);
+		printed++;
 	}
+	if (sheet.embeddedObjects) options.losses?.push({
+		severity: "dropped",
+		feature: "shapes",
+		detail: `${String(sheet.embeddedObjects)} embedded object(s) not rendered — an OLE embedding draws as an icon from a metafile preview`
+	});
+	if (sheet.metafilePictures) options.losses?.push({
+		severity: "dropped",
+		feature: "images",
+		detail: `${String(sheet.metafilePictures)} picture(s) not rendered — a WMF/EMF/PICT metafile is replayed, not embedded; the anchor keeps its space`
+	});
 	const sections = sheetSections.length > 1 ? sheetSections.map((properties, i) => ({
 		properties,
 		endIndex: sheetEnds[i]
@@ -127,7 +180,364 @@ function commentBlocks(comments) {
 	}
 	return out;
 }
+var RADIO_DIAMETER_PT = 8.4;
+var RADIO_RING_PT = .6;
+var RADIO_DOT_INSET_PT = 1.2;
+var CHECKBOX_SIDE_PT = 8.4;
+var CAPTION_GUTTER_PT = 11.5;
+var CONTROL_LINE_PT = .75;
+var GROUP_BOX_GREY = "808080";
+var DEFAULT_FORM_CONTROL_PT = 8;
+var DEFAULT_ACTIVEX_CONTROL_PT = 10;
+function formControlGlyph(objectType) {
+	switch ((objectType ?? "").toLowerCase()) {
+		case "radio": return "radio";
+		case "checkbox": return "checkbox";
+		case "gbox": return "group";
+		case "button":
+		case "buttons": return "button";
+		case "label": return "label";
+		default: return "frame";
+	}
+}
+function activeXGlyph(type) {
+	switch (type) {
+		case "option": return "radio";
+		case "checkbox": return "checkbox";
+		case "button":
+		case "toggle": return "button";
+		case "label": return "label";
+		default: return "frame";
+	}
+}
+/** A floating shape at `box`, sized and positioned in sheet points. */
+function controlShape(box, dx, dy, widthPt, heightPt, rest) {
+	return {
+		float: {
+			wrap: "none",
+			posH: {
+				relativeFrom: "margin",
+				offsetPt: pt(box.xPt + dx)
+			},
+			posV: {
+				relativeFrom: "margin",
+				offsetPt: pt(box.yPt + dy)
+			}
+		},
+		width: pt(widthPt),
+		height: pt(heightPt),
+		...rest,
+		paragraphProperties: {}
+	};
+}
+/**
+* A control drawn where the document puts it (E-SHEET W8/W10), as the widget it
+* is: an option button's ring and dot, a check box, a group box's frame, a
+* push button's outline — each with its caption beside or inside it.
+*
+* Listing the captions after the grid instead was a stand-in for having no
+* geometry to place them with. It read as a paragraph of ASCII where
+* tdf111980_radioButtons.xlsx has eleven widgets spread across the sheet, the
+* furthest of them 18cm from where we drew it.
+*/
+function controlShapes(box, glyph, caption, checked, fontSizePt) {
+	const out = [];
+	const noFill = { kind: "none" };
+	const rect = {
+		kind: "preset",
+		preset: "rect"
+	};
+	const ellipse = {
+		kind: "preset",
+		preset: "ellipse"
+	};
+	const grey = {
+		colorHex: GROUP_BOX_GREY,
+		width: pt(CONTROL_LINE_PT)
+	};
+	const black = {
+		colorHex: "000000",
+		width: pt(CONTROL_LINE_PT)
+	};
+	if (glyph === "radio" || glyph === "checkbox") {
+		const side = glyph === "radio" ? RADIO_DIAMETER_PT : CHECKBOX_SIDE_PT;
+		const top = Math.max(0, (box.heightPt - side) / 2);
+		out.push(controlShape(box, 0, top, side, side, {
+			geometry: glyph === "radio" ? ellipse : rect,
+			fill: {
+				kind: "solid",
+				colorHex: "FFFFFF"
+			},
+			line: {
+				colorHex: "000000",
+				width: pt(RADIO_RING_PT)
+			}
+		}));
+		if (checked) {
+			const mark = side - 2 * RADIO_DOT_INSET_PT;
+			if (glyph === "radio") out.push(controlShape(box, RADIO_DOT_INSET_PT, top + RADIO_DOT_INSET_PT, mark, mark, {
+				geometry: ellipse,
+				fill: {
+					kind: "solid",
+					colorHex: "000000"
+				}
+			}));
+			else for (const flipV of [false, true]) out.push(controlShape(box, RADIO_DOT_INSET_PT, top + RADIO_DOT_INSET_PT, mark, mark, {
+				geometry: {
+					kind: "preset",
+					preset: "line"
+				},
+				fill: noFill,
+				line: {
+					colorHex: "000000",
+					width: pt(RADIO_RING_PT)
+				},
+				...flipV ? { transform: { flipV: true } } : {}
+			}));
+		}
+	} else if (glyph !== "label") out.push(controlShape(box, 0, 0, box.widthPt, box.heightPt, {
+		geometry: rect,
+		fill: noFill,
+		line: glyph === "group" ? grey : black
+	}));
+	if (caption !== void 0 && caption.length > 0) {
+		const inset = glyph === "radio" || glyph === "checkbox" ? CAPTION_GUTTER_PT : 3;
+		const runs = [{
+			text: caption,
+			properties: { fontSizePt: pt(fontSizePt) }
+		}];
+		out.push(controlShape(box, 0, 0, box.widthPt, box.heightPt, {
+			geometry: rect,
+			fill: noFill,
+			text: {
+				content: [{
+					kind: "paragraph",
+					paragraph: {
+						properties: glyph === "button" ? { alignment: "center" } : {},
+						runs
+					}
+				}],
+				insetLeft: pt(inset),
+				insetTop: pt(1),
+				insetRight: pt(1),
+				insetBottom: pt(1),
+				anchor: glyph === "group" ? "t" : "ctr"
+			}
+		}));
+	}
+	return out;
+}
+/**
+* Split floating drawings into page-wide bands, left to right — the "down, then
+* over" order a wide sheet prints in (§18.3.1.63 `pageOrder`), applied to the
+* drawing layer when there is no grid whose column bands it could follow.
+*
+* Each band is shifted back to the page's left margin, so band 2 starts where
+* the printable width ran out. A drawing straddling the boundary belongs to the
+* band its left edge is in, which is where the reference draws it too — the
+* part past the edge is clipped on that page and continues on the next.
+*/
+/**
+* Whether a sheet has anything to put on a page.
+*
+* A cell that carries a value or inline text, any drawing, control or slicer,
+* or a printed note. A tab nobody touched has none of those, and Excel and
+* LibreOffice both leave it out of the print — a header or footer does not
+* rescue it.
+*
+* @param ws The sheet.
+* @returns True when the sheet would print something.
+*/
+/**
+* Whether a sheet carries a header or footer with anything in it.
+*
+* @param ws The sheet.
+* @returns True when either band has a non-empty format string.
+*/
+function hasHeaderOrFooter(ws) {
+	const hf = ws.grid.headerFooter;
+	return Boolean(hf && ((hf.oddHeader?.length ?? 0) > 0 || (hf.oddFooter?.length ?? 0) > 0));
+}
+function sheetPrintsAnything(ws, styles) {
+	if (ws.grid.cells.some((c) => c.rawValue !== "" || c.inlineText !== void 0)) return true;
+	if (ws.grid.cells.some((c) => cellPaintsVisibly(c, styles))) return true;
+	if ((ws.charts?.length ?? 0) > 0) return true;
+	if ((ws.images?.length ?? 0) > 0) return true;
+	if ((ws.shapes?.length ?? 0) > 0) return true;
+	if ((ws.slicers?.length ?? 0) > 0) return true;
+	if ((ws.comments?.length ?? 0) > 0) return true;
+	if ((ws.formControls?.length ?? 0) > 0) return true;
+	if ((ws.activeXControls?.length ?? 0) > 0) return true;
+	return false;
+}
+/**
+* Put each drawing beside the column band it is anchored in.
+*
+* A wide sheet's grid prints as one table per band, each on its own page, and a
+* float lands on whatever page the layout has reached when it meets the block.
+* Emitted ahead of the whole grid, a drawing anchored in the second band was
+* printed on the FIRST page at an offset a page and a half wide — off the paper
+* entirely. shape-macro-ext-ref.xlsx anchors its chart and its macro button at
+* x=838pt and x=891pt of a 480pt page and lost both.
+*
+* Each drawing goes in front of its band's table with its horizontal anchor
+* measured from that band's left edge instead of the sheet's.
+*
+* @param drawings The sheet's floats, in the order they were projected.
+* @param gridBody The grid's body elements — one table per band.
+* @param lefts    Each band's left edge in points (from the projection's sink).
+* @returns The two merged; drawings first when the sheet does not band.
+*/
+function withDrawingsByBand(drawings, gridBody, lefts) {
+	const tables = gridBody.filter((el) => el.kind === "table").length;
+	if (drawings.length === 0 || lefts.length < 2 || tables !== lefts.length) return [...drawings, ...gridBody];
+	const bandOf = (x) => {
+		let band = 0;
+		while (band + 1 < lefts.length && x >= lefts[band + 1]) band++;
+		return band;
+	};
+	const byBand = lefts.map(() => []);
+	for (const el of drawings) {
+		const x = floatLeftPt(el);
+		const band = x === void 0 ? 0 : bandOf(x);
+		byBand[band].push(x === void 0 ? el : shiftFloatLeft(el, lefts[band]));
+	}
+	const out = [];
+	let seen = 0;
+	for (const el of gridBody) {
+		out.push(el);
+		if (el.kind === "table") out.push(...byBand[seen++]);
+	}
+	return out;
+}
+/** A float's horizontal anchor, for the block kinds a sheet anchors. */
+function floatLeftPt(el) {
+	return (el.kind === "chart" ? el.chart.float : el.kind === "image" ? el.image.float : el.kind === "shape" ? el.shape.float : void 0)?.posH?.offsetPt;
+}
+/** The same block with its horizontal anchor measured from `by` points later. */
+function shiftFloatLeft(el, by) {
+	if (by === 0) return el;
+	const moved = (block) => ({
+		...block,
+		float: {
+			...block.float,
+			posH: {
+				...block.float.posH,
+				offsetPt: pt((block.float.posH.offsetPt ?? 0) - by)
+			}
+		}
+	});
+	if (el.kind === "chart") return {
+		...el,
+		chart: moved(el.chart)
+	};
+	if (el.kind === "image") return {
+		...el,
+		image: moved(el.image)
+	};
+	if (el.kind === "shape") return {
+		...el,
+		shape: moved(el.shape)
+	};
+	return el;
+}
+var ACROSS = {
+	anchorOf: (s) => s.float?.posH?.offsetPt,
+	sizeOf: (s) => s.width,
+	shifted: (s, by) => ({
+		...s,
+		float: {
+			...s.float,
+			posH: {
+				...s.float.posH,
+				offsetPt: pt((s.float.posH.offsetPt ?? 0) - by)
+			}
+		}
+	})
+};
+var DOWN = {
+	anchorOf: (s) => s.float?.posV?.offsetPt,
+	sizeOf: (s) => s.height,
+	shifted: (s, by) => ({
+		...s,
+		float: {
+			...s.float,
+			posV: {
+				...s.float.posV,
+				offsetPt: pt((s.float.posV.offsetPt ?? 0) - by)
+			}
+		}
+	})
+};
+function bandDrawings(shapes, printable, scale, axis = ACROSS) {
+	if (shapes.length === 0 || !(printable > 0)) return [shapes];
+	const rightOf = (s) => (axis.anchorOf(s) ?? 0) * scale + axis.sizeOf(s);
+	const extent = Math.max(0, ...shapes.map(rightOf));
+	const bandCount = Math.ceil(extent / printable);
+	if (bandCount <= 1) return [shapes];
+	const bands = Array.from({ length: bandCount }, () => []);
+	for (const shape of shapes) {
+		const anchor = axis.anchorOf(shape);
+		const left = (anchor ?? 0) * scale;
+		const right = left + axis.sizeOf(shape);
+		const first = Math.max(0, Math.min(bandCount - 1, Math.floor(left / printable)));
+		const last = Math.max(first, Math.min(bandCount - 1, Math.ceil(right / printable) - 1));
+		for (let band = first; band <= last; band++) {
+			if (!shape.float || anchor === void 0) {
+				bands[band].push(shape);
+				continue;
+			}
+			const { text: _text, ...frame } = shape;
+			if (band !== first && !frame.line && frame.fill.kind === "none") continue;
+			bands[band].push(axis.shifted(band === first ? shape : frame, band * printable / scale));
+		}
+	}
+	return bands.filter((b) => b.length > 0);
+}
+/**
+* §20.5.2.35 — the float a drawing's anchor asks for: pinned at the point the
+* anchor names, measured from the page margin, wrapping nothing.
+*
+* A chart or a picture placed in the FLOW instead lands at the left margin,
+* below every block before it, and on whatever page that turns out to be:
+* simple-monthly-budget.xlsx anchors its chart beside the summary on page one
+* and we printed it alone on page two, a third of the way in from the left.
+* Shapes have floated at their anchors since W2; these two never did.
+*
+* No anchor (an `absoluteAnchor`, or a reader that gave none) ⇒ no float, and
+* the block keeps the flow placement it has always had.
+*/
+function anchorFloat(xPt, yPt, scale) {
+	if (xPt === void 0 || yPt === void 0) return {};
+	return { float: {
+		wrap: "none",
+		posH: {
+			relativeFrom: "margin",
+			offsetPt: pt(xPt * scale)
+		},
+		posV: {
+			relativeFrom: "margin",
+			offsetPt: pt(yPt * scale)
+		}
+	} };
+}
+/** Every control that carries geometry, as the shapes that draw it. */
+function controlShapeBlocks(formControls, activeXControls) {
+	const out = [];
+	for (const c of formControls ?? []) {
+		if (!c.box) continue;
+		out.push(...controlShapes(c.box, formControlGlyph(c.objectType), c.caption, c.checked === true, c.fontSizePt ?? DEFAULT_FORM_CONTROL_PT));
+	}
+	for (const c of activeXControls ?? []) {
+		if (!c.box) continue;
+		const on = c.value === "1" || c.value?.toLowerCase() === "true";
+		out.push(...controlShapes(c.box, activeXGlyph(c.type), c.caption, on, DEFAULT_ACTIVEX_CONTROL_PT));
+	}
+	return out;
+}
 function formControlBlocks(controls) {
+	const listed = controls.filter((c) => c.box === void 0);
+	if (listed.length === 0) return [];
 	const out = [{
 		kind: "paragraph",
 		paragraph: {
@@ -138,7 +548,7 @@ function formControlBlocks(controls) {
 			}]
 		}
 	}];
-	for (const c of controls) out.push({
+	for (const c of listed) out.push({
 		kind: "paragraph",
 		paragraph: {
 			properties: {},
@@ -164,6 +574,8 @@ function formControlLabel(c) {
 	}
 }
 function activeXBlocks(controls) {
+	const listed = controls.filter((c) => c.box === void 0);
+	if (listed.length === 0) return [];
 	const out = [{
 		kind: "paragraph",
 		paragraph: {
@@ -174,7 +586,7 @@ function activeXBlocks(controls) {
 			}]
 		}
 	}];
-	for (const c of controls) out.push({
+	for (const c of listed) out.push({
 		kind: "paragraph",
 		paragraph: {
 			properties: {},
@@ -203,28 +615,131 @@ function activeXLabel(c) {
 		default: return label;
 	}
 }
-function withHeaderFooter(section, ws, headersFooters) {
+/**
+* How far the sheet's drawings reach from its origin, or undefined when it has
+* none. Fit-to-page has to fit them as well as the cells: a drawing anchored
+* past the last value is still printed, and on a sheet whose values sit in a
+* handful of cells it is the drawing that decides the page.
+*/
+function drawingReachPt(ws) {
+	let widthPt = 0;
+	let heightPt = 0;
+	for (const shape of ws.shapes ?? []) {
+		widthPt = Math.max(widthPt, (shape.float?.posH?.offsetPt ?? 0) + shape.width);
+		heightPt = Math.max(heightPt, (shape.float?.posV?.offsetPt ?? 0) + shape.height);
+	}
+	for (const c of ws.charts ?? []) {
+		widthPt = Math.max(widthPt, (c.xPt ?? 0) + c.widthPt);
+		heightPt = Math.max(heightPt, (c.yPt ?? 0) + c.heightPt);
+	}
+	for (const p of ws.images ?? []) {
+		widthPt = Math.max(widthPt, (p.xPt ?? 0) + p.widthPt);
+		heightPt = Math.max(heightPt, (p.yPt ?? 0) + p.heightPt);
+	}
+	return widthPt > 0 || heightPt > 0 ? {
+		widthPt,
+		heightPt
+	} : void 0;
+}
+/**
+* `<printOptions horizontalCentered/verticalCentered>` centres what is PRINTED,
+* and a drawing is printed. We centred the table only, which leaves a drawing
+* at its raw offset — and on a sheet whose cells are all empty there is no
+* table to centre at all: bnc762542.xlsx asks for both axes and its callout sat
+* some 280pt left of where the reference puts it, matching the file's own
+* numbers exactly but ignoring the request that moves them.
+*/
+function centreShape(shape, worksheet, extent, scale) {
+	const options = worksheet.printOptions;
+	if (!extent || !options?.horizontalCentered && !options?.verticalCentered) return shape;
+	const section = sectionFromWorksheet(worksheet);
+	const size = section.pageSize;
+	const margins = section.margins;
+	if (!size || !margins) return shape;
+	const dx = options.horizontalCentered ? (size.width - margins.left - margins.right - extent.widthPt * scale) / 2 : 0;
+	const dy = options.verticalCentered ? (size.height - margins.top - margins.bottom - extent.heightPt * scale) / 2 : 0;
+	if (dx <= 0 && dy <= 0) return shape;
+	const posH = shape.float?.posH;
+	const posV = shape.float?.posV;
+	if (!shape.float) return shape;
+	return {
+		...shape,
+		float: {
+			...shape.float,
+			...posH && dx > 0 ? { posH: {
+				...posH,
+				offsetPt: pt((posH.offsetPt ?? 0) + dx)
+			} } : {},
+			...posV && dy > 0 ? { posV: {
+				...posV,
+				offsetPt: pt((posV.offsetPt ?? 0) + dy)
+			} } : {}
+		}
+	};
+}
+/**
+* A drawing at the sheet's print scale: its box and the point it floats at
+* shrink together, exactly as the grid beneath them does. Returns the shape
+* untouched at 1.0 so an unscaled sheet stays byte-identical.
+*/
+function scaleShape(shape, scale) {
+	if (!(scale > 0) || scale >= .999) return shape;
+	const offset = (o) => o?.offsetPt === void 0 ? void 0 : o.offsetPt * scale;
+	const posH = shape.float?.posH;
+	const posV = shape.float?.posV;
+	return {
+		...shape,
+		width: pt(shape.width * scale),
+		height: pt(shape.height * scale),
+		...shape.float ? { float: {
+			...shape.float,
+			...posH ? { posH: {
+				...posH,
+				...withOffset(offset(posH))
+			} } : {},
+			...posV ? { posV: {
+				...posV,
+				...withOffset(offset(posV))
+			} } : {}
+		} } : {}
+	};
+}
+function withOffset(value) {
+	return value === void 0 ? {} : { offsetPt: pt(value) };
+}
+/**
+* The sheet's header/footer bands, registered under ids of this sheet's own.
+*
+* The map is document-level and the ids used to be fixed, so a second sheet
+* overwrote the first's bands and every section pointed at the last one — in
+* practice only the first sheet's header survived, because only its section
+* carried the references. formats.xlsx puts the sheet name and page number on
+* all five of its pages and we printed them on one.
+*/
+function withHeaderFooter(section, ws, headersFooters, scale, basePt, sheetIdx, fileName, themePalette, now) {
+	const headerRel = `${HEADER_REL}${sheetIdx}`;
+	const footerRel = `${FOOTER_REL}${sheetIdx}`;
 	const hf = ws.grid.headerFooter;
 	if (!hf || !hf.oddHeader && !hf.oddFooter) return section;
 	const headers = [];
 	const footers = [];
 	if (hf.oddHeader) {
-		const content = buildHeaderFooterContent(hf.oddHeader, ws.name);
+		const content = buildHeaderFooterContent(hf.oddHeader, ws.name, scale, basePt, fileName, themePalette, now);
 		if (content.length > 0) {
-			headersFooters.set(HEADER_REL, resolveBodyStyles(content, EMPTY_STYLE_SHEET));
+			headersFooters.set(headerRel, resolveBodyStyles(content, EMPTY_STYLE_SHEET));
 			headers.push({
 				type: "default",
-				relationshipId: HEADER_REL
+				relationshipId: headerRel
 			});
 		}
 	}
 	if (hf.oddFooter) {
-		const content = buildHeaderFooterContent(hf.oddFooter, ws.name);
+		const content = buildHeaderFooterContent(hf.oddFooter, ws.name, scale, basePt, fileName, themePalette, now);
 		if (content.length > 0) {
-			headersFooters.set(FOOTER_REL, resolveBodyStyles(content, EMPTY_STYLE_SHEET));
+			headersFooters.set(footerRel, resolveBodyStyles(content, EMPTY_STYLE_SHEET));
 			footers.push({
 				type: "default",
-				relationshipId: FOOTER_REL
+				relationshipId: footerRel
 			});
 		}
 	}

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

@@ -2,6 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/excel/slicer-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	parseAttributeValue: false,