reamkit 1.23.0 → 1.25.0

package/dist/esm/pptx/pptx-reader.js

@@ -4,6 +4,7 @@ import { FEATURES } from "../core/ir/features.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
 import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs } from "../core/po-helpers.js";
+import { cachedDiagramTree, laidOutDiagramTree } from "../core/drawingml/diagram/run.js";
 import { packageHasPart } from "../core/bytes.js";
 import { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
@@ -207,7 +208,81 @@ function parseSlide(tree, ctx, inheritedBg, pageW, pageH, inheritedShapes = [])
 	if (bg) out.push(backdropElement(bg, pageW, pageH));
 	out.push(...inheritedShapes.map(asBackdrop));
 	if (spTree) out.push(...parseSlideShapes(spTree, shapeCtx));
-	return out;
+	out.push(...parseSlideControls(cSld, shapeCtx));
+	return inPaintOrder(out);
+}
+/**
+* §19.3.1 — a slide's shape tree IS its z-order: what stands later in it is
+* drawn over what stands earlier, whatever KIND either of them is.
+*
+* The page otherwise paints kind by kind — every image, then every shape — and
+* on a slide that is simply wrong. 54542_cropped_bitmap.pptx is six logos each
+* standing on its own coloured panel, written panel-then-logo six times over,
+* and painted by kind all six logos went down first and all six panels covered
+* them.
+*
+* @param elements The slide's elements, in the order the tree gives them.
+* @returns The same elements, each float carrying its place in that order.
+*/
+function inPaintOrder(elements) {
+	return elements.map((el, z) => {
+		if (el.kind === "shape") return {
+			...el,
+			shape: withZ(el.shape, z)
+		};
+		if (el.kind === "image") return {
+			...el,
+			image: withZ(el.image, z)
+		};
+		if (el.kind === "table") {
+			const anchor = el.table.properties.float;
+			return anchor ? {
+				...el,
+				table: {
+					...el.table,
+					properties: {
+						...el.table.properties,
+						float: {
+							...anchor,
+							zOrder: z
+						}
+					}
+				}
+			} : el;
+		}
+		return el;
+	});
+}
+/** The same block with its float carrying `z`, when it floats at all. */
+function withZ(block, z) {
+	return block.float ? {
+		...block,
+		float: {
+			...block.float,
+			zOrder: z
+		}
+	} : block;
+}
+/**
+* §19.3.1.15 `p:controls` — the ActiveX controls a slide carries.
+*
+* They sit BESIDE the shape tree rather than in it, so a reader that walks
+* `p:spTree` alone never sees them. Each one's `mc:Fallback` is a `p:pic` of
+* what the control looks like — the picture PowerPoint cached precisely so that
+* a reader which cannot run the control still draws it — and by the time the
+* slide is parsed the alternate content is already resolved to that fallback.
+* activex_picture.pptx is seventeen of them over an EMPTY `p:spTree`, and it
+* rendered as a blank page.
+*
+* @param cSld The slide's `p:cSld`.
+* @param ctx  The slide's parsing context.
+* @returns The controls' cached pictures as ordinary floating pictures.
+*/
+function parseSlideControls(cSld, ctx) {
+	const controls = cSld ? poChildren(cSld).find((c) => poIs(c, "p:controls")) : void 0;
+	if (!controls) return [];
+	const pics = poChildren(controls).flatMap((c) => poIs(c, "p:control") ? poChildren(c).filter((k) => poIs(k, "p:pic")) : []);
+	return pics.length === 0 ? [] : parseSlideShapes({ "p:spTree": pics }, ctx);
 }
 function partBackground(tree, root, colors, resolveImage, themeFills) {
 	const sld = tree.find((n) => poIs(n, root));
@@ -312,23 +387,28 @@ function makeSlideChartResolver(pkg, slidePath, charts, colors, resources) {
 }
 function makeSlideDiagramResolver(pkg, slidePath) {
 	const cache = /* @__PURE__ */ new Map();
-	return (relId) => {
+	return (relId, frame) => {
 		if (cache.has(relId)) return cache.get(relId);
-		let spTree;
 		const dataRel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
 		const data = dataRel ? pkg.resolveRelatedPart(slidePath, dataRel) : void 0;
 		const draw = data ? drawingPart(pkg, slidePath, data) : void 0;
-		if (draw) for (const root of parseXml(draw.data)) {
-			const found = poFindDescendant(root, "dsp:spTree");
-			if (found) {
-				spTree = found;
-				break;
-			}
-		}
+		let spTree = draw ? cachedDiagramTree(draw.data, parseXml) : void 0;
+		if (!spTree && data) spTree = laidOutDiagram(pkg, slidePath, data, frame);
 		cache.set(relId, spTree);
 		return spTree;
 	};
 }
+function laidOutDiagram(pkg, slidePath, data, frame) {
+	const related = (type) => {
+		const rel = pkg.getPartRelationships(slidePath).find((r) => r.type.endsWith(type));
+		return rel ? pkg.resolveRelatedPart(slidePath, rel)?.data : void 0;
+	};
+	return laidOutDiagramTree({
+		data: data.data,
+		layout: related("/diagramLayout"),
+		colors: related("/diagramColors")
+	}, frame, parseXml);
+}
 /**
 * The pre-rendered drawing a diagram's data part points at.
 *

package/dist/esm/pptx/slide-parser.d.ts

@@ -59,7 +59,10 @@ export interface SlideContext {
      * drawing override (its `dsp:spTree`), or `undefined` when the file ships no
      * override (E-SMARTART SA0).
      */
-    readonly resolveDiagram?: (relId: string) => PoNode | undefined;
+    readonly resolveDiagram?: (relId: string, frame: {
+        readonly cx: number;
+        readonly cy: number;
+    }) => PoNode | undefined;
     /**
      * Sink for graceful-degradation notices (E-SMARTART SA3): a SmartArt that
      * declares a diagram but ships no drawing override records a dropped-feature

package/dist/esm/pptx/slide-parser.js

@@ -1,10 +1,11 @@
 import { emuToPt, pt } from "../core/ir/units.js";
 import { FEATURES } from "../core/ir/features.js";
+import { isTextWarp } from "../core/drawingml/text-warp.js";
 import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poTag, poText } from "../core/po-helpers.js";
 import { defaultColorResolver, placeholderColors, resolveColorNode } from "../core/drawingml/colors.js";
 import { boxFromXfrm, parsePh, parseXfrmBox, rPrToRunProps } from "./sp-helpers.js";
 import { lineSpacing, parseBullet, spacingFractions, spacingFromLineFraction } from "./placeholder-cascade.js";
-import { colorChangeOf, parseCustGeom, parseFill, parseLine, parsePrstGeom, parseShadow, parseXfrm, statesFill, styleRefFill, styleRefFontColor, styleRefLine } from "../word/drawing-parser.js";
+import { colorChangeOf, parseCustGeom, parseFill, parseLine, parsePrstGeom, parseShadow, parseSrcRect, parseXfrm, statesFill, styleRefFill, styleRefFontColor, styleRefLine, withStatedDirection } from "../word/drawing-parser.js";
 import { cellStyle, lineBorder, tableStyleFlags, tableStyleId, withCellStyle, withoutFill } from "./table-style.js";
 //#region src/pptx/slide-parser.ts
 var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
@@ -46,17 +47,49 @@ function parseSlideShapes(container, ctx = {}, transform = IDENTITY_TRANSFORM, s
 				shape
 			});
 		} else if (poIs(child, "p:pic")) {
-			const image = parsePic(child, ctx, transform);
-			if (image) out.push({
-				kind: "image",
-				image
+			const clipped = pictureAsShape(child);
+			const shape = clipped ? parseSp(clipped, ctx, transform) : void 0;
+			if (shape) out.push({
+				kind: "shape",
+				shape
 			});
+			else {
+				const image = parsePic(child, ctx, transform);
+				if (image) out.push({
+					kind: "image",
+					image
+				});
+			}
 		} else if (poIs(child, "p:graphicFrame")) out.push(...parseGraphicFrame(child, ctx, transform));
 		else if (poIs(child, "p:grpSp")) out.push(...parseSlideShapes(child, ctx, composeGroupTransform(child, transform), skipPlaceholders));
 	}
 	return out;
 }
 /**
+* A `p:pic` that names a geometry of its own, rewritten as the `p:sp` it is.
+*
+* A picture holds its `p:blipFill` BESIDE `p:spPr`; a shape holds its fill
+* INSIDE it, under the drawing namespace. Moving the one into the other is the
+* whole difference, and it buys the shape path entire — the geometry, the
+* outline, the crop, the recolour — instead of a second clipper that would
+* drift from it.
+*
+* @param pic The `p:pic` node.
+* @returns The equivalent `p:sp`, or undefined when the picture is a plain
+*          rectangle and wants no clipping at all.
+*/
+function pictureAsShape(pic) {
+	const spPr = poChildren(pic).find((c) => poIs(c, "p:spPr"));
+	const prst = spPr ? poChildren(spPr).find((c) => poIs(c, "a:prstGeom")) : void 0;
+	const custom = spPr ? poChildren(spPr).find((c) => poIs(c, "a:custGeom")) : void 0;
+	const shape = poAttr(prst, "prst");
+	if (custom === void 0 && (shape === void 0 || shape === "rect")) return void 0;
+	const blipFill = poChildren(pic).find((c) => poIs(c, "p:blipFill"));
+	if (!blipFill || !spPr) return void 0;
+	const nv = poChildren(pic).find((c) => poIs(c, "p:nvPicPr"));
+	return { "p:sp": [...nv ? [{ "p:nvSpPr": poChildren(nv) }] : [], { "p:spPr": [{ "a:blipFill": poChildren(blipFill) }, ...poChildren(spPr)] }] };
+}
+/**
 * Whether a shape is a placeholder — `p:ph` in its OWN non-visual properties.
 * Read as "anywhere below", a group holding one would take the whole group
 * with it.
@@ -132,7 +165,7 @@ function parseSp(sp, ctx, transform) {
 	const ownFill = stated(statesFill);
 	const styleFill = style ? styleRefFill(style, colors, themeStyles) : void 0;
 	const lentFill = lent(statesFill);
-	const styled = useBgFill ? backgroundThrough(ctx.backgroundFill, box, ctx.slideSize) : ownFill ? parseFill(ownFill, colors, ctx.resolveImage) : styleFill && styleFill.kind !== "none" ? styleFill : lentFill ? parseFill(lentFill, colors, ctx.resolveImage) : spPr ? parseFill(spPr, colors, ctx.resolveImage) : { kind: "none" };
+	const styled = withStatedDirection(useBgFill ? backgroundThrough(ctx.backgroundFill, box, ctx.slideSize) : ownFill ? parseFill(ownFill, colors, ctx.resolveImage) : styleFill && styleFill.kind !== "none" ? styleFill : lentFill ? parseFill(lentFill, colors, ctx.resolveImage) : spPr ? parseFill(spPr, colors, ctx.resolveImage) : { kind: "none" }, spPr);
 	const lineFrom = from((n) => poChildren(n).some((c) => poIs(c, "a:ln")));
 	let line = lineFrom ? parseLine(lineFrom, colors) : void 0;
 	if (style) {
@@ -236,7 +269,10 @@ function parseGraphicFrame(gf, ctx, transform) {
 	if (uri === DIAGRAM_URI) {
 		const relIds = poFindDescendant(gf, "dgm:relIds");
 		const dmRelId = relIds ? poAttr(relIds, "dm") : void 0;
-		const spTree = dmRelId !== void 0 ? ctx.resolveDiagram?.(dmRelId) : void 0;
+		const spTree = dmRelId !== void 0 ? ctx.resolveDiagram?.(dmRelId, {
+			cx: box.cx,
+			cy: box.cy
+		}) : void 0;
 		if (!spTree) {
 			if (dmRelId !== void 0) ctx.onLoss?.(noDiagramOverrideLoss());
 			return [];
@@ -551,7 +587,10 @@ function parseGeometry(spPr) {
 	return RECT_GEOMETRY;
 }
 function parsePic(pic, ctx, transform) {
-	const own = parseXfrmBox(poChildren(pic).find((c) => poIs(c, "p:spPr")));
+	const spPr = poChildren(pic).find((c) => poIs(c, "p:spPr"));
+	const ph = parsePh(pic);
+	let own = parseXfrmBox(spPr);
+	if (!own && ph && ctx.cascade) own = ctx.cascade.geometryFor(ph);
 	if (!own) return void 0;
 	const box = transform(own);
 	const blipFill = poChildren(pic).find((c) => poIs(c, "p:blipFill"));
@@ -562,12 +601,19 @@ function parsePic(pic, ctx, transform) {
 	const fixed = blip ? poChildren(blip).find((c) => poIs(c, "a:alphaModFix")) : void 0;
 	const amt = fixed ? poIntAttr(fixed, "amt") : void 0;
 	const alpha = amt === void 0 ? void 0 : Math.min(1, Math.max(0, amt / 1e5));
+	const crop = parseSrcRect(blipFill ? poFindDescendant(blipFill, "a:srcRect") : void 0);
+	const xfrm = spPr ? poChildren(spPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+	const rot = xfrm ? poIntAttr(xfrm, "rot") : void 0;
 	const altText = picAltText(pic);
 	return {
 		float: floatAt(box),
 		...resource !== void 0 ? { resource } : {},
 		...colorChange ? { colorChange } : {},
 		...alpha !== void 0 && alpha < 1 ? { alpha } : {},
+		...crop ? { crop } : {},
+		...rot !== void 0 && rot !== 0 ? { rotation60k: rot } : {},
+		...poAttr(xfrm, "flipH") === "1" ? { flipH: true } : {},
+		...poAttr(xfrm, "flipV") === "1" ? { flipV: true } : {},
 		width: emuToPt(box.cx),
 		height: emuToPt(box.cy),
 		paragraphProperties: {},
@@ -616,6 +662,12 @@ function parseTxBody(txBody, ph, cascade, colors, resolveLink, styleColor, theme
 	const rIns = bodyPr ? poIntAttr(bodyPr, "rIns") : void 0;
 	const bIns = bodyPr ? poIntAttr(bodyPr, "bIns") : void 0;
 	const a = bodyPr ? poAttr(bodyPr, "anchor") : void 0;
+	const autofit = bodyPr ? poChildren(bodyPr).find((c) => poIs(c, "a:normAutofit")) : void 0;
+	const shrink = autofit !== void 0 && poIntAttr(autofit, "fontScale") === void 0;
+	const warp = bodyPr ? textWarp(bodyPr) : void 0;
+	const v = bodyPr ? poAttr(bodyPr, "vert") : void 0;
+	const vertical = v === "vert270" ? "vert270" : v !== void 0 && v !== "horz" ? "vert" : void 0;
+	const upright = bodyPr ? poAttr(bodyPr, "upright") === "1" : false;
 	const anchor = a === "ctr" || a === "b" || a === "t" ? a : ph && cascade ? cascade.anchorFor(ph) : void 0;
 	return {
 		content: fitted,
@@ -623,7 +675,33 @@ function parseTxBody(txBody, ph, cascade, colors, resolveLink, styleColor, theme
 		...tIns !== void 0 ? { insetTop: emuToPt(tIns) } : {},
 		...rIns !== void 0 ? { insetRight: emuToPt(rIns) } : {},
 		...bIns !== void 0 ? { insetBottom: emuToPt(bIns) } : {},
-		...anchor ? { anchor } : {}
+		...anchor ? { anchor } : {},
+		...vertical ? { vertical } : {},
+		...upright ? { upright } : {},
+		...shrink ? { shrinkToFit: true } : {},
+		...warp ? { warp } : {}
+	};
+}
+/**
+* §20.1.9.10 `a:prstTxWarp` — the WordArt curve a body's text is bent through,
+* with the `a:avLst` `adj` guide when it states one. Unread, tdf114848's eight
+* pieces of WordArt were set as eight ordinary paragraphs, each wrapped onto
+* three lines of upright type where both references draw one bent line.
+*
+* @param bodyPr The body's `a:bodyPr`.
+* @returns The preset and its adjustment, or `undefined` when the body states
+*          no warp or states the enumeration's `textNoShape`.
+*/
+function textWarp(bodyPr) {
+	const node = poChildren(bodyPr).find((c) => poIs(c, "a:prstTxWarp"));
+	const preset = node ? poAttr(node, "prst") : void 0;
+	if (node === void 0 || preset === void 0 || !isTextWarp(preset)) return void 0;
+	const avLst = poChildren(node).find((c) => poIs(c, "a:avLst"));
+	const adj = avLst ? poChildren(avLst).find((c) => poIs(c, "a:gd") && poAttr(c, "name") === "adj") : void 0;
+	const value = adj ? /^val\s+(-?\d+)$/u.exec(poAttr(adj, "fmla") ?? "")?.[1] : void 0;
+	return {
+		preset,
+		...value !== void 0 ? { adjust: Number(value) } : {}
 	};
 }
 /**
@@ -683,9 +761,19 @@ function parseSlideParagraph(aP, ph, cascade, colors, resolveLink, counters, sty
 	const algn = pPr ? poAttr(pPr, "algn") : void 0;
 	const alignment = algn !== void 0 ? ALGN_TO_ALIGNMENT[algn] : void 0;
 	const runs = [];
-	for (const child of poChildren(aP)) if (poIs(child, "a:r") || poIs(child, "a:fld")) {
-		const run = parseSlideRun(child, defaults, colors, resolveLink, themeFonts);
-		if (run) runs.push(run);
+	for (const child of poChildren(aP)) {
+		if (poIs(child, "a:br")) {
+			const last = runs[runs.length - 1];
+			if (last) runs[runs.length - 1] = {
+				...last,
+				text: `${last.text}\n`
+			};
+			continue;
+		}
+		if (poIs(child, "a:r") || poIs(child, "a:fld")) {
+			const run = parseSlideRun(child, defaults, colors, resolveLink, themeFonts);
+			if (run) runs.push(run);
+		}
 	}
 	const marL = pPr ? poIntAttr(pPr, "marL") : void 0;
 	const indent = pPr ? poIntAttr(pPr, "indent") : void 0;
@@ -840,12 +928,15 @@ function parseTableCell(tc, colors) {
 	const tcPr = poChildren(tc).find((c) => poIs(c, "a:tcPr"));
 	const shadingHex = tcPr ? cellFillHex(tcPr, colors) : void 0;
 	const borders = tcPr ? cellOwnBorders(tcPr, colors) : void 0;
+	const vert = tcPr ? poAttr(tcPr, "vert") : void 0;
+	const textDirection = vert === "vert" || vert === "eaVert" || vert === "mongolianVert" ? "vert" : vert === "vert270" ? "vert270" : void 0;
 	return {
 		properties: {
 			...gridSpan !== void 0 && gridSpan > 1 ? { colSpan: gridSpan } : {},
 			...merge ? { merge } : {},
 			...shadingHex ? { shading: { colorHex: shadingHex } } : {},
-			...borders ? { borders } : {}
+			...borders ? { borders } : {},
+			...textDirection ? { textDirection } : {}
 		},
 		content
 	};

package/dist/esm/pptx/sp-helpers.d.ts

@@ -19,9 +19,13 @@ export interface ShapeBoxEmu {
     readonly cy: number;
 }
 /**
- * `p:nvSpPr/p:nvPr/p:ph` → the placeholder reference, or `undefined` for an
- * ordinary (non-placeholder) shape. A bare `<p:ph/>` returns an empty ref (still
- * a placeholder: `type` defaults to `'obj'`).
+ * `p:nvPr/p:ph` → the placeholder reference, or `undefined` for an ordinary
+ * (non-placeholder) shape. A bare `<p:ph/>` returns an empty ref (still a
+ * placeholder: `type` defaults to `'obj'`).
+ *
+ * A PICTURE is a placeholder as readily as a shape is — a content placeholder
+ * filled with a photograph writes `p:nvPicPr/p:nvPr/p:ph` and an EMPTY `p:spPr`,
+ * leaving its whole geometry to the layout (customshape-bitmapfill-srcrect).
  */
 export declare function parsePh(sp: PoNode): PlaceholderRef | undefined;
 /**

package/dist/esm/pptx/sp-helpers.js

@@ -4,14 +4,24 @@ import { resolveColorNode } from "../core/drawingml/colors.js";
 import { resolveThemeFont } from "../core/drawingml/theme-parser.js";
 //#region src/pptx/sp-helpers.ts
 var isTrue = (v) => v === "1" || v === "true" || v === "on";
+var NON_VISUAL = [
+	"p:nvSpPr",
+	"p:nvPicPr",
+	"p:nvGraphicFramePr",
+	"p:nvCxnSpPr"
+];
 /**
-* `p:nvSpPr/p:nvPr/p:ph` → the placeholder reference, or `undefined` for an
-* ordinary (non-placeholder) shape. A bare `<p:ph/>` returns an empty ref (still
-* a placeholder: `type` defaults to `'obj'`).
+* `p:nvPr/p:ph` → the placeholder reference, or `undefined` for an ordinary
+* (non-placeholder) shape. A bare `<p:ph/>` returns an empty ref (still a
+* placeholder: `type` defaults to `'obj'`).
+*
+* A PICTURE is a placeholder as readily as a shape is — a content placeholder
+* filled with a photograph writes `p:nvPicPr/p:nvPr/p:ph` and an EMPTY `p:spPr`,
+* leaving its whole geometry to the layout (customshape-bitmapfill-srcrect).
 */
 function parsePh(sp) {
-	const nvSpPr = poChildren(sp).find((c) => poIs(c, "p:nvSpPr"));
-	const nvPr = nvSpPr ? poChildren(nvSpPr).find((c) => poIs(c, "p:nvPr")) : void 0;
+	const nonVisual = poChildren(sp).find((c) => NON_VISUAL.some((n) => poIs(c, n)));
+	const nvPr = nonVisual ? poChildren(nonVisual).find((c) => poIs(c, "p:nvPr")) : void 0;
 	const ph = nvPr ? poChildren(nvPr).find((c) => poIs(c, "p:ph")) : void 0;
 	if (!ph) return void 0;
 	const type = poAttr(ph, "type");
@@ -88,8 +98,36 @@ function capsOf(cap) {
 }
 function solidFillColor(rPr, colors) {
 	const solidFill = poChildren(rPr).find((c) => poIs(c, "a:solidFill"));
-	if (!solidFill) return void 0;
-	for (const c of poChildren(solidFill)) {
+	if (solidFill) {
+		for (const c of poChildren(solidFill)) {
+			const hex = resolveColorNode(c, colors);
+			if (hex) return hex;
+		}
+		return;
+	}
+	return gradientFillColor(rPr, colors);
+}
+/**
+* §20.1.8.33 — a run may be filled with a GRADIENT, and WordArt always is: the
+* text of tdf114848's second page runs through five stops of accent1. A run
+* here wears one colour, so the gradient gives up the stop nearest its middle —
+* the one most of the glyph is painted in. Unread, the run had no colour at all
+* and every word came out in the default black.
+*/
+function gradientFillColor(rPr, colors) {
+	const grad = poChildren(rPr).find((c) => poIs(c, "a:gradFill"));
+	const list = grad ? poChildren(grad).find((c) => poIs(c, "a:gsLst")) : void 0;
+	const stops = list ? poChildren(list).filter((c) => poIs(c, "a:gs")) : [];
+	let best;
+	for (const gs of stops) {
+		const at = Math.abs((poIntAttr(gs, "pos") ?? 0) - 5e4);
+		if (!best || at < best.at) best = {
+			at,
+			node: gs
+		};
+	}
+	if (!best) return void 0;
+	for (const c of poChildren(best.node)) {
 		const hex = resolveColorNode(c, colors);
 		if (hex) return hex;
 	}

package/dist/esm/pptx/table-style.d.ts

@@ -13,6 +13,13 @@ export interface TableStyleFlags {
 /** What one part of a table style says about a cell. */
 export interface TableStylePart {
     readonly shadingHex?: string;
+    /**
+     * §20.1.2.3.1 — how opaque that shading is, when the part asks for less than
+     * all of it. A cell's fill is a layer over the table's background, not over
+     * the page, so the two have to be composed rather than each flattened to
+     * white on its own.
+     */
+    readonly shadingAlpha?: number;
     readonly borders?: CellBorders;
     readonly bold?: boolean;
     readonly italic?: boolean;

package/dist/esm/pptx/table-style.js

@@ -1,6 +1,6 @@
 import { pt } from "../core/ir/units.js";
 import { poAttr, poChildren, poIntAttr, poIs, poTag, poText } from "../core/po-helpers.js";
-import { readColorMods, resolveColorNode } from "../core/drawingml/colors.js";
+import { placeholderColors, readColorMods, resolveColorNode } from "../core/drawingml/colors.js";
 //#region src/pptx/table-style.ts
 /** The `a:tblPr` flags, all off unless the table says otherwise. */
 function tableStyleFlags(tblPr) {
@@ -40,12 +40,57 @@ function cellStyle(style, flags, at, colors, theme) {
 	let out = tableBackground(style, colors, theme);
 	for (const name of names) {
 		const part = poChildren(style).find((c) => poIs(c, name));
-		if (part) out = {
+		if (!part) continue;
+		const next = partStyle(part, colors, theme);
+		out = {
 			...out,
-			...partStyle(part, colors, theme)
+			...next,
+			...overFill(out.shadingHex, next)
 		};
 	}
-	return out;
+	const { shadingAlpha: _drop, ...flat } = out;
+	return flat;
+}
+/**
+* A part's fill laid OVER what is already under it.
+*
+* A colour resolves flattened against the page, because that is what a shape's
+* fill sits on; a table cell's sits on the table's background. Undoing the one
+* and redoing the other needs only the alpha: bnc480256's banding is `accent1`
+* at 40% over a background the theme's gradient makes pale, and taken against
+* white instead it came out as the flat accent with every second row white.
+*/
+function overFill(under, part) {
+	const a = part.shadingAlpha;
+	if (a === void 0 || a >= 1 || part.shadingHex === void 0 || under === void 0) return {};
+	const flat = rgb(part.shadingHex);
+	const back = rgb(under);
+	if (!flat || !back) return {};
+	return { shadingHex: toHex(flat.map((v, i) => v - (1 - a) * (1 - (back[i] ?? 1)))) };
+}
+function alphaOf(fill) {
+	const walk = (node) => {
+		for (const child of poChildren(node)) {
+			if (poIs(child, "a:alpha")) {
+				const v = poIntAttr(child, "val");
+				if (v !== void 0) return Math.max(0, Math.min(1, v / 1e5));
+			}
+			const deeper = walk(child);
+			if (deeper !== void 0) return deeper;
+		}
+	};
+	return walk(fill) ?? 1;
+}
+function rgb(h) {
+	const m = /^([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/u.exec(h);
+	return m ? [
+		1,
+		2,
+		3
+	].map((i) => parseInt(m[i] ?? "0", 16) / 255) : void 0;
+}
+function toHex(v) {
+	return v.map((c) => Math.round(Math.max(0, Math.min(1, c)) * 255).toString(16).padStart(2, "0").toUpperCase()).join("");
 }
 function tableBackground(style, colors, theme) {
 	const bg = poChildren(style).find((c) => poIs(c, "a:tblBg"));
@@ -68,9 +113,14 @@ function refFillColor(ref, colors, theme) {
 	const idx = poIntAttr(ref, "idx");
 	const slot = idx !== void 0 && idx > 0 ? theme?.fills?.[idx - 1] : void 0;
 	if (!slot) return own;
-	const solid = poChildren(slot).find((c) => poIs(c, "a:solidFill"));
-	const slotHex = solid ? colorOf(solid, colors) : void 0;
-	return slotHex && slotHex !== "PHCLR" ? own ?? slotHex : own;
+	const named = own === void 0 ? colors : placeholderColors(colors, own);
+	const solid = poIs(slot, "a:solidFill") ? slot : void 0;
+	if (solid) return colorOf(solid, named) ?? own;
+	const grad = poIs(slot, "a:gradFill") ? slot : void 0;
+	const list = grad ? poChildren(grad).find((c) => poIs(c, "a:gsLst")) : void 0;
+	const stops = list ? poChildren(list).filter((c) => poIs(c, "a:gs")) : [];
+	const last = stops[stops.length - 1];
+	return (last ? colorOf(last, named) : void 0) ?? own;
 }
 function bandName(index, edge, axis) {
 	return (edge ? index - 1 : index) % 2 === 0 ? `a:band1${axis}` : `a:band2${axis}`;
@@ -81,12 +131,14 @@ function partStyle(part, colors, theme) {
 	const fill = tcStyle ? poChildren(tcStyle).find((c) => poIs(c, "a:fill")) : void 0;
 	const solid = fill ? poChildren(fill).find((c) => poIs(c, "a:solidFill")) : void 0;
 	const shadingHex = solid ? colorOf(solid, colors) : void 0;
+	const shadingAlpha = solid ? alphaOf(solid) : void 0;
 	const bdr = tcStyle ? poChildren(tcStyle).find((c) => poIs(c, "a:tcBdr")) : void 0;
 	const borders = bdr ? partBorders(bdr, colors, theme) : void 0;
 	const on = (name) => poAttr(txStyle, name) === "on";
 	const colorHex = txStyle ? colorOf(txStyle, colors) : void 0;
 	return {
 		...shadingHex ? { shadingHex } : {},
+		...shadingAlpha !== void 0 && shadingAlpha < 1 ? { shadingAlpha } : {},
 		...borders ? { borders } : {},
 		...txStyle && on("b") ? { bold: true } : {},
 		...txStyle && on("i") ? { italic: true } : {},

package/dist/esm/svg/svg-writer.js

@@ -88,6 +88,7 @@ function emitPage(out, page, laid, losses, idc) {
 	}
 	for (const sh of plan.shapes) emitShape(out, sh.shape, idc);
 	for (const picture of plan.pictures) for (const item of picture) emitPageItem(out, item, laid, losses, idc);
+	for (const run of plan.ordered) for (const item of run) emitPageItem(out, item, laid, losses, idc);
 	for (const t of plan.lines) emitTextLine(out, t, losses, idc);
 }
 /**

package/dist/esm/word/document-parser.d.ts

@@ -39,7 +39,10 @@ export interface ParseContext {
      * pre-rendered drawing override, or `undefined` when the file ships none
      * (E-SMARTART SA2).
      */
-    readonly resolveDiagram?: (relId: string) => ResolvedDiagram | undefined;
+    readonly resolveDiagram?: (relId: string, frame: {
+        readonly cx: number;
+        readonly cy: number;
+    }) => ResolvedDiagram | undefined;
     /**
      * §21.2 a `c:chart` `@r:id` → the chart part's path, the key the reader files
      * parsed charts under. Relationship ids are scoped to their owning part, so a

package/dist/esm/word/document-parser.js

@@ -484,7 +484,10 @@ function blocksForDrawing(content, paragraphProperties, ctx) {
 		}
 	}];
 	if (content.kind === "diagram") {
-		const diagram = ctx.resolveDiagram?.(content.dmRelId);
+		const diagram = ctx.resolveDiagram?.(content.dmRelId, {
+			cx: content.widthEmu,
+			cy: content.heightEmu
+		});
 		if (!diagram) {
 			ctx.onLoss?.(noDiagramOverrideLoss());
 			return null;

package/dist/esm/word/docx-reader.js

@@ -5,7 +5,7 @@ import { resolveTableStyles } from "../core/style-cascade/table.js";
 import "../core/style-cascade/index.js";
 import { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
 import "../core/numbering/index.js";
-import { poFindDescendant } from "../core/po-helpers.js";
+import { cachedDiagramTree, laidOutDiagramTree } from "../core/drawingml/diagram/run.js";
 import { packageHasPart } from "../core/bytes.js";
 import { DEFAULT_THEME_PALETTE, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
@@ -185,29 +185,42 @@ function infoFromCore(core) {
 }
 function makeDiagramResolver(pkg, partName, store) {
 	const cache = /* @__PURE__ */ new Map();
-	return (relId) => {
-		if (cache.has(relId)) return cache.get(relId);
+	return (relId, frame) => {
+		const key = `${relId}|${frame.cx}x${frame.cy}`;
+		if (cache.has(key)) return cache.get(key);
 		let resolved;
 		const dataRel = pkg.getPartRelationships(partName).find((r) => r.id === relId);
 		const data = dataRel ? pkg.resolveRelatedPart(partName, dataRel) : void 0;
 		if (data) {
 			const own = pkg.getPartRelationships(data.path).find((r) => r.type.endsWith("/diagramDrawing"));
 			const draw = own ? pkg.resolveRelatedPart(data.path, own) : drawingFromOwner(pkg, partName, data.path);
-			if (draw) for (const root of parseXml(draw.data)) {
-				const spTree = poFindDescendant(root, "dsp:spTree");
-				if (spTree) {
-					resolved = {
-						spTree,
-						resolveImage: makeImageResolver(pkg, store, draw.path)
-					};
-					break;
-				}
+			const cached = draw ? cachedDiagramTree(draw.data, parseXml) : void 0;
+			if (cached && draw) resolved = {
+				spTree: cached,
+				resolveImage: makeImageResolver(pkg, store, draw.path)
+			};
+			else {
+				const spTree = laidOutDiagramTree({
+					data: data.data,
+					layout: siblingPart(pkg, partName, data.path, "/diagramLayout"),
+					colors: siblingPart(pkg, partName, data.path, "/diagramColors")
+				}, frame, parseXml);
+				if (spTree) resolved = { spTree };
 			}
 		}
-		cache.set(relId, resolved);
+		cache.set(key, resolved);
 		return resolved;
 	};
 }
+function siblingPart(pkg, ownerPart, dataPart, type) {
+	const own = pkg.getPartRelationships(dataPart).find((r) => r.type.endsWith(type));
+	if (own) return pkg.resolveRelatedPart(dataPart, own)?.data;
+	const index = (path) => /(\d*)\.[^.]+$/u.exec(path)?.[1] ?? "";
+	const want = index(dataPart);
+	const rels = pkg.getPartRelationships(ownerPart).filter((r) => r.type.endsWith(type));
+	const rel = rels.find((r) => index(r.target) === want) ?? (rels.length === 1 ? rels[0] : void 0);
+	return rel ? pkg.resolveRelatedPart(ownerPart, rel)?.data : void 0;
+}
 function drawingFromOwner(pkg, ownerPart, dataPart) {
 	const drawings = pkg.getPartRelationships(ownerPart).filter((r) => r.type.endsWith("/diagramDrawing"));
 	if (drawings.length === 0) return void 0;