reamkit 1.23.0 → 1.24.0

package/dist/esm/core/metafile/emf.js

@@ -1,5 +1,5 @@
 import { PathBuilder } from "../vector.js";
-import { applyTransform, cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { applyTransform, clippedAway, cloneDc, colorRef, intersectClip, newDeviceContext, primBounds } from "./picture.js";
 import { cropDib, fadedDib, readDib } from "./dib.js";
 import { makeBlitter } from "./blit.js";
 import { fromSymbolFont } from "./symbol-fonts.js";
@@ -71,7 +71,14 @@ function readEmf(bytes) {
 	};
 	let building;
 	const open = () => building ?? [];
-	const blitter = makeBlitter((prim) => prims.push(prim));
+	const inFigure = () => {
+		const tail = building?.[building.length - 1];
+		return tail !== void 0 && tail.op !== "close";
+	};
+	const emit = (prim) => {
+		if (!clippedAway(dc, primBounds(prim))) prims.push(prim);
+	};
+	const blitter = makeBlitter(emit);
 	/**
 	* §2.3.1 — one blit record: the source bitmap into the destination
 	* rectangle, both stated in the record's own fields. The rectangle is mapped
@@ -101,7 +108,10 @@ function readEmf(bytes) {
 	};
 	const strokeOf = () => {
 		if (dc.pen.style === "none") return void 0;
-		const w = dc.pen.widthLu <= 1 ? 1 : dc.pen.widthLu * Math.abs(sx());
+		const m = dc.transform;
+		const world = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
+		const lu = dc.pen.widthLu * world;
+		const w = lu <= 1 ? 1 : lu * Math.abs(sx());
 		return {
 			colorHex: dc.pen.colorHex,
 			widthPt: w,
@@ -117,13 +127,22 @@ function readEmf(bytes) {
 		const st = stroke ? strokeOf() : void 0;
 		const fillHex = fill && !dc.brush.hollow ? dc.brush.colorHex : void 0;
 		if (fillHex === void 0 && !st) return;
-		prims.push({
+		emit({
 			kind: "path",
 			paths: [path],
 			...fillHex !== void 0 ? { fillColorHex: fillHex } : {},
 			...st ? { stroke: st } : {}
 		});
 	};
+	/** Two mapped corners → the rectangle they bound, in either order. */
+	function rectOf(a, b) {
+		return {
+			left: Math.min(a.x, b.x),
+			top: Math.min(a.y, b.y),
+			right: Math.max(a.x, b.x),
+			bottom: Math.max(a.y, b.y)
+		};
+	}
 	/** A closed rectangle, as the geometry records draw one. */
 	const rectSegments = (l, t, r, b) => {
 		const p0 = px(l, t);
@@ -176,6 +195,32 @@ function readEmf(bytes) {
 				};
 				haveView = true;
 				break;
+			case 30: {
+				const a = px(at(8), at(12));
+				const b = px(at(16), at(20));
+				dc = {
+					...dc,
+					clip: intersectClip(dc, rectOf(a, b))
+				};
+				break;
+			}
+			case 75: {
+				const cbRgnData = u(8);
+				const mode = u(12);
+				if (cbRgnData === 0 && mode === 5) {
+					const { clip: _drop, ...rest } = dc;
+					dc = rest;
+				} else if (mode === 5 && cbRgnData >= 32 && u(20) === 1) {
+					const base = off + 16 + 32;
+					const a = px(v.getInt32(base, true), v.getInt32(base + 4, true));
+					const b = px(v.getInt32(base + 8, true), v.getInt32(base + 12, true));
+					dc = {
+						...dc,
+						clip: rectOf(a, b)
+					};
+				}
+				break;
+			}
 			case 33:
 				stack.push(cloneDc(dc));
 				break;
@@ -281,7 +326,7 @@ function readEmf(bytes) {
 					dc.y = at(12);
 					const to = px(dc.x, dc.y);
 					if (building) {
-						if (building.length === 0) building.push({
+						if (!inFigure()) building.push({
 							op: "move",
 							x: from.x,
 							y: from.y
@@ -327,6 +372,11 @@ function readEmf(bytes) {
 			case 44:
 				paint(rectSegments(at(8), at(12), at(16), at(20)), true, true);
 				break;
+			case 47:
+			case 46:
+			case 45:
+				paint(arcSegments(px, at(8), at(12), at(16), at(20), at(24), at(28), at(32), at(36), type), type !== 45, true);
+				break;
 			case 3:
 			case 4:
 			case 2:
@@ -345,10 +395,13 @@ function readEmf(bytes) {
 					const segs = polySegments(px, pts, {
 						closed,
 						bezier: type === 2 || type === 5 || type === 85 || type === 88,
-						...type === 5 || type === 6 || type === 88 || type === 89 ? { from: {
-							x: dc.x,
-							y: dc.y
-						} } : {}
+						...type === 5 || type === 6 || type === 88 || type === 89 ? {
+							from: {
+								x: dc.x,
+								y: dc.y
+							},
+							joined: inFigure()
+						} : {}
 					});
 					if (pts.length > 0) {
 						dc.x = pts[pts.length - 1].x;
@@ -395,7 +448,7 @@ function readEmf(bytes) {
 					if (text.trim() !== "") {
 						const p = px(refX, refY);
 						const font = dc.font;
-						prims.push({
+						emit({
 							kind: "text",
 							text: fromSymbolFont(text, font?.family),
 							x: p.x,
@@ -422,6 +475,7 @@ function readEmf(bytes) {
 				const h = at(36);
 				if (cbBmiSrc === 0) {
 					const hex = rop === 66 ? "000000" : rop === 16711778 ? "FFFFFF" : void 0;
+					if (hex === void 0 && rop !== 15728673) break;
 					const brush = dc.brush;
 					if (hex !== void 0) dc.brush = {
 						kind: "brush",
@@ -671,12 +725,14 @@ function polySegments(map, pts, o) {
 	if (pts.length === 0) return segs;
 	let i = 0;
 	if (o.from) {
-		const s = map(o.from.x, o.from.y);
-		segs.push({
-			op: "move",
-			x: s.x,
-			y: s.y
-		});
+		if (o.joined !== true) {
+			const s = map(o.from.x, o.from.y);
+			segs.push({
+				op: "move",
+				x: s.x,
+				y: s.y
+			});
+		}
 	} else {
 		const s = map(pts[0].x, pts[0].y);
 		segs.push({
@@ -712,6 +768,78 @@ function polySegments(map, pts, o) {
 	return segs;
 }
 var KAPPA = .5522847498307936;
+/**
+* §2.3.5.2/.4/.13 — the wedge, chord or bare curve an `EMR_ARC`, `EMR_CHORD` or
+* `EMR_PIE` draws.
+*
+* All three state the same thing: an ellipse inscribed in a box, and two points
+* naming RAYS from its centre. The arc runs from where the first ray crosses
+* the ellipse to where the second does, anticlockwise on the page — GDI's
+* default direction — and the two records differ only in how they close: a pie
+* back through the centre, a chord straight across, an arc not at all.
+*
+* Built in the metafile's own coordinates and mapped point by point, exactly as
+* the ellipse and the polygons are: the mapping is affine, so a Bézier's
+* control points survive it.
+*
+* @param map        The metafile's logical → page mapping.
+* @param l,t,r,b    The box the ellipse is inscribed in.
+* @param sx,sy      The point naming the ray the arc starts at.
+* @param ex,ey      The point naming the ray it ends at.
+* @param type       The record type, which decides how the figure closes.
+* @returns The path segments, in page coordinates.
+*/
+function arcSegments(map, l, t, r, b, sx, sy, ex, ey, type) {
+	const cx = (l + r) / 2;
+	const cy = (t + b) / 2;
+	const rx = (r - l) / 2;
+	const ry = (b - t) / 2;
+	if (!(rx > 0) || !(ry > 0)) return [];
+	const angleOf = (x, y) => Math.atan2((y - cy) / ry, (x - cx) / rx);
+	const start = angleOf(sx, sy);
+	let sweep = angleOf(ex, ey) - start;
+	if (sweep >= 0) sweep -= 2 * Math.PI;
+	const point = (a) => map(cx + rx * Math.cos(a), cy + ry * Math.sin(a));
+	const segs = [];
+	const from = point(start);
+	if (type === 47) {
+		const c = map(cx, cy);
+		segs.push({
+			op: "move",
+			x: c.x,
+			y: c.y
+		}, {
+			op: "line",
+			x: from.x,
+			y: from.y
+		});
+	} else segs.push({
+		op: "move",
+		x: from.x,
+		y: from.y
+	});
+	const steps = Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2)));
+	const delta = sweep / steps;
+	const alpha = 4 / 3 * Math.tan(delta / 4);
+	for (let i = 0; i < steps; i++) {
+		const a0 = start + delta * i;
+		const a1 = a0 + delta;
+		const t0 = map(cx + rx * Math.cos(a0) - alpha * rx * Math.sin(a0), cy + ry * Math.sin(a0) + alpha * ry * Math.cos(a0));
+		const t1 = map(cx + rx * Math.cos(a1) + alpha * rx * Math.sin(a1), cy + ry * Math.sin(a1) - alpha * ry * Math.cos(a1));
+		const to = point(a1);
+		segs.push({
+			op: "cubic",
+			x1: t0.x,
+			y1: t0.y,
+			x2: t1.x,
+			y2: t1.y,
+			x: to.x,
+			y: to.y
+		});
+	}
+	if (type !== 45) segs.push({ op: "close" });
+	return segs;
+}
 function ellipseSegments(map, l, t, r, b) {
 	const cx = (l + r) / 2;
 	const cy = (t + b) / 2;

package/dist/esm/core/metafile/picture.d.ts

@@ -102,12 +102,61 @@ export interface DeviceContext {
     y: number;
     /** The world→page transform, as `[a, b, c, d, e, f]`. */
     transform: readonly [number, number, number, number, number, number];
+    /**
+     * MS-EMF §2.3.2 / MS-WMF §2.3.2 — the region drawing is limited to, in
+     * logical units, when the metafile states a RECTANGULAR one. A primitive
+     * that falls wholly outside it is not drawn: an embedded workbook's preview
+     * clips its sheet to the used range, and unclipped we painted the whole
+     * empty grid around it.
+     */
+    clip?: {
+        readonly left: number;
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+    };
 }
 export declare const DEFAULT_PEN: MetaPen;
 export declare const DEFAULT_BRUSH: MetaBrush;
 /** A device context in its documented initial state (MS-WMF §3.1.5). */
 export declare function newDeviceContext(): DeviceContext;
 export declare function cloneDc(dc: DeviceContext): DeviceContext;
+/**
+ * Whether a primitive bounded by `box` is wholly outside the device context's
+ * clip. Partial overlaps are kept whole — the reader discards what the clip
+ * excludes rather than cutting geometry, which is a missing cut, never wrong
+ * content.
+ *
+ * @param dc  The device context, for its clip.
+ * @param box The primitive's bounds in logical units.
+ * @returns `true` when nothing of it would be drawn.
+ */
+export declare function clippedAway(dc: DeviceContext, box: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}): boolean;
+/** The intersection of a device context's clip with another rectangle. */
+export declare function intersectClip(dc: DeviceContext, rect: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}): NonNullable<DeviceContext['clip']>;
+/**
+ * A primitive's bounds in the units it is stored in, for the clip test.
+ *
+ * @param prim The primitive.
+ * @returns Its bounding rectangle; a text run's is its reference point, since
+ *          the box it fills is not known until it is measured.
+ */
+export declare function primBounds(prim: PicturePrim): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
 /** A COLORREF (`0x00bbggrr`) as the 6-hex this codebase's colours use. */
 export declare function colorRef(v: number): string;
 /** Apply the world transform to a point. */

package/dist/esm/core/metafile/picture.js

@@ -36,6 +36,75 @@ function newDeviceContext() {
 function cloneDc(dc) {
 	return { ...dc };
 }
+/**
+* Whether a primitive bounded by `box` is wholly outside the device context's
+* clip. Partial overlaps are kept whole — the reader discards what the clip
+* excludes rather than cutting geometry, which is a missing cut, never wrong
+* content.
+*
+* @param dc  The device context, for its clip.
+* @param box The primitive's bounds in logical units.
+* @returns `true` when nothing of it would be drawn.
+*/
+function clippedAway(dc, box) {
+	const c = dc.clip;
+	if (!c) return false;
+	return box.right < c.left || box.left > c.right || box.bottom < c.top || box.top > c.bottom;
+}
+/** The intersection of a device context's clip with another rectangle. */
+function intersectClip(dc, rect) {
+	const c = dc.clip;
+	if (!c) return rect;
+	return {
+		left: Math.max(c.left, rect.left),
+		top: Math.max(c.top, rect.top),
+		right: Math.min(c.right, rect.right),
+		bottom: Math.min(c.bottom, rect.bottom)
+	};
+}
+/**
+* A primitive's bounds in the units it is stored in, for the clip test.
+*
+* @param prim The primitive.
+* @returns Its bounding rectangle; a text run's is its reference point, since
+*          the box it fills is not known until it is measured.
+*/
+function primBounds(prim) {
+	if (prim.kind === "text") return {
+		left: prim.x,
+		top: prim.y,
+		right: prim.x,
+		bottom: prim.y
+	};
+	if (prim.kind === "image") return {
+		left: prim.x,
+		top: prim.y,
+		right: prim.x + prim.width,
+		bottom: prim.y + prim.height
+	};
+	let left = Infinity;
+	let top = Infinity;
+	let right = -Infinity;
+	let bottom = -Infinity;
+	for (const path of prim.paths) for (const sg of path.segments) {
+		if (!("x" in sg)) continue;
+		left = Math.min(left, sg.x);
+		right = Math.max(right, sg.x);
+		top = Math.min(top, sg.y);
+		bottom = Math.max(bottom, sg.y);
+	}
+	return Number.isFinite(left) ? {
+		left,
+		top,
+		right,
+		bottom
+	} : {
+		left: 0,
+		top: 0,
+		right: 0,
+		bottom: 0
+	};
+}
 /** A COLORREF (`0x00bbggrr`) as the 6-hex this codebase's colours use. */
 function colorRef(v) {
 	return [
@@ -52,4 +121,4 @@ function applyTransform(t, x, y) {
 	};
 }
 //#endregion
-export { applyTransform, cloneDc, colorRef, newDeviceContext };
+export { applyTransform, clippedAway, cloneDc, colorRef, intersectClip, newDeviceContext, primBounds };

package/dist/esm/core/metafile/wmf.js

@@ -1,5 +1,5 @@
 import { PathBuilder } from "../vector.js";
-import { cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { clippedAway, cloneDc, colorRef, intersectClip, newDeviceContext, primBounds } from "./picture.js";
 import { cropDib, readDib } from "./dib.js";
 import { makeBlitter } from "./blit.js";
 import { fromSymbolFont, symbolGeometryOf, symbolOutline } from "./symbol-fonts.js";
@@ -62,6 +62,7 @@ function readWmf(bytes) {
 	};
 	let origin;
 	const emit = (prim) => {
+		if (clippedAway(dc, primBounds(prim))) return;
 		origin ??= {
 			x: win.x,
 			y: win.y
@@ -145,6 +146,17 @@ function readWmf(bytes) {
 					cy: p(0)
 				};
 				break;
+			case 1046:
+				dc = {
+					...dc,
+					clip: intersectClip(dc, {
+						bottom: p(0),
+						right: p(1),
+						top: p(2),
+						left: p(3)
+					})
+				};
+				break;
 			case 30:
 				stack.push(cloneDc(dc));
 				break;
@@ -388,12 +400,13 @@ function readWmf(bytes) {
 		right: win.x + (win.cx || 1e3),
 		bottom: win.y + (win.cy || 1e3)
 	};
+	const flipped = win.cy < 0 ? prims.map((p) => mirrorPrimY(p, box.top + box.bottom)) : prims;
 	return {
-		left: box.left,
-		top: box.top,
+		left: Math.min(box.left, box.right),
+		top: Math.min(box.top, box.bottom),
 		width: Math.max(1, Math.abs(box.right - box.left)),
 		height: Math.max(1, Math.abs(box.bottom - box.top)),
-		prims,
+		prims: flipped,
 		skipped: [...skipped]
 	};
 }
@@ -451,6 +464,42 @@ function shiftPrim(prim, dx, dy) {
 		}))
 	};
 }
+/**
+* A primitive mirrored about a horizontal axis, for a window whose y grows UP.
+*
+* Only the geometry turns over. A text run's reference point names a corner of
+* the cell IN DEVICE SPACE — GDI never draws the glyphs themselves upside down —
+* so the point moves and the alignment flags stay as they are. An image states
+* the TOP of its destination rectangle, which after the mirror is where its
+* bottom used to be.
+*
+* @param prim      The primitive, in the metafile's own logical units.
+* @param twiceAxis Twice the y the mirror runs along, so `y' = twiceAxis - y`.
+* @returns The primitive with its y coordinates turned over.
+*/
+function mirrorPrimY(prim, twiceAxis) {
+	const at = (y) => twiceAxis - y;
+	if (prim.kind === "text") return {
+		...prim,
+		y: at(prim.y)
+	};
+	if (prim.kind === "image") return {
+		...prim,
+		y: at(prim.y + prim.height)
+	};
+	return {
+		...prim,
+		paths: prim.paths.map((path) => ({
+			...path,
+			segments: path.segments.map((sg) => "x" in sg ? {
+				...sg,
+				y: at(sg.y),
+				..."y1" in sg ? { y1: at(sg.y1) } : {},
+				..."y2" in sg ? { y2: at(sg.y2) } : {}
+			} : sg)
+		}))
+	};
+}
 function penStyle(style) {
 	switch (style & 15) {
 		case 1: return "dash";

package/dist/esm/core/ole/escher-blip.js

@@ -1,3 +1,4 @@
+import { dibToBmp } from "../bmp.js";
 import { unzlibSync } from "fflate";
 //#region src/core/ole/escher-blip.ts
 var BLIP_EMF = 61466;
@@ -54,9 +55,18 @@ var RASTER_MAGICS = [
 */
 function readEscherBlip(type, instance, data) {
 	if (type === BLIP_EMF || type === BLIP_WMF || type === BLIP_PICT) return readMetafileBlip(instance, data);
-	if (type === BLIP_JPEG || type === BLIP_PNG || type === BLIP_DIB || type === BLIP_TIFF || type === BLIP_JPEG_CMYK) return scanRaster(data);
+	if (type === BLIP_DIB) return readDibBlip(instance, data) ?? scanRaster(data);
+	if (type === BLIP_JPEG || type === BLIP_PNG || type === BLIP_TIFF || type === BLIP_JPEG_CMYK) return scanRaster(data);
 	return scanRaster(data);
 }
+function readDibBlip(instance, data) {
+	const uidBytes = TWO_UID_INSTANCES.has(instance) ? 32 : 16;
+	for (const at of [uidBytes + 1, uidBytes]) {
+		if (data.length <= at) continue;
+		const bmp = dibToBmp(data.subarray(at));
+		if (bmp) return bmp;
+	}
+}
 function readMetafileBlip(instance, data) {
 	const uidBytes = TWO_UID_INSTANCES.has(instance) ? 32 : 16;
 	const head = uidBytes + METAFILE_HEADER_BYTES;

package/dist/esm/excel/print-model.js

@@ -1122,8 +1122,8 @@ function shadingFromXf(xf, styles) {
 	if (!pattern || pattern === "none") return void 0;
 	if (pattern === "solid") return fill.fgColorHex ? { colorHex: fill.fgColorHex } : void 0;
 	const density = PATTERN_DENSITY[pattern];
-	if (density === void 0 || !fill.fgColorHex) return void 0;
-	const blended = blendHex(fill.fgColorHex, fill.bgColorHex ?? "FFFFFF", density);
+	if (density === void 0) return void 0;
+	const blended = blendHex(fill.fgColorHex ?? "000000", fill.bgColorHex ?? "FFFFFF", density);
 	return blended ? { colorHex: blended } : void 0;
 }
 function blendHex(fg, bg, fraction) {

package/dist/esm/excel/sheet-drawing.js

@@ -162,7 +162,7 @@ function makeColWidthPt(ws) {
 	return (col) => {
 		for (const c of ws.columns) if (col >= c.min - 1 && col <= c.max - 1) return widthPt(c.widthChars);
 		if (ws.defaultColWidthChars !== void 0) return widthPt(ws.defaultColWidthChars);
-		if (ws.baseColWidthChars !== void 0) return (columnTwips(ws.baseColWidthChars, 105) + 75) / TWIPS_PER_PT;
+		if (ws.baseColWidthChars !== void 0) return (columnTwips(ws.baseColWidthChars, 105) + 150) / TWIPS_PER_PT;
 		return 960 / TWIPS_PER_PT;
 	};
 }

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

@@ -401,8 +401,16 @@ function withDrawingsByBand(drawings, gridBody, lefts) {
 	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]));
+		if (x === void 0) {
+			byBand[0].push(el);
+			continue;
+		}
+		const start = bandOf(x);
+		const right = x + (floatWidthPt(el) ?? 0);
+		for (let band = start; band < lefts.length; band++) {
+			if (band > start && right <= lefts[band]) break;
+			byBand[band].push(shiftFloatLeft(el, lefts[band]));
+		}
 	}
 	const out = [];
 	let seen = 0;
@@ -416,6 +424,12 @@ function withDrawingsByBand(drawings, gridBody, lefts) {
 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;
 }
+/** A float's own width, for the block kinds a sheet anchors. */
+function floatWidthPt(el) {
+	if (el.kind === "chart") return el.chart.width;
+	if (el.kind === "image") return el.image.width;
+	if (el.kind === "shape") return el.shape.width;
+}
 /** The same block with its horizontal anchor measured from `by` points later. */
 function shiftFloatLeft(el, by) {
 	if (by === 0) return el;

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

@@ -653,7 +653,8 @@ var MIME_BY_FORMAT = {
 	png: "image/png",
 	jpeg2000: "image/jp2",
 	gif: "image/gif",
-	tiff: "image/tiff"
+	tiff: "image/tiff",
+	bmp: "image/bmp"
 };
 function dataUri(resource, store) {
 	if (resource === void 0) return void 0;

package/dist/esm/layout/page-doc.d.ts

@@ -326,6 +326,32 @@ export interface TextLineItem extends PageItemBase {
      * the plot's own tick labels. Absent ⇒ horizontal.
      */
     readonly rotationDeg?: number;
+    /**
+     * §20.1.9.10 `a:prstTxWarp` — the line is WordArt: each glyph is placed on
+     * its own, bent through the preset's curve and stretched onto the shape's
+     * box. Absent ⇒ the line is set flat, one text matrix for the whole of it.
+     */
+    readonly warp?: TextLineWarp;
+}
+/**
+ * What placing a warped line needs: the preset, the shape box the warped block
+ * is stretched onto, and the box the UN-warped block occupies — both in the
+ * page's top-left frame, so a glyph's position in the second maps straight into
+ * the first.
+ */
+export interface TextLineWarp {
+    readonly preset: string;
+    readonly adjust?: number;
+    readonly boxX: Pt;
+    readonly boxY: Pt;
+    readonly boxWidth: Pt;
+    readonly boxHeight: Pt;
+    /** The un-warped block's left edge and width (its widest line). */
+    readonly srcX: Pt;
+    readonly srcWidth: Pt;
+    /** The un-warped block's ink top and total ink height. */
+    readonly srcTop: Pt;
+    readonly srcHeight: Pt;
 }
 /** One edge of a table-cell frame; `(x, y)` is the cell box's top-left corner. */
 export interface BorderItem extends PageItemBase {
@@ -422,6 +448,15 @@ export interface PagePaintPlan {
      * per {@link PageItemBase.pictureId}. They paint where the shape pass does.
      */
     readonly pictures: ReadonlyArray<ReadonlyArray<PageItem>>;
+    /**
+     * §19.3.1 — the items of a page that STATES its own paint order, each run in
+     * the order it paints, the runs sorted by the order they were given. A slide
+     * is such a page: its shape tree is a z-order, and a picture standing after a
+     * rectangle in it is drawn over that rectangle. Split by kind instead — every
+     * image, then every shape — the six logos of 54542_cropped_bitmap.pptx were
+     * painted first and the six panels they sit on were painted over them.
+     */
+    readonly ordered: ReadonlyArray<ReadonlyArray<PageItem>>;
 }
 export declare function paintPlan(commands: ReadonlyArray<PageItem>): PagePaintPlan;
 export interface LaidOutDocument {

package/dist/esm/layout/page-doc.js

@@ -7,11 +7,23 @@ function paintPlan(commands) {
 	const lines = [];
 	const pictures = /* @__PURE__ */ new Map();
 	const behind = [];
+	const ordered = /* @__PURE__ */ new Map();
+	const orderOf = /* @__PURE__ */ new Map();
 	for (const c of commands) {
 		if (c.behind === true) {
 			behind.push(c);
 			continue;
 		}
+		if (c.z !== void 0 && c.type !== "line" && c.type !== "fill" && c.type !== "border") {
+			const key = c.pictureId !== void 0 ? `p${c.pictureId}` : `i${orderOf.size}`;
+			const run = ordered.get(key);
+			if (run) run.push(c);
+			else {
+				ordered.set(key, [c]);
+				orderOf.set(key, c.z);
+			}
+			continue;
+		}
 		if (c.pictureId !== void 0) {
 			const group = pictures.get(c.pictureId);
 			if (group) group.push(c);
@@ -44,7 +56,8 @@ function paintPlan(commands) {
 		borders,
 		shapes,
 		lines,
-		pictures: [...pictures.values()]
+		pictures: [...pictures.values()],
+		ordered: [...ordered.entries()].sort((a, b) => (orderOf.get(a[0]) ?? 0) - (orderOf.get(b[0]) ?? 0)).map(([, run]) => run)
 	};
 }
 function assertNeverPageItem(item) {