reamkit 1.31.0 → 1.32.0

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

@@ -1,7 +1,8 @@
 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 { cellPaintsVisibly, printableHeightPt, printableWidthPt, resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, slicerTable, worksheetToBody } from "./print-model.js";
+import { parseCellRef } from "./cell-reference.js";
+import { cellPaintsVisibly, noteKey, 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";
@@ -15,6 +16,29 @@ var PAGE_BREAK_PARAGRAPH = {
 	runs: []
 };
 /**
+* A page with room for any sheet, and the sliver of margin a sheet drawn as an
+* image keeps round itself, so that the rules on its outer edges are not cut
+* in half.
+*/
+var WHOLE_SHEET_PAGE_PT = 1e6;
+var WHOLE_SHEET_MARGIN_PT = 2;
+var WHOLE_SHEET_SECTION = {
+	pageSize: {
+		width: pt(WHOLE_SHEET_PAGE_PT),
+		height: pt(WHOLE_SHEET_PAGE_PT)
+	},
+	margins: {
+		top: pt(WHOLE_SHEET_MARGIN_PT),
+		right: pt(WHOLE_SHEET_MARGIN_PT),
+		bottom: pt(WHOLE_SHEET_MARGIN_PT),
+		left: pt(WHOLE_SHEET_MARGIN_PT),
+		header: pt(0),
+		footer: pt(0)
+	},
+	headers: [],
+	footers: []
+};
+/**
 * 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. Each
@@ -28,6 +52,8 @@ function projectSheetDoc(sheet, options = {}) {
 	const body = [];
 	const sheetSections = [];
 	const sheetEnds = [];
+	const sheetNames = [];
+	const screen = options.screen === true;
 	let firstSheetSection;
 	const headersFooters = /* @__PURE__ */ new Map();
 	const sheetGrids = new Map(sheet.sheets.map((s) => [s.name, s.grid]));
@@ -38,19 +64,28 @@ function projectSheetDoc(sheet, options = {}) {
 	for (let sheetIdx = 0; sheetIdx < sheet.sheets.length; sheetIdx++) {
 		const ws = sheet.sheets[sheetIdx];
 		if (ws.hidden) continue;
-		if (!sheetPrintsAnything(ws, sheet.styles) && ws !== fallbackSheet) {
+		if (!screen && !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 headingSink = {
+			dxPt: 0,
+			dyPt: 0
+		};
+		const notesShown = screen || ws.grid.pageSetup?.cellComments === "asDisplayed";
+		const drawingExtentPt = drawingReachPt(ws, notesShown, screen);
+		const controlBlocks = controlShapeBlocks(ws.formControls, ws.activeXControls);
+		const noteBlocks = notesShown ? (ws.comments ?? []).flatMap((comment) => noteShapes(comment, ws.grid.rightToLeft === true)) : [];
+		const printArea = screen ? void 0 : resolvePrintArea(sheet.definedNames, sheetIdx);
+		const titleRows = screen ? void 0 : resolvePrintTitleRows(sheet.definedNames, sheetIdx);
 		const gridBody = worksheetToBody(ws.grid, sheet.sharedStrings, sheet.styles, sheet.date1904, {
+			...screen ? { screen } : {},
+			...screen && options.wholeSheetPages === true ? { image: true } : {},
 			...printArea ? { printArea } : {},
 			...titleRows ? { titleRows } : {},
-			gridLines: ws.grid.printOptions?.gridLines === true,
+			gridLines: screen ? ws.grid.showGridLines !== false : ws.grid.printOptions?.gridLines === true,
 			sheetGrids,
 			sheetName: ws.name,
 			definedNames: sheet.definedNames,
@@ -60,19 +95,23 @@ function projectSheetDoc(sheet, options = {}) {
 			...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 } : {},
+			...screen && ws.comments && ws.comments.length > 0 ? { noteFlags: noteFlagsOf(ws.comments) } : {},
 			scaleSink,
 			bandSink,
-			...drawingExtentPt ? { drawingExtentPt } : {}
+			headingSink,
+			...drawingExtentPt ? { drawingExtentPt } : {},
+			...screen ? {} : { drawingBoxesPt: drawingBoxes(ws, [...controlBlocks, ...noteBlocks]) }
 		});
-		const sheetSection = withHeaderFooter(sectionFromWorksheet(ws.grid), ws, headersFooters, scaleSink.value, sheet.styles.fonts[0]?.sizePt, printed, options.fileName, sheet.themePalette, options.now);
+		const sheetSection = screen ? options.wholeSheetPages === true ? WHOLE_SHEET_SECTION : sectionFromWorksheet(ws.grid) : 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);
+		sheetNames.push(ws.name);
 		if (options.sheetHeadings === true) body.push({
 			kind: "paragraph",
 			paragraph: {
 				properties: {
 					outlineLevel: 0,
-					...printed > 0 ? { pageBreakBefore: true } : {}
+					...printed > 0 && !screen ? { pageBreakBefore: true } : {}
 				},
 				runs: [{
 					text: ws.name,
@@ -80,37 +119,52 @@ function projectSheetDoc(sheet, options = {}) {
 				}]
 			}
 		});
-		else if (printed > 0) body.push({
+		else if (printed > 0 && !screen) body.push({
 			kind: "paragraph",
 			paragraph: PAGE_BREAK_PARAGRAPH
 		});
 		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 * scaleSink.value),
-				height: pt(ref.heightPt * scaleSink.value),
-				paragraphProperties: {}
-			}
-		});
-		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 * scaleSink.value),
-				height: pt(img.heightPt * scaleSink.value),
-				paragraphProperties: {}
-			}
-		});
-		for (const shape of ws.shapes ?? []) drawings.push({
-			kind: "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];
+		const pageFilling = ws.grid.chartSheet === true && !screen;
+		for (const ref of ws.charts ?? []) {
+			if (ref.screenOnly && !screen) continue;
+			drawings.push({
+				kind: "chart",
+				chart: pageFilling ? {
+					...anchorFloat(0, 0, 1),
+					chartRelId: ref.chartPartPath,
+					width: pt(printableWidthPt(ws.grid)),
+					height: pt(printableHeightPt(ws.grid)),
+					paragraphProperties: {}
+				} : {
+					...anchorFloat(ref.xPt, ref.yPt, scaleSink.value),
+					chartRelId: ref.chartPartPath,
+					width: pt(ref.widthPt * scaleSink.value),
+					height: pt(ref.heightPt * scaleSink.value),
+					paragraphProperties: {}
+				}
+			});
+		}
+		for (const img of ws.images ?? []) {
+			if (img.screenOnly && !screen) continue;
+			drawings.push({
+				kind: "image",
+				image: {
+					...anchorFloat(img.xPt, img.yPt, scaleSink.value),
+					resource: img.resourceId,
+					width: pt(img.widthPt * scaleSink.value),
+					height: pt(img.heightPt * scaleSink.value),
+					paragraphProperties: {}
+				}
+			});
+		}
+		for (const [i, shape] of (ws.shapes ?? []).entries()) {
+			if (!screen && ws.screenOnlyShapes?.has(i)) continue;
+			drawings.push({
+				kind: "shape",
+				shape: screen ? shape : scaleShape(shape, scaleSink.value)
+			});
+		}
+		const drawingBands = gridBody.length === 0 && !screen ? 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",
@@ -118,22 +172,43 @@ function projectSheetDoc(sheet, options = {}) {
 			});
 			for (const shape of drawingBands[band]) drawings.push({
 				kind: "shape",
-				shape: centreShape(scaleShape(shape, scaleSink.value), ws.grid, drawingExtentPt, scaleSink.value)
+				shape: screen ? shape : scaleShape(shape, scaleSink.value)
 			});
 		}
-		body.push(...withDrawingsByBand(drawings, gridBody, bandSink.lefts));
+		for (const shape of noteBlocks) drawings.push({
+			kind: "shape",
+			shape: screen ? shape : scaleShape(shape, scaleSink.value)
+		});
+		const { grid, loose } = screen ? {
+			grid: gridBody,
+			loose: drawings
+		} : intoOverlays(gridBody, drawings, printArea !== void 0);
+		const placed = withDrawingsByBand(screen ? loose : loose.map((el) => el.kind === "shape" ? {
+			...el,
+			shape: centreShape(el.shape, ws.grid, drawingExtentPt, scaleSink.value)
+		} : el), grid, bandSink.lefts).map((el) => headingSink.dxPt > 0 || headingSink.dyPt > 0 ? nudgeFloat(el, headingSink.dxPt, headingSink.dyPt) : el);
+		body.push(...ws.grid.rightToLeft === true ? mirrorDrawings(placed, screen ? void 0 : printableWidthPt(ws.grid), (drawingExtentPt?.widthPt ?? 0) * scaleSink.value) : placed);
 		for (const slicer of ws.slicers ?? []) body.push({
 			kind: "table",
 			table: slicerTable(slicer)
 		});
-		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({
+		const listComments = !screen && ws.grid.pageSetup?.cellComments === "atEnd";
+		if (ws.comments && ws.comments.length > 0) if (listComments) body.push(...commentBlocks(ws.comments));
+		else if (!notesShown) 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}"`
 		});
+		else {
+			const hidden = ws.comments.filter((c) => c.shown === void 0).length;
+			if (hidden > 0) options.losses?.push({
+				severity: "dropped",
+				feature: "comments",
+				detail: screen ? `${hidden} cell note(s) not shown — a hidden note shows only while its cell is pointed at` : `${hidden} cell note(s) not printed — "asDisplayed" prints the notes the sheet shows`,
+				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);
@@ -149,9 +224,10 @@ function projectSheetDoc(sheet, options = {}) {
 		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) => ({
+	const sections = sheetSections.length > 1 || screen ? sheetSections.map((properties, i) => ({
 		properties,
-		endIndex: sheetEnds[i]
+		endIndex: sheetEnds[i],
+		...screen ? { sheet: { name: sheetNames[i] } } : {}
 	})) : [];
 	return {
 		kind: "flow",
@@ -162,7 +238,169 @@ function projectSheetDoc(sheet, options = {}) {
 		resources: sheet.resources,
 		...sheet.chartData && sheet.chartData.size > 0 ? { charts: sheet.chartData } : {},
 		...headersFooters.size > 0 ? { headersFooters } : {},
-		...sheet.info ? { info: sheet.info } : {}
+		...sheet.info ? { info: sheet.info } : {},
+		floatsOverText: true
+	};
+}
+/**
+* E-SHEET W7 — what a window flags: each cell that carries a note or a
+* comment, with what hovering over it shows. A cell with a threaded comment is
+* flagged as one, and reads as its conversation — Excel writes a legacy
+* placeholder note beside every thread ("[Threaded comment] Your version of
+* Excel allows you to read…"), which is no part of what anyone wrote.
+*
+* @param comments The sheet's legacy notes and threaded comments.
+* @returns The flags by absolute cell (print-model `noteKey`).
+*/
+function noteFlagsOf(comments) {
+	const byCell = /* @__PURE__ */ new Map();
+	for (const c of comments) {
+		let cell;
+		try {
+			cell = parseCellRef(c.ref);
+		} catch {
+			continue;
+		}
+		const k = noteKey(cell.row, cell.column);
+		const entry = byCell.get(k) ?? {
+			notes: [],
+			thread: []
+		};
+		(c.threaded ? entry.thread : entry.notes).push(c.author ? `${c.author}: ${c.text}` : c.text);
+		byCell.set(k, entry);
+	}
+	const out = /* @__PURE__ */ new Map();
+	for (const [k, { notes, thread }] of byCell) out.set(k, thread.length > 0 ? {
+		kind: "thread",
+		text: thread.join("\n")
+	} : {
+		kind: "note",
+		text: notes.join("\n")
+	});
+	return out;
+}
+var NOTE_INSET_PT = 1.5;
+var NOTE_SHADOW_PT = 2;
+var NOTE_LINE_PT = .75;
+var NOTE_FACE = "Tahoma";
+var NOTE_SIZE_PT = 9;
+/**
+* A shown note as Excel draws it: a pale box at the place its VML anchor
+* names, holding the note's text run by run (the bold "Author:" line first),
+* with a hard shadow down and to the right — and a thin line from the box to
+* its cell's top-right corner, ending there in a small arrowhead.
+*
+* Built in the file's column order like every other drawing. On a sheet that
+* reads from the right mirrorDrawings moves both, and the line, which has a
+* direction the box has not, is turned round here so it still meets the
+* cell's corner — the corner, too, is mirrored.
+*
+* @param comment The note, with the box its shape shows, if it shows one.
+* @param rtl     Whether the sheet reads from the right.
+* @returns The line then the box (the box over the line), or nothing.
+*/
+function noteShapes(comment, rtl) {
+	const box = comment.shown;
+	if (!box) return [];
+	const runs = comment.runs ?? [{ text: comment.author ? `${comment.author}:\n${comment.text}` : comment.text }];
+	const frame = {
+		...anchorFloat(box.xPt, box.yPt, 1),
+		width: pt(box.widthPt),
+		height: pt(box.heightPt),
+		geometry: {
+			kind: "preset",
+			preset: "rect"
+		},
+		fill: {
+			kind: "solid",
+			colorHex: box.fillHex
+		},
+		line: {
+			width: pt(NOTE_LINE_PT),
+			colorHex: box.lineHex
+		},
+		...box.shadow ? { shadow: {
+			dxPt: NOTE_SHADOW_PT,
+			dyPt: NOTE_SHADOW_PT,
+			blurPt: 0,
+			colorHex: "000000",
+			alpha: 1
+		} } : {},
+		text: {
+			content: noteParagraphs(runs, box.textAlign),
+			insetLeft: pt(NOTE_INSET_PT),
+			insetTop: pt(NOTE_INSET_PT),
+			insetRight: pt(NOTE_INSET_PT),
+			insetBottom: pt(NOTE_INSET_PT),
+			anchor: "t"
+		},
+		paragraphProperties: {}
+	};
+	const cx = box.cornerXPt;
+	const cy = box.cornerYPt;
+	const sx = Math.min(Math.max(cx, box.xPt), box.xPt + box.widthPt);
+	const sy = Math.min(Math.max(cy, box.yPt), box.yPt + box.heightPt);
+	if (sx === cx && sy === cy) return [frame];
+	const flipH = sx > cx !== rtl;
+	const flipV = sy > cy;
+	return [{
+		...anchorFloat(Math.min(sx, cx), Math.min(sy, cy), 1),
+		width: pt(Math.abs(cx - sx)),
+		height: pt(Math.abs(cy - sy)),
+		geometry: {
+			kind: "preset",
+			preset: "line"
+		},
+		fill: { kind: "none" },
+		line: {
+			width: pt(NOTE_LINE_PT),
+			colorHex: box.lineHex,
+			tailEnd: {
+				type: "triangle",
+				width: "sm",
+				length: "sm"
+			}
+		},
+		...flipH || flipV ? { transform: {
+			...flipH ? { flipH: true } : {},
+			...flipV ? { flipV: true } : {}
+		} } : {},
+		paragraphProperties: {}
+	}, frame];
+}
+function noteParagraphs(runs, align) {
+	const lines = [[]];
+	for (const r of runs) r.text.split(/\r\n|\r|\n/).forEach((part, i) => {
+		if (i > 0) lines.push([]);
+		if (part.length > 0) lines[lines.length - 1].push({
+			text: part,
+			properties: noteRunProps(r)
+		});
+	});
+	while (lines.length > 1 && lines[lines.length - 1].length === 0) lines.pop();
+	return lines.map((line) => ({
+		kind: "paragraph",
+		paragraph: {
+			properties: align ? { alignment: align } : {},
+			runs: line
+		}
+	}));
+}
+function noteRunProps(r) {
+	const face = r.fontName ?? NOTE_FACE;
+	return {
+		fontFamily: {
+			ascii: face,
+			hAnsi: face,
+			cs: face
+		},
+		fontSizePt: pt(r.sizePt ?? NOTE_SIZE_PT),
+		colorHex: r.colorHex ?? "000000",
+		...r.bold ? { bold: true } : {},
+		...r.italic ? { italic: true } : {},
+		...r.underline ? { underline: "single" } : {},
+		...r.strike ? { strike: true } : {},
+		...r.vertAlign ? { verticalAlign: r.vertAlign } : {}
 	};
 }
 function commentBlocks(comments) {
@@ -433,6 +671,113 @@ function withDrawingsByBand(drawings, gridBody, lefts) {
 	}
 	return out;
 }
+/**
+* §20.5 — each printed table of a sheet takes the drawings over the columns it
+* prints, into its overlay (TableOverlay): the layout then shows every page
+* the part of them over its own rows. A table none of them lies over keeps no
+* overlay.
+*
+* @param grid       The sheet's grid, its tables framed by the print model.
+* @param drawings   The sheet's drawings at the print scale, in the sheet's frame.
+* @param printArea  Whether a print area bounds what prints.
+* @returns The grid with the drawings in it, and those over none of its
+*   columns that still print — none, when a print area leaves them out.
+*/
+function intoOverlays(grid, drawings, printArea) {
+	if (!grid.some((el) => el.kind === "table" && el.table.overlay)) return {
+		grid: [...grid],
+		loose: [...drawings]
+	};
+	const taken = /* @__PURE__ */ new Set();
+	return {
+		grid: grid.map((el) => {
+			if (el.kind !== "table" || !el.table.overlay) return el;
+			const o = el.table.overlay;
+			const over = drawings.filter((d) => {
+				const x = floatLeftPt(d);
+				const w = floatWidthPt(d) ?? 0;
+				return x !== void 0 && x < o.sheetLeftPt + o.widthPt && x + w > o.sheetLeftPt;
+			});
+			for (const d of over) taken.add(d);
+			if (over.length === 0) {
+				const { overlay: _none, ...table } = el.table;
+				return {
+					kind: "table",
+					table
+				};
+			}
+			return {
+				kind: "table",
+				table: {
+					...el.table,
+					overlay: {
+						...o,
+						drawings: over
+					}
+				}
+			};
+		}),
+		loose: drawings.filter((d) => !taken.has(d) && (!printArea || floatLeftPt(d) === void 0))
+	};
+}
+/**
+* Where each of the sheet's printed drawings lies, unscaled, in the sheet's
+* own frame — what a band keeps its rows under (PrintModelOptions
+* .drawingBoxesPt).
+*
+* @param ws     The sheet.
+* @param shapes The controls and shown notes drawn as shapes, besides its own.
+* @returns The boxes.
+*/
+function drawingBoxes(ws, shapes) {
+	const boxes = [];
+	const add = (xPt, yPt, w, h) => {
+		if (xPt !== void 0 && yPt !== void 0) boxes.push({
+			xPt,
+			yPt,
+			widthPt: w,
+			heightPt: h
+		});
+	};
+	for (const c of ws.charts ?? []) if (!c.screenOnly) add(c.xPt, c.yPt, c.widthPt, c.heightPt);
+	for (const p of ws.images ?? []) if (!p.screenOnly) add(p.xPt, p.yPt, p.widthPt, p.heightPt);
+	for (const [i, shape] of [...ws.shapes ?? [], ...shapes].entries()) {
+		if (i < (ws.shapes ?? []).length && ws.screenOnlyShapes?.has(i)) continue;
+		add(shape.float?.posH?.offsetPt, shape.float?.posV?.offsetPt, shape.width, shape.height);
+	}
+	return boxes;
+}
+/**
+* §18.3.1.87 `rightToLeft` — a drawing on a sheet that reads from the right is
+* anchored to the same cells, and they stand mirrored: it keeps its size and
+* its own orientation (Excel does not turn a right arrow round) but its place
+* is counted from the grid's right edge. Each float is measured against the
+* table it was placed beside — a band's own when the sheet bands, the first
+* one for the floats that go in ahead of the grid — and on paper that table
+* stands against the right margin (mirrorTable), or in the middle when the
+* sheet asks to be centred.
+*
+* @param elements       The sheet's grid and floats, as withDrawingsByBand placed them.
+* @param contentWidthPt The width between the margins, or undefined for a screen.
+* @param extentWidthPt  How far the drawings reach, for a sheet with no table.
+*/
+function mirrorDrawings(elements, contentWidthPt, extentWidthPt) {
+	let table = elements.find((el) => el.kind === "table")?.table;
+	const out = [];
+	for (const el of elements) {
+		if (el.kind === "table") table = el.table;
+		const x = floatLeftPt(el);
+		const w = floatWidthPt(el);
+		if (el.kind === "table" || x === void 0 || w === void 0) {
+			out.push(el);
+			continue;
+		}
+		const gridWidth = table ? table.grid.reduce((sum, c) => sum + c, 0) : extentWidthPt;
+		const left = contentWidthPt === void 0 ? 0 : table?.properties.alignment === "center" ? (contentWidthPt - gridWidth) / 2 : contentWidthPt - gridWidth;
+		out.push(shiftFloatLeft(el, x - (left + gridWidth - x - w)));
+	}
+	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;
@@ -443,6 +788,40 @@ function floatWidthPt(el) {
 	if (el.kind === "image") return el.image.width;
 	if (el.kind === "shape") return el.shape.width;
 }
+/** The same block with its anchor moved `dx` right and `dy` down. */
+function nudgeFloat(el, dx, dy) {
+	const moved = (block) => {
+		const f = block.float;
+		if (!f) return block;
+		return {
+			...block,
+			float: {
+				...f,
+				...f.posH ? { posH: {
+					...f.posH,
+					offsetPt: pt((f.posH.offsetPt ?? 0) + dx)
+				} } : {},
+				...f.posV ? { posV: {
+					...f.posV,
+					offsetPt: pt((f.posV.offsetPt ?? 0) + dy)
+				} } : {}
+			}
+		};
+	};
+	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;
+}
 /** The same block with its horizontal anchor measured from `by` points later. */
 function shiftFloatLeft(el, by) {
 	if (by === 0) return el;
@@ -650,21 +1029,29 @@ function activeXLabel(c) {
 * 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) {
+function drawingReachPt(ws, notesShown, screen) {
 	let widthPt = 0;
 	let heightPt = 0;
-	for (const shape of ws.shapes ?? []) {
+	for (const [i, shape] of (ws.shapes ?? []).entries()) {
+		if (!screen && ws.screenOnlyShapes?.has(i)) continue;
 		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 ?? []) {
+		if (c.screenOnly && !screen) continue;
 		widthPt = Math.max(widthPt, (c.xPt ?? 0) + c.widthPt);
 		heightPt = Math.max(heightPt, (c.yPt ?? 0) + c.heightPt);
 	}
 	for (const p of ws.images ?? []) {
+		if (p.screenOnly && !screen) continue;
 		widthPt = Math.max(widthPt, (p.xPt ?? 0) + p.widthPt);
 		heightPt = Math.max(heightPt, (p.yPt ?? 0) + p.heightPt);
 	}
+	for (const c of notesShown ? ws.comments ?? [] : []) {
+		if (!c.shown) continue;
+		widthPt = Math.max(widthPt, c.shown.xPt + c.shown.widthPt + NOTE_SHADOW_PT);
+		heightPt = Math.max(heightPt, c.shown.yPt + c.shown.heightPt + NOTE_SHADOW_PT);
+	}
 	return widthPt > 0 || heightPt > 0 ? {
 		widthPt,
 		heightPt
@@ -685,7 +1072,7 @@ function centreShape(shape, worksheet, extent, scale) {
 	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 dx = options.horizontalCentered && worksheet.rightToLeft !== true ? (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;

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

@@ -37,3 +37,12 @@ export declare function parseXlsxStyles(data: Uint8Array, theme?: ThemePalette):
  * @returns The format; empty when the node states nothing.
  */
 export declare function parseDxf(item: unknown, colors: WorkbookColors): Dxf;
+/**
+ * A `<color>` of this workbook as 6-hex: its `rgb`, its `indexed` entry or its
+ * `theme` slot, with the `tint` applied (§18.8.3).
+ *
+ * @param node   The `<color>` element, parsed.
+ * @param colors What the workbook's colours point at.
+ * @returns The colour, or undefined for one that names nothing reachable.
+ */
+export declare function workbookColorHex(node: unknown, colors: WorkbookColors): string | undefined;