reamkit 1.15.4 → 1.17.0

package/dist/esm/excel/sheet-shape-parser.js

@@ -1,6 +1,7 @@
 import { emuToPt, pt } from "../core/ir/units.js";
-import { poChildren, poFirstChild, poIntAttr, poIs, poText } from "../core/po-helpers.js";
-import { parseFill, parseLine } from "../word/drawing-parser.js";
+import { poAttr, poChildren, poFirstChild, poIntAttr, poIs, poTag, poText } from "../core/po-helpers.js";
+import { applyColorMods, resolveColorNode } from "../core/drawingml/colors.js";
+import { parseFill, parseLine, parseShadow, parseXfrm, shadowFromOuterShdw } from "../word/drawing-parser.js";
 import { parseGeometry, parseTxBody } from "../pptx/slide-parser.js";
 import { parseXml } from "../pptx/pptx-reader.js";
 import { makeColWidthPt, makeRowHeightPt } from "./sheet-drawing.js";
@@ -11,6 +12,65 @@ var ANCHOR_KINDS = [
 	"xdr:absoluteAnchor"
 ];
 /**
+* One `xdr:sp` / `dsp:sp` as a {@link ShapeBlock} in the box it occupies, or
+* undefined when it would draw nothing at all.
+*
+* @param sp     The shape element.
+* @param box    The box it occupies on the page.
+* @param ns     Which namespace its own children carry.
+* @param colors The theme colour resolver.
+* @param themeLineWidths   `a:lnStyleLst` widths, indexed by `<a:lnRef idx>`.
+* @param themeFillStyles   `a:fillStyleLst` nodes, indexed by `<a:fillRef idx>`.
+* @param themeEffectStyles `a:effectStyleLst` nodes, indexed by `<a:effectRef idx>`.
+*/
+function buildShape(sp, box, ns, colors, themeLineWidths, themeFillStyles, themeEffectStyles) {
+	const spPr = poChildren(sp).find((c) => poIs(c, `${ns}:spPr`));
+	const txBody = poChildren(sp).find((c) => poIs(c, `${ns}:txBody`));
+	const geometry = parseGeometry(spPr);
+	const parsed = txBody ? parseTxBody(txBody, void 0, void 0, colors, void 0) : void 0;
+	const lettered = (parsed?.content ?? []).some((b) => b.kind === "paragraph" && b.paragraph.runs.some((r) => r.text.trim().length > 0));
+	const xfrm = spPr ? poChildren(spPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+	const transform = xfrm ? parseXfrm(xfrm) : void 0;
+	const own = transform !== void 0 && Object.keys(transform).length > 0 && xfrm && !lettered ? poChildren(xfrm).find((c) => poIs(c, "a:ext")) : void 0;
+	const ownW = own ? emuToPt(poIntAttr(own, "cx") ?? 0) : 0;
+	const ownH = own ? emuToPt(poIntAttr(own, "cy") ?? 0) : 0;
+	const useOwn = ownW > 0 && ownH > 0;
+	const widthPt = useOwn ? ownW : box.widthPt;
+	const heightPt = useOwn ? ownH : box.heightPt;
+	const xPt = useOwn ? box.xPt + (box.widthPt - ownW) / 2 : box.xPt;
+	const yPt = useOwn ? box.yPt + (box.heightPt - ownH) / 2 : box.yPt;
+	const spFill = spPr ? parseFill(spPr, colors) : { kind: "none" };
+	const fill = spFill.kind === "none" ? styleFill(sp, ns, colors, themeFillStyles) : spFill;
+	const directLine = spPr ? parseLine(spPr, colors) : void 0;
+	const line = directLine && Object.keys(directLine).length > 0 ? directLine : styleLine(sp, ns, colors, themeLineWidths);
+	const text = parsed ? withStyleTextColor(parsed, sp, ns, colors) : void 0;
+	const shadow = (spPr ? parseShadow(spPr, colors) : void 0) ?? styleShadow(sp, ns, colors, themeEffectStyles);
+	const visibleLine = line !== void 0 && line.fill !== "none";
+	if (!text && fill.kind === "none" && !visibleLine) return void 0;
+	return {
+		float: {
+			wrap: "none",
+			posH: {
+				relativeFrom: "margin",
+				offsetPt: pt(xPt)
+			},
+			posV: {
+				relativeFrom: "margin",
+				offsetPt: pt(yPt)
+			}
+		},
+		width: pt(widthPt),
+		height: pt(heightPt),
+		geometry,
+		fill,
+		...transform && Object.keys(transform).length > 0 ? { transform } : {},
+		...line ? { line } : {},
+		...text ? { text } : {},
+		...shadow ? { shadow } : {},
+		paragraphProperties: {}
+	};
+}
+/**
 * Parse a drawing's `xdr:sp` shape anchors (§20.5.2.30) into anchor-ordered
 * {@link ShapeBlock}s (E-SHEET W2), reusing the shared DrawingML geometry / fill /
 * line / text readers. A shape's box comes from its sheet anchor (from/to tracks),
@@ -21,8 +81,14 @@ var ANCHOR_KINDS = [
 *                   preserveOrder tree the shape readers expect).
 * @param worksheet  The host worksheet, for the column/row track geometry.
 * @param colors     The theme colour resolver threaded into fill/line parsing.
+* @param themeLineWidths The theme's `a:lnStyleLst` widths in points, which an
+*                   `<a:lnRef idx>` indexes for a gallery-styled outline.
+* @param themeFillStyles The theme's `a:fillStyleLst` nodes, which an
+*                   `<a:fillRef idx>` indexes for a gallery-styled fill.
+* @param themeEffectStyles The theme's `a:effectStyleLst` nodes, which an
+*                   `<a:effectRef idx>` indexes for a gallery-styled shadow.
 */
-function parseSheetShapes(drawingXml, worksheet, colors) {
+function parseSheetShapes(drawingXml, worksheet, colors, themeLineWidths = [], themeFillStyles = [], themeEffectStyles = []) {
 	const wsDr = parseXml(drawingXml).find((n) => poIs(n, "xdr:wsDr"));
 	if (!wsDr) return [];
 	const colWidthPt = makeColWidthPt(worksheet);
@@ -30,33 +96,361 @@ function parseSheetShapes(drawingXml, worksheet, colors) {
 	const shapes = [];
 	for (const anchor of poChildren(wsDr)) {
 		if (!ANCHOR_KINDS.some((k) => poIs(anchor, k))) continue;
-		const sp = poChildren(anchor).find((c) => poIs(c, "xdr:sp"));
-		if (!sp) continue;
+		const anchored = anchorBox(anchor, colWidthPt, rowHeightPt);
+		if (!anchored) continue;
+		const placed = [];
+		const direct = poChildren(anchor).find((c) => poIs(c, "xdr:sp"));
+		if (direct) placed.push({
+			sp: direct,
+			box: anchored
+		});
+		for (const group of poChildren(anchor).filter((c) => poIs(c, "xdr:grpSp"))) collectGrouped(group, anchored, placed);
+		for (const { sp, box } of placed) {
+			if (isHiddenDrawing(sp, "xdr:nvSpPr")) continue;
+			const shape = buildShape(sp, box, "xdr", colors, themeLineWidths, themeFillStyles, themeEffectStyles);
+			if (!shape) continue;
+			shapes.push({
+				shape,
+				anchorRow: box.anchorRow
+			});
+		}
+	}
+	shapes.sort((a, b) => a.anchorRow - b.anchorRow);
+	return shapes.map((s) => s.shape);
+}
+/**
+* The boxes the diagram frames of a drawing occupy, in document order.
+*
+* §20.5.2.16 `xdr:graphicFrame` is how a sheet hosts a diagram: the frame is
+* anchored like any other drawing and the diagram itself lives in its own
+* parts. The frame gives the corner its fallback shapes are laid out from —
+* see {@link parseDiagramShapes}.
+*
+* @param drawingXml The drawing part bytes.
+* @param worksheet  The host worksheet, for the column/row track geometry.
+* @returns One box per diagram frame, in the order the drawing writes them.
+*/
+function parseDiagramFrames(drawingXml, worksheet) {
+	const wsDr = parseXml(drawingXml).find((n) => poIs(n, "xdr:wsDr"));
+	if (!wsDr) return [];
+	const colWidthPt = makeColWidthPt(worksheet);
+	const rowHeightPt = makeRowHeightPt(worksheet);
+	const out = [];
+	for (const anchor of poChildren(wsDr)) {
+		if (!ANCHOR_KINDS.some((k) => poIs(anchor, k))) continue;
+		const frame = poChildren(anchor).find((c) => poIs(c, "xdr:graphicFrame"));
+		if (!frame) continue;
+		if (!poFirstChild(poFirstChild(poFirstChild(frame, "a:graphic"), "a:graphicData"), "dgm:relIds")) continue;
 		const box = anchorBox(anchor, colWidthPt, rowHeightPt);
+		if (box) out.push(box);
+	}
+	return out;
+}
+/**
+* Parse the fallback drawing of a SmartArt diagram (§ MS-ODRAWXML 2.1
+* `dsp:drawing`) into the shapes it lays out.
+*
+* A diagram is FOUR parts of description — data, layout, quick style, colours —
+* that a renderer is meant to lay out itself, and nobody outside Office does.
+* The producer therefore also writes what it drew: a plain DrawingML picture of
+* the result, under `dsp:`, reachable from the drawing part by a
+* `diagramDrawing` relationship. Reading it is the difference between a diagram
+* and a blank space — tdf83671_SmartArt_import.xlsx draws three nested circles
+* where we drew nothing between its "start" and its "end".
+*
+* The shapes' `a:xfrm` offsets are relative to the frame the diagram sits in,
+* so the frame's own corner is all that has to be added.
+*
+* @param diagramXml The `dsp:drawing` part bytes.
+* @param frame      The box the graphic frame occupies on the page.
+* @param colors     The theme colour resolver.
+* @param themeLineWidths   `a:lnStyleLst` widths, indexed by `<a:lnRef idx>`.
+* @param themeFillStyles   `a:fillStyleLst` nodes, indexed by `<a:fillRef idx>`.
+* @param themeEffectStyles `a:effectStyleLst` nodes, indexed by `<a:effectRef idx>`.
+* @returns The shapes, in the order the diagram stacks them.
+*/
+function parseDiagramShapes(diagramXml, frame, colors, themeLineWidths = [], themeFillStyles = [], themeEffectStyles = []) {
+	const drawing = parseXml(diagramXml).find((n) => poIs(n, "dsp:drawing"));
+	const spTree = drawing ? poFirstChild(drawing, "dsp:spTree") : void 0;
+	if (!spTree) return [];
+	const out = [];
+	for (const sp of poChildren(spTree)) {
+		if (!poIs(sp, "dsp:sp")) continue;
+		const box = diagramBox(sp, frame);
 		if (!box) continue;
-		const spPr = poChildren(sp).find((c) => poIs(c, "xdr:spPr"));
-		const geometry = parseGeometry(spPr);
-		const fill = spPr ? parseFill(spPr, colors) : { kind: "none" };
-		const line = spPr ? parseLine(spPr, colors) : void 0;
-		const txBody = poChildren(sp).find((c) => poIs(c, "xdr:txBody"));
-		const text = txBody ? parseTxBody(txBody, void 0, void 0, colors, void 0) : void 0;
-		const visibleLine = line !== void 0 && line.fill !== "none";
-		if (!text && fill.kind === "none" && !visibleLine) continue;
-		shapes.push({
-			shape: {
-				width: pt(box.widthPt),
-				height: pt(box.heightPt),
-				geometry,
-				fill,
-				...line ? { line } : {},
-				...text ? { text } : {},
-				paragraphProperties: {}
+		const shape = buildShape(sp, box, "dsp", colors, themeLineWidths, themeFillStyles, themeEffectStyles);
+		if (!shape) continue;
+		const text = shape.text;
+		const label = text ? textBox(sp, frame) : void 0;
+		if (!label || !text) {
+			out.push(shape);
+			continue;
+		}
+		const { text: _moved, ...graphic } = shape;
+		out.push(graphic);
+		out.push({
+			float: {
+				wrap: "none",
+				posH: {
+					relativeFrom: "margin",
+					offsetPt: pt(label.xPt)
+				},
+				posV: {
+					relativeFrom: "margin",
+					offsetPt: pt(label.yPt)
+				}
+			},
+			width: pt(label.widthPt),
+			height: pt(label.heightPt),
+			geometry: {
+				kind: "preset",
+				preset: "rect",
+				adjust: /* @__PURE__ */ new Map()
 			},
-			anchorRow: box.anchorRow
+			fill: { kind: "none" },
+			text,
+			paragraphProperties: {}
 		});
 	}
-	shapes.sort((a, b) => a.anchorRow - b.anchorRow);
-	return shapes.map((s) => s.shape);
+	return out;
+}
+/** A diagram label's box: its `dsp:txXfrm`, moved to the frame's corner. */
+function textBox(sp, frame) {
+	const xfrm = poFirstChild(sp, "dsp:txXfrm");
+	const ext = xfrm ? poFirstChild(xfrm, "a:ext") : void 0;
+	if (!ext) return void 0;
+	const widthPt = emuToPt(poIntAttr(ext, "cx") ?? 0);
+	const heightPt = emuToPt(poIntAttr(ext, "cy") ?? 0);
+	if (!(widthPt > 0 && heightPt > 0)) return void 0;
+	const off = poFirstChild(xfrm, "a:off");
+	return {
+		widthPt,
+		heightPt,
+		anchorRow: frame.anchorRow,
+		xPt: frame.xPt + emuToPt(poIntAttr(off, "x") ?? 0),
+		yPt: frame.yPt + emuToPt(poIntAttr(off, "y") ?? 0)
+	};
+}
+/** A diagram shape's box: its own `a:xfrm`, moved to the frame's corner. */
+function diagramBox(sp, frame) {
+	const spPr = poFirstChild(sp, "dsp:spPr");
+	const xfrm = spPr ? poFirstChild(spPr, "a:xfrm") : void 0;
+	const off = xfrm ? poFirstChild(xfrm, "a:off") : void 0;
+	const ext = xfrm ? poFirstChild(xfrm, "a:ext") : void 0;
+	if (!ext) return void 0;
+	const widthPt = emuToPt(poIntAttr(ext, "cx") ?? 0);
+	const heightPt = emuToPt(poIntAttr(ext, "cy") ?? 0);
+	if (!(widthPt > 0 && heightPt > 0)) return void 0;
+	return {
+		widthPt,
+		heightPt,
+		anchorRow: frame.anchorRow,
+		xPt: frame.xPt + emuToPt(poIntAttr(off, "x") ?? 0),
+		yPt: frame.yPt + emuToPt(poIntAttr(off, "y") ?? 0)
+	};
+}
+/**
+* Place a group's children inside the box the group itself occupies.
+*
+* §20.5.2.17 `xdr:grpSp` — a group gives its children a coordinate space of its
+* own: `a:xfrm/a:chOff` + `a:chExt` name that space, and each child's own
+* `a:xfrm` is a rectangle inside it. Mapping the rectangle onto the group's box
+* places the child; a nested group recurses through the same map.
+*
+* @param group The `xdr:grpSp` element.
+* @param box   The box the group occupies on the page.
+* @param out   Collects each `xdr:sp` with the box it lands in.
+*/
+function collectGrouped(group, box, out) {
+	const grpPr = poChildren(group).find((c) => poIs(c, "xdr:grpSpPr"));
+	const xfrm = grpPr ? poChildren(grpPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+	const chOff = xfrm ? poChildren(xfrm).find((c) => poIs(c, "a:chOff")) : void 0;
+	const chExt = xfrm ? poChildren(xfrm).find((c) => poIs(c, "a:chExt")) : void 0;
+	const ox = chOff ? poIntAttr(chOff, "x") ?? 0 : 0;
+	const oy = chOff ? poIntAttr(chOff, "y") ?? 0 : 0;
+	const cw = chExt ? poIntAttr(chExt, "cx") ?? 0 : 0;
+	const ch = chExt ? poIntAttr(chExt, "cy") ?? 0 : 0;
+	if (!(cw > 0) || !(ch > 0)) return;
+	const place = (node, prTag) => {
+		const pr = poChildren(node).find((c) => poIs(c, prTag));
+		const x = pr ? poChildren(pr).find((c) => poIs(c, "a:xfrm")) : void 0;
+		const off = x ? poChildren(x).find((c) => poIs(c, "a:off")) : void 0;
+		const ext = x ? poChildren(x).find((c) => poIs(c, "a:ext")) : void 0;
+		if (!off || !ext) return void 0;
+		const w = (poIntAttr(ext, "cx") ?? 0) / cw * box.widthPt;
+		const h = (poIntAttr(ext, "cy") ?? 0) / ch * box.heightPt;
+		if (!(w > 0) || !(h > 0)) return void 0;
+		return {
+			widthPt: w,
+			heightPt: h,
+			anchorRow: box.anchorRow,
+			xPt: box.xPt + ((poIntAttr(off, "x") ?? 0) - ox) / cw * box.widthPt,
+			yPt: box.yPt + ((poIntAttr(off, "y") ?? 0) - oy) / ch * box.heightPt
+		};
+	};
+	for (const child of poChildren(group)) if (poIs(child, "xdr:sp")) {
+		const b = place(child, "xdr:spPr");
+		if (b) out.push({
+			sp: child,
+			box: b
+		});
+	} else if (poIs(child, "xdr:grpSp")) {
+		const b = place(child, "xdr:grpSpPr");
+		if (b) collectGrouped(child, b, out);
+	}
+}
+/**
+* Whether a drawing says it is not to be shown.
+*
+* §20.1.2.2.8 `cNvPr@hidden` — "Specifies whether this DrawingML object shall
+* be displayed", default false. POI writes one white rectangle per cell comment
+* under the name `_xssf_cell_comment` and marks it hidden; read without the
+* flag, 51850.xlsx grew a 494 × 677pt outlined box across both its pages.
+*
+* @param node      The `xdr:sp` / `xdr:pic` / `xdr:graphicFrame` element.
+* @param nvPropTag Its non-visual properties wrapper.
+* @returns True when the object declares itself hidden.
+*/
+function isHiddenDrawing(node, nvPropTag) {
+	const nv = poChildren(node).find((c) => poIs(c, nvPropTag));
+	const cNvPr = nv ? poChildren(nv).find((c) => poIs(c, "xdr:cNvPr")) : void 0;
+	const hidden = cNvPr ? poAttr(cNvPr, "hidden") : void 0;
+	return hidden === "1" || hidden === "true";
+}
+/**
+* The outline `<xdr:style><a:lnRef>` names, if it names one.
+*
+* §20.1.4.2.19: the reference's `idx` is a 1-based index into the theme's
+* `a:lnStyleLst`, which is where the WIDTH lives — the reference itself carries
+* only the colour. Assuming a hairline drew 50299.xlsx's `idx="2"` rectangle in
+* 0.75pt where its theme asks for 2pt.
+*/
+function styleLine(sp, ns, colors, themeLineWidths) {
+	const style = poChildren(sp).find((c) => poIs(c, `${ns}:style`));
+	const lnRef = style ? poChildren(style).find((c) => poIs(c, "a:lnRef")) : void 0;
+	const child = poFirstElement(lnRef);
+	const colorHex = child ? resolveColorNode(child, colors) : void 0;
+	if (colorHex === void 0) return void 0;
+	const idx = Number(poAttr(lnRef, "idx") ?? "");
+	return {
+		colorHex,
+		width: pt((Number.isFinite(idx) ? themeLineWidths[idx - 1] : void 0) ?? .75)
+	};
+}
+/**
+* The fill `<xdr:style><a:fillRef>` names, if it names one.
+*
+* §20.1.4.2.10, the same mechanism as the outline beside it: a shape drawn from
+* a gallery style carries no `a:solidFill` in its `spPr` at all, and read alone
+* it says the shape has no fill. 50299.xlsx's rectangle asks for `accent1` that
+* way, and we drew it empty on all six sheets.
+*
+* `idx="0"` is the explicit "no fill" slot. Above it the reference is a 1-based
+* index into the theme's `a:fillStyleLst` (§20.1.4.1.13), and THAT is the fill —
+* the reference only says which colour goes where the style says `phClr`. The
+* standard Office theme's third slot is a gradient, which is what 47504.xlsx
+* asks for and what both references draw; painting the referenced colour flat
+* instead lost the gradient on every gallery shape.
+*/
+/**
+* The first CHILD ELEMENT of a style reference — `<a:lnRef>`, `<a:fillRef>`,
+* `<a:effectRef>`, `<a:fontRef>` — each of which wraps exactly one colour.
+*
+* Not `poChildren(ref)[0]`: a part saved with indentation puts a whitespace
+* text node there, and the colour behind it went unread. Every gallery shape in
+* tdf139763ShapeAnchor.xlsx lost its fill AND its outline that way and drew
+* nothing at all on a page LibreOffice fills with two blue arrows.
+*
+* @param ref The style reference, or undefined.
+* @returns Its first element child, or undefined.
+*/
+function poFirstElement(ref) {
+	return ref ? poChildren(ref).find((c) => poTag(c) !== void 0) : void 0;
+}
+function styleFill(sp, ns, colors, themeFillStyles) {
+	const style = poChildren(sp).find((c) => poIs(c, `${ns}:style`));
+	const fillRef = style ? poChildren(style).find((c) => poIs(c, "a:fillRef")) : void 0;
+	if (!fillRef || poAttr(fillRef, "idx") === "0") return { kind: "none" };
+	const child = poFirstElement(fillRef);
+	const colorHex = child ? resolveColorNode(child, colors) : void 0;
+	if (colorHex === void 0) return { kind: "none" };
+	const idx = Number(poAttr(fillRef, "idx") ?? "");
+	const slot = Number.isFinite(idx) ? themeFillStyles[idx - 1] : void 0;
+	if (!slot) return {
+		kind: "solid",
+		colorHex
+	};
+	const themed = parseFill({ "a:spPr": [slot] }, placeholderColors(colors, colorHex));
+	return themed.kind === "none" ? {
+		kind: "solid",
+		colorHex
+	} : themed;
+}
+/**
+* §20.1.4.2.10 — inside a theme's style list, `phClr` stands for "the colour the
+* reference names". Every other colour resolves as it always did.
+*
+* @param colors The workbook's own resolver.
+* @param phHex  The colour the `a:fillRef` / `a:lnRef` carries.
+* @returns A resolver that answers `phClr` with that colour, transforms and all.
+*/
+function placeholderColors(colors, phHex) {
+	return (raw) => "scheme" in raw && raw.scheme === "phClr" ? applyColorMods(phHex, raw.mods ?? []) : colors(raw);
+}
+/**
+* The shadow `<xdr:style><a:effectRef>` names, if it names one.
+*
+* §20.1.4.2.8, the same mechanism as the fill and the outline beside it: a
+* shape drawn from a gallery style carries no `a:effectLst`, only an index into
+* the theme's `a:effectStyleLst`, and the colour to put where the style says
+* `phClr`. 47504.xlsx asks for slot 2 that way — the soft shadow both
+* references draw under it, and which we drew not at all.
+*
+* @param sp                The `xdr:sp` node.
+* @param colors            The workbook's colour resolver.
+* @param themeEffectStyles The theme's `a:effectStyleLst` nodes.
+* @returns The shadow, or undefined when the shape names no effect style.
+*/
+function styleShadow(sp, ns, colors, themeEffectStyles) {
+	const style = poChildren(sp).find((c) => poIs(c, `${ns}:style`));
+	const ref = style ? poChildren(style).find((c) => poIs(c, "a:effectRef")) : void 0;
+	if (!ref) return void 0;
+	const idx = Number(poAttr(ref, "idx") ?? "");
+	if (!Number.isFinite(idx) || idx < 1) return void 0;
+	const slot = themeEffectStyles[idx - 1];
+	const list = slot ? poFirstChild(slot, "a:effectLst") : void 0;
+	const shdw = list ? poFirstChild(list, "a:outerShdw") : void 0;
+	if (!shdw) return void 0;
+	const child = poFirstElement(ref);
+	const phHex = child ? resolveColorNode(child, colors) : void 0;
+	return shadowFromOuterShdw(shdw, phHex ? placeholderColors(colors, phHex) : colors);
+}
+/** The colour `<xdr:style><a:fontRef>` names, if it names one. */
+function styleFontColor(sp, ns, colors) {
+	const style = poChildren(sp).find((c) => poIs(c, `${ns}:style`));
+	const child = poFirstElement(style ? poChildren(style).find((c) => poIs(c, "a:fontRef")) : void 0);
+	return child ? resolveColorNode(child, colors) : void 0;
+}
+/** The text body with that colour filled in wherever a run declares none. */
+function withStyleTextColor(text, sp, ns, colors) {
+	const colorHex = styleFontColor(sp, ns, colors);
+	if (colorHex === void 0) return text;
+	return {
+		...text,
+		content: text.content.map((block) => block.kind === "paragraph" ? {
+			...block,
+			paragraph: {
+				...block.paragraph,
+				runs: block.paragraph.runs.map((run) => run.properties.colorHex === void 0 ? {
+					...run,
+					properties: {
+						...run.properties,
+						colorHex
+					}
+				} : run)
+			}
+		} : block)
+	};
 }
 function anchorBox(anchor, colWidthPt, rowHeightPt) {
 	const from = marker(poChildren(anchor).find((c) => poIs(c, "xdr:from")));
@@ -65,21 +459,56 @@ function anchorBox(anchor, colWidthPt, rowHeightPt) {
 		if (!from || !to) return void 0;
 		const widthPt = span(from.col, from.colOffPt, to.col, to.colOffPt, colWidthPt);
 		const heightPt = span(from.row, from.rowOffPt, to.row, to.rowOffPt, rowHeightPt);
-		return widthPt > 0 && heightPt > 0 ? {
+		if (!(widthPt > 0 && heightPt > 0)) return void 0;
+		return {
 			widthPt,
 			heightPt,
-			anchorRow: from.row
-		} : void 0;
+			anchorRow: from.row,
+			xPt: origin(from.col, from.colOffPt, colWidthPt),
+			yPt: origin(from.row, from.rowOffPt, rowHeightPt)
+		};
 	}
 	const ext = poChildren(anchor).find((c) => poIs(c, "xdr:ext"));
 	if (!ext) return void 0;
+	const pos = absolutePos(anchor);
 	const widthPt = emuToPt(poIntAttr(ext, "cx") ?? 0);
 	const heightPt = emuToPt(poIntAttr(ext, "cy") ?? 0);
-	return widthPt > 0 && heightPt > 0 ? {
+	if (!(widthPt > 0 && heightPt > 0)) return void 0;
+	return {
 		widthPt,
 		heightPt,
-		anchorRow: from?.row ?? 0
-	} : void 0;
+		anchorRow: from?.row ?? 0,
+		xPt: from ? origin(from.col, from.colOffPt, colWidthPt) : pos.xPt,
+		yPt: from ? origin(from.row, from.rowOffPt, rowHeightPt) : pos.yPt
+	};
+}
+/**
+* §20.5.2.1 `absoluteAnchor` names no cell: it gives the distance from the
+* sheet's own corner in `<xdr:pos>`. Read nowhere, both of
+* tdf139763ShapeAnchor.xlsx's arrows piled into the top-left corner.
+*
+* @param anchor The anchor element.
+* @returns The offset in points; zero for an anchor that states none.
+*/
+function absolutePos(anchor) {
+	const node = poChildren(anchor).find((c) => poIs(c, "xdr:pos"));
+	if (!node) return {
+		xPt: 0,
+		yPt: 0
+	};
+	return {
+		xPt: emuToPt(poIntAttr(node, "x") ?? 0),
+		yPt: emuToPt(poIntAttr(node, "y") ?? 0)
+	};
+}
+/**
+* The distance from the sheet's origin to a marker: every whole track before it
+* plus the marker's own offset into the one it lands in.
+*/
+function origin(index, offsetPt, trackPt) {
+	let total = 0;
+	for (let i = 0; i < index; i++) total += trackPt(i);
+	return total + offsetPt;
 }
 function marker(node) {
 	if (!node) return void 0;
@@ -105,4 +534,4 @@ function span(from, fromOffPt, to, toOffPt, trackPt) {
 	return total - fromOffPt + toOffPt;
 }
 //#endregion
-export { parseSheetShapes };
+export { parseDiagramFrames, parseDiagramShapes, parseSheetShapes };

package/dist/esm/excel/sheet-to-flow.d.ts

@@ -21,12 +21,33 @@ export interface ProjectSheetOptions {
      * unreported.
      */
     readonly losses?: Array<Loss>;
+    /**
+     * Width of a digit in the font the document will actually be rendered in, at
+     * the workbook's default size, in points.
+     *
+     * §18.3.1.13 measures a column in Maximum Digit Widths of the workbook's own
+     * default font — the unit is a property of the font, not a constant. Laying
+     * columns out in one font's digit and then drawing the text in another makes
+     * every column the wrong width for its contents: with Calibri's 5.25 pt
+     * assumed and Roboto's 6.18 pt drawn, a column holds a sixth less than the
+     * file says, and the text that does not fit is clipped away.
+     *
+     * Omitted ⇒ Excel's own 7 px, which is right only if the render font matches
+     * the workbook's.
+     */
+    readonly digitWidthPt?: number;
+    /**
+     * §18.3.1.34 `&F` — the workbook's file name, for a header or footer that
+     * prints it. The reader takes bytes and cannot know it, so the caller
+     * supplies it; absent, the code is dropped exactly as before.
+     */
+    readonly fileName?: string;
 }
 /**
  * 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).