reamkit 1.23.0 → 1.24.0

package/dist/esm/core/bmp.d.ts

@@ -0,0 +1,33 @@
+/** One decoded bitmap: chunky 8-bit samples, plus alpha when the file carries it. */
+export interface DecodedBmp {
+    readonly width: number;
+    readonly height: number;
+    /** Row-major RGB samples, `width * height * 3` long. */
+    readonly data: Uint8Array;
+    /** One byte per pixel, present only when the file states real transparency. */
+    readonly alpha?: Uint8Array;
+    /** `biXPelsPerMeter`/`biYPelsPerMeter` turned into pixels per inch. */
+    readonly dpiX?: number;
+    readonly dpiY?: number;
+}
+/** Whether these bytes open with the `BM` signature of a bitmap FILE. */
+export declare function isBmp(bytes: Uint8Array): boolean;
+/**
+ * MS-ODRAW §2.2.28 — a `BlipDIB`'s payload is a bitmap without its 14-byte
+ * BITMAPFILEHEADER, which the Escher record makes redundant. Put it back.
+ *
+ * @param dib The bytes from the DIB header onwards.
+ * @returns A complete BMP file, or `undefined` when the header does not read
+ *          as a bitmap at all.
+ */
+export declare function dibToBmp(dib: Uint8Array): Uint8Array | undefined;
+/**
+ * Decode a Windows bitmap into 8-bit RGB samples.
+ *
+ * @param bytes A complete BMP file (`BM` signature included).
+ * @returns The samples, their size and any alpha channel.
+ * @throws Error when the file is malformed, or carries a bitmap this does not
+ *         read — a JPEG or PNG smuggled inside a DIB (`BI_JPEG`/`BI_PNG`),
+ *         which is a whole other file wearing a bitmap header.
+ */
+export declare function decodeBmp(bytes: Uint8Array): DecodedBmp;

package/dist/esm/core/bmp.js

@@ -0,0 +1,276 @@
+//#region src/core/bmp.ts
+var FILE_HEADER_BYTES = 14;
+var CORE_HEADER_BYTES = 12;
+var INFO_HEADER_BYTES = 40;
+var MAX_PIXELS = 4e7;
+var BI_RGB = 0;
+var BI_RLE8 = 1;
+var BI_RLE4 = 2;
+var BI_BITFIELDS = 3;
+var BI_ALPHABITFIELDS = 6;
+/** Whether these bytes open with the `BM` signature of a bitmap FILE. */
+function isBmp(bytes) {
+	return bytes.length >= FILE_HEADER_BYTES && bytes[0] === 66 && bytes[1] === 77;
+}
+/**
+* MS-ODRAW §2.2.28 — a `BlipDIB`'s payload is a bitmap without its 14-byte
+* BITMAPFILEHEADER, which the Escher record makes redundant. Put it back.
+*
+* @param dib The bytes from the DIB header onwards.
+* @returns A complete BMP file, or `undefined` when the header does not read
+*          as a bitmap at all.
+*/
+function dibToBmp(dib) {
+	const head = readDibHeader(dib, 0);
+	if (!head) return void 0;
+	const offBits = FILE_HEADER_BYTES + head.headerBytes + head.maskBytes + head.paletteBytes;
+	const out = new Uint8Array(FILE_HEADER_BYTES + dib.length);
+	const view = new DataView(out.buffer);
+	out[0] = 66;
+	out[1] = 77;
+	view.setUint32(2, out.length, true);
+	view.setUint32(10, offBits, true);
+	out.set(dib, FILE_HEADER_BYTES);
+	return out;
+}
+/**
+* Decode a Windows bitmap into 8-bit RGB samples.
+*
+* @param bytes A complete BMP file (`BM` signature included).
+* @returns The samples, their size and any alpha channel.
+* @throws Error when the file is malformed, or carries a bitmap this does not
+*         read — a JPEG or PNG smuggled inside a DIB (`BI_JPEG`/`BI_PNG`),
+*         which is a whole other file wearing a bitmap header.
+*/
+function decodeBmp(bytes) {
+	if (!isBmp(bytes)) throw new Error("BMP: not a bitmap");
+	const file = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const head = readDibHeader(bytes, FILE_HEADER_BYTES);
+	if (!head) throw new Error("BMP: unreadable header");
+	const { width, height, topDown, bitCount, compression } = head;
+	if (width <= 0 || height <= 0) throw new Error("BMP: empty bitmap");
+	if (width * height > MAX_PIXELS) throw new Error("BMP: image too large");
+	if (compression === 4 || compression === 5) throw new Error("BMP: embedded JPEG/PNG bitmaps are not supported");
+	const stated = file.getUint32(10, true);
+	const computed = FILE_HEADER_BYTES + head.headerBytes + head.maskBytes + head.paletteBytes;
+	const pixelsAt = stated >= computed && stated < bytes.length ? stated : computed;
+	const palette = readPalette(bytes, FILE_HEADER_BYTES + head.headerBytes, head);
+	const count = width * height;
+	const data = new Uint8Array(count * 3);
+	const rowOf = (y) => topDown ? y : height - 1 - y;
+	if (compression === BI_RLE8 || compression === BI_RLE4) {
+		const indices = decodeRle(bytes.subarray(pixelsAt), width, height, compression === BI_RLE4);
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+			const at = (rowOf(y) * width + x) * 3;
+			const p = (indices[y * width + x] ?? 0) * 3;
+			data[at] = palette[p] ?? 0;
+			data[at + 1] = palette[p + 1] ?? 0;
+			data[at + 2] = palette[p + 2] ?? 0;
+		}
+		return {
+			width,
+			height,
+			data,
+			...density(head)
+		};
+	}
+	const stride = ((width * bitCount + 31) / 32 | 0) * 4;
+	const alpha = head.alphaMask !== 0 ? new Uint8Array(count) : void 0;
+	const shifts = {
+		r: maskShift(head.redMask),
+		g: maskShift(head.greenMask),
+		b: maskShift(head.blueMask),
+		a: maskShift(head.alphaMask)
+	};
+	for (let y = 0; y < height; y++) {
+		const row = pixelsAt + y * stride;
+		if (row + stride > bytes.length + stride) break;
+		for (let x = 0; x < width; x++) {
+			const at = (rowOf(y) * width + x) * 3;
+			if (bitCount <= 8) {
+				const p = paletteIndex(bytes, row, x, bitCount) * 3;
+				data[at] = palette[p] ?? 0;
+				data[at + 1] = palette[p + 1] ?? 0;
+				data[at + 2] = palette[p + 2] ?? 0;
+				continue;
+			}
+			if (bitCount === 24) {
+				const o = row + x * 3;
+				data[at] = bytes[o + 2] ?? 0;
+				data[at + 1] = bytes[o + 1] ?? 0;
+				data[at + 2] = bytes[o] ?? 0;
+				continue;
+			}
+			const raw = bitCount === 16 ? (bytes[row + x * 2] ?? 0) | (bytes[row + x * 2 + 1] ?? 0) << 8 : ((bytes[row + x * 4] ?? 0) | (bytes[row + x * 4 + 1] ?? 0) << 8 | (bytes[row + x * 4 + 2] ?? 0) << 16 | (bytes[row + x * 4 + 3] ?? 0) << 24) >>> 0;
+			data[at] = channel(raw, head.redMask, shifts.r);
+			data[at + 1] = channel(raw, head.greenMask, shifts.g);
+			data[at + 2] = channel(raw, head.blueMask, shifts.b);
+			if (alpha) alpha[rowOf(y) * width + x] = channel(raw, head.alphaMask, shifts.a);
+		}
+	}
+	const opaque = alpha?.every((v) => v === 0) ?? true;
+	return {
+		width,
+		height,
+		data,
+		...alpha && !opaque ? { alpha } : {},
+		...density(head)
+	};
+}
+function readDibHeader(bytes, at) {
+	if (bytes.length < at + 4) return void 0;
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const headerBytes = v.getUint32(at, true);
+	const core = headerBytes === CORE_HEADER_BYTES;
+	if (!core && headerBytes < INFO_HEADER_BYTES) return void 0;
+	if (bytes.length < at + headerBytes) return void 0;
+	const width = core ? v.getInt16(at + 4, true) : v.getInt32(at + 4, true);
+	const rawHeight = core ? v.getInt16(at + 6, true) : v.getInt32(at + 8, true);
+	const planes = core ? v.getUint16(at + 6, true) : v.getUint16(at + 12, true);
+	const bitCount = core ? v.getUint16(at + 8, true) : v.getUint16(at + 14, true);
+	const compression = core ? BI_RGB : v.getUint32(at + 16, true);
+	if (planes !== 1) return void 0;
+	if (![
+		1,
+		2,
+		4,
+		8,
+		16,
+		24,
+		32
+	].includes(bitCount)) return void 0;
+	if (compression > 6) return void 0;
+	if (width <= 0 || rawHeight === 0) return void 0;
+	const clrUsed = core ? 0 : v.getUint32(at + 32, true);
+	const inHeader = headerBytes >= 52;
+	const maskBytes = !inHeader && (compression === BI_BITFIELDS || compression === BI_ALPHABITFIELDS) ? compression === BI_ALPHABITFIELDS ? 16 : 12 : 0;
+	const maskAt = inHeader ? at + 40 : at + headerBytes;
+	const stated = compression === BI_BITFIELDS || compression === BI_ALPHABITFIELDS || inHeader;
+	const readMask = (i) => stated && bytes.length >= maskAt + (i + 1) * 4 ? v.getUint32(maskAt + i * 4, true) : 0;
+	const defaults = bitCount === 16 ? [
+		31744,
+		992,
+		31
+	] : [
+		16711680,
+		65280,
+		255
+	];
+	const red = readMask(0) || defaults[0];
+	const green = readMask(1) || defaults[1];
+	const blue = readMask(2) || defaults[2];
+	const alphaMask = headerBytes >= 56 && bytes.length >= maskAt + 16 ? v.getUint32(maskAt + 12, true) : 0;
+	const paletteEntryBytes = core ? 3 : 4;
+	return {
+		headerBytes,
+		maskBytes,
+		paletteBytes: (bitCount <= 8 ? clrUsed || 1 << bitCount : 0) * paletteEntryBytes,
+		paletteEntryBytes,
+		width,
+		height: Math.abs(rawHeight),
+		topDown: rawHeight < 0,
+		bitCount,
+		compression,
+		redMask: red,
+		greenMask: green,
+		blueMask: blue,
+		alphaMask,
+		pxPerMeterX: core ? 0 : v.getInt32(at + 24, true),
+		pxPerMeterY: core ? 0 : v.getInt32(at + 28, true)
+	};
+}
+/** The palette as flat RGB triples, whichever entry width the header uses. */
+function readPalette(bytes, at, head) {
+	const entries = head.paletteBytes / head.paletteEntryBytes;
+	const out = new Uint8Array(entries * 3);
+	for (let i = 0; i < entries; i++) {
+		const o = at + i * head.paletteEntryBytes;
+		out[i * 3] = bytes[o + 2] ?? 0;
+		out[i * 3 + 1] = bytes[o + 1] ?? 0;
+		out[i * 3 + 2] = bytes[o] ?? 0;
+	}
+	return out;
+}
+/** The palette index of one pixel of a 1/2/4/8-bit row. */
+function paletteIndex(bytes, row, x, bitCount) {
+	if (bitCount === 8) return bytes[row + x] ?? 0;
+	const perByte = 8 / bitCount;
+	return (bytes[row + (x / perByte | 0)] ?? 0) >> 8 - bitCount * (x % perByte + 1) & (1 << bitCount) - 1;
+}
+/** How far right a mask's field sits, so its bits can be read off. */
+function maskShift(mask) {
+	if (mask === 0) return 0;
+	let shift = 0;
+	while ((mask >>> shift & 1) === 0) shift++;
+	return shift;
+}
+/** One channel of a packed pixel, stretched to the full byte range. */
+function channel(raw, mask, shift) {
+	if (mask === 0) return 0;
+	const width = (mask >>> shift).toString(2).length;
+	const value = (raw & mask) >>> shift;
+	const max = (1 << width) - 1;
+	return max === 0 ? 0 : Math.round(value * 255 / max);
+}
+/** §biXPelsPerMeter — the resolution the bitmap claims, in pixels per inch. */
+function density(head) {
+	if (head.pxPerMeterX <= 0 || head.pxPerMeterY <= 0) return {};
+	return {
+		dpiX: head.pxPerMeterX * .0254,
+		dpiY: head.pxPerMeterY * .0254
+	};
+}
+/**
+* §BI_RLE8 / §BI_RLE4 — run-length rows of palette indices.
+*
+* Each pair is either a run (a non-zero count and the index to repeat) or an
+* escape (a zero count and a code): 0 ends the row, 1 ends the bitmap, 2 is a
+* delta that skips forward, and anything else is that many literal pixels,
+* padded to a two-byte boundary.
+*
+* @param data   The bytes from the first run onwards.
+* @param width  The bitmap's width in pixels.
+* @param height Its height in rows.
+* @param four   Whether this is the four-bit form, which packs two indices per byte.
+* @returns One palette index per pixel, top row first.
+*/
+function decodeRle(data, width, height, four) {
+	const out = new Uint8Array(width * height);
+	let x = 0;
+	let y = 0;
+	let at = 0;
+	const put = (index) => {
+		if (x < width && y < height) out[y * width + x] = index;
+		x++;
+	};
+	while (at + 1 < data.length && y < height) {
+		const count = data[at];
+		const value = data[at + 1];
+		at += 2;
+		if (count > 0) {
+			for (let i = 0; i < count; i++) put(four ? i % 2 === 0 ? value >> 4 : value & 15 : value);
+			continue;
+		}
+		if (value === 0) {
+			x = 0;
+			y++;
+			continue;
+		}
+		if (value === 1) break;
+		if (value === 2) {
+			x += data[at] ?? 0;
+			y += data[at + 1] ?? 0;
+			at += 2;
+			continue;
+		}
+		const bytesUsed = four ? (value + 1) / 2 | 0 : value;
+		for (let i = 0; i < value; i++) {
+			const byte = data[at + (four ? i / 2 | 0 : i)] ?? 0;
+			put(four ? i % 2 === 0 ? byte >> 4 : byte & 15 : byte);
+		}
+		at += bytesUsed + bytesUsed % 2;
+	}
+	return out;
+}
+//#endregion
+export { decodeBmp, dibToBmp, isBmp };

package/dist/esm/core/document-model/types.d.ts

@@ -787,6 +787,13 @@ export interface CellProperties {
      * is a word-processor table's default.
      */
     readonly verticalAlign?: 'top' | 'center' | 'bottom';
+    /**
+     * §17.4.71 `w:textDirection` / §21.1.3.17 `a:tcPr@vert` — the cell's text is
+     * turned a quarter: `vert` reads top-to-bottom (turned clockwise), `vert270`
+     * bottom-to-top. Its lines then run along the cell's HEIGHT and stack across
+     * its width, which is what makes a narrow header column readable.
+     */
+    readonly textDirection?: 'vert' | 'vert270';
 }
 /** §17.4.81 `w:trPr` — a table row's properties: height, split/header flags. */
 export interface RowProperties {
@@ -1043,6 +1050,16 @@ export interface ShapeFill {
         readonly sx: number;
         readonly sy: number;
     };
+    /**
+     * Where the grid of copies is anchored. DrawingML pins it to the shape's
+     * top-left corner (§20.1.8.58 `a:tile @algn`, which defaults to `tl`); an
+     * MS-ODRAW texture fill (§2.3.7.13 `fillOriginX`/`fillOriginY`, both
+     * defaulting to nothing) centres it on the shape instead. It only shows when
+     * the copies do not divide the box evenly — and it shows most when ONE copy
+     * is larger than the box, where the difference is which part of the picture
+     * is visible at all.
+     */
+    readonly tileFromCentre?: boolean;
     /**
      * §20.1.8.14 `a:blipFill` — the picture painted across the shape's box. A
      * DrawingML picture IS a shape with one of these, which is how a `pic:pic`
@@ -1162,6 +1179,26 @@ export interface ShapeTextBody {
      * WordArt is set at whatever size fills the box it was drawn in.
      */
     readonly fitToBox?: boolean;
+    /**
+     * §20.1.9.10 `a:prstTxWarp` — DrawingML WordArt: the preset curve the text is
+     * bent through, and the `a:avLst` `adj` guide when the file states one. The
+     * warped text does not wrap and is stretched to fill the shape's box, so the
+     * size its runs state stops deciding how large it is drawn. `textNoShape` is
+     * not carried: it is the enumeration's "no warp" member, and a body under it
+     * is an ordinary text box.
+     */
+    readonly warp?: {
+        readonly preset: string;
+        readonly adjust?: number;
+    };
+    /**
+     * §20.1.10.42 `a:normAutofit` — the text SHRINKS to fit the box, and only
+     * shrinks: a size that already fits is left alone. PowerPoint writes the
+     * scale it settled on into `@fontScale` and that is applied at parse; this
+     * is for the text that arrives without one, which is every box of a diagram
+     * laid out from its layout part rather than from a cached drawing.
+     */
+    readonly shrinkToFit?: boolean;
     /**
      * `wps:txbx @id` / `wps:linkedTxbx @id @seq` — the chain of boxes this one
      * belongs to. Text that overruns a box continues in the next of its chain;

package/dist/esm/core/drawingml/chart-geometry.js

@@ -875,9 +875,10 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		});
 		const mid = ang + sweep / 2;
 		const pct = Math.round(v / total * 100);
+		const own = chart.showValues ? fmtDataLabel(chart, v) : `${pct}%`;
 		const custom = series.pointLabels?.find((l) => l.idx === i)?.text;
-		if (custom !== void 0 || pct >= 5) labels.push({
-			text: custom ?? `${pct}%`,
+		if (custom !== void 0 || chart.showValues || pct >= 5) labels.push({
+			text: custom ?? own,
 			x: cx + Math.cos(mid) * labelR,
 			y: cy + Math.sin(mid) * labelR - 9 / 3,
 			sizePt: 9,

package/dist/esm/core/drawingml/diagram/colors.d.ts

@@ -0,0 +1,52 @@
+import { PoNode } from '../../po-helpers.js';
+/** The colours part, as the drawing writer asks it. */
+export declare class DiagramColors {
+    private readonly byLabel;
+    constructor(tree: ReadonlyArray<PoNode>);
+    /**
+     * The `a:solidFill` for a box, or undefined when the part states none.
+     *
+     * @param label The layout node's `styleLbl`.
+     * @param index The box's place in the run of siblings.
+     */
+    fill(label: string | undefined, index: number): string | undefined;
+    /**
+     * Whether the part states this label at all.
+     *
+     * A label it names but gives no fill — `revTx`, the reversed text of a
+     * process arrow — is a box with NO fill, which is not the same as a file
+     * that ships no colours and falls back to one accent for everything.
+     */
+    knows(label: string | undefined): boolean;
+    /**
+     * The `a:ln` for a box's OUTLINE, where the part states one.
+     *
+     * A follower box is often a near-white wash with the node's own accent drawn
+     * round it (`conFgAcc1` is `lt1` at 90% inside an `accent1` line): without the
+     * line it is a white rectangle on a white slide and reads as nothing at all.
+     *
+     * @param label The layout node's `styleLbl`.
+     * @param index The box's place in the run of siblings.
+     */
+    line(label: string | undefined, index: number): string | undefined;
+    /** The `a:solidFill` for a box's TEXT, where the part overrides the style. */
+    textFill(label: string | undefined, index: number): string | undefined;
+    private pick;
+}
+/**
+ * §21.4.2.20 `dgm:pt/dgm:spPr` — the formatting the AUTHOR set on one point,
+ * which beats whatever the colours part gives that point's style label.
+ *
+ * A cycle-matrix whose second quarter was recoloured by hand states it here and
+ * nowhere else: read only from the colours part, all four quarters came out the
+ * one accent the label names, and the orange quarter and the orange outline
+ * round its callout both vanished.
+ *
+ * @param spPr The point's `dgm:spPr`, when it has one.
+ * @returns The fill and the outline it overrides, each as DrawingML, when it
+ *          overrides them.
+ */
+export declare function pointPaint(spPr: PoNode | undefined): {
+    fill?: string;
+    line?: string;
+};

package/dist/esm/core/drawingml/diagram/colors.js

@@ -0,0 +1,125 @@
+import { poAttr, poChildren, poIs, poTag } from "../../po-helpers.js";
+//#region src/core/drawingml/diagram/colors.ts
+/** The colours part, as the drawing writer asks it. */
+var DiagramColors = class {
+	byLabel = /* @__PURE__ */ new Map();
+	constructor(tree) {
+		const def = findDescendant(tree, "dgm:colorsDef");
+		for (const lbl of def ? poChildren(def) : []) {
+			if (!poIs(lbl, "dgm:styleLbl")) continue;
+			const name = poAttr(lbl, "name");
+			if (name === void 0) continue;
+			const kids = poChildren(lbl);
+			this.byLabel.set(name, {
+				...run(kids, "dgm:fillClrLst", "fill"),
+				...run(kids, "dgm:linClrLst", "line"),
+				...run(kids, "dgm:txFillClrLst", "txFill")
+			});
+		}
+	}
+	/**
+	* The `a:solidFill` for a box, or undefined when the part states none.
+	*
+	* @param label The layout node's `styleLbl`.
+	* @param index The box's place in the run of siblings.
+	*/
+	fill(label, index) {
+		return solid(this.pick(label, "fill", index));
+	}
+	/**
+	* Whether the part states this label at all.
+	*
+	* A label it names but gives no fill — `revTx`, the reversed text of a
+	* process arrow — is a box with NO fill, which is not the same as a file
+	* that ships no colours and falls back to one accent for everything.
+	*/
+	knows(label) {
+		return label !== void 0 && this.byLabel.has(label);
+	}
+	/**
+	* The `a:ln` for a box's OUTLINE, where the part states one.
+	*
+	* A follower box is often a near-white wash with the node's own accent drawn
+	* round it (`conFgAcc1` is `lt1` at 90% inside an `accent1` line): without the
+	* line it is a white rectangle on a white slide and reads as nothing at all.
+	*
+	* @param label The layout node's `styleLbl`.
+	* @param index The box's place in the run of siblings.
+	*/
+	line(label, index) {
+		const fill = solid(this.pick(label, "line", index));
+		return fill === void 0 ? void 0 : `<a:ln>${fill}</a:ln>`;
+	}
+	/** The `a:solidFill` for a box's TEXT, where the part overrides the style. */
+	textFill(label, index) {
+		return solid(this.pick(label, "txFill", index));
+	}
+	pick(label, which, index) {
+		const colors = (label === void 0 ? void 0 : this.byLabel.get(label)?.[which])?.colors ?? [];
+		if (colors.length === 0) return void 0;
+		return colors[(index % colors.length + colors.length) % colors.length];
+	}
+};
+function run(kids, tag, as) {
+	const list = kids.find((c) => poIs(c, tag));
+	const colors = list ? poChildren(list).filter((c) => poTag(c)?.endsWith("Clr") === true) : [];
+	if (colors.length === 0) return {};
+	return { [as]: {
+		meth: poAttr(list, "meth") ?? "repeat",
+		colors
+	} };
+}
+/**
+* §21.4.2.20 `dgm:pt/dgm:spPr` — the formatting the AUTHOR set on one point,
+* which beats whatever the colours part gives that point's style label.
+*
+* A cycle-matrix whose second quarter was recoloured by hand states it here and
+* nowhere else: read only from the colours part, all four quarters came out the
+* one accent the label names, and the orange quarter and the orange outline
+* round its callout both vanished.
+*
+* @param spPr The point's `dgm:spPr`, when it has one.
+* @returns The fill and the outline it overrides, each as DrawingML, when it
+*          overrides them.
+*/
+function pointPaint(spPr) {
+	const kids = poChildren(spPr);
+	const fillNode = kids.find((c) => poIs(c, "a:solidFill") || poIs(c, "a:noFill") || poIs(c, "a:gradFill"));
+	const colorIn = (node) => poChildren(node).find((c) => poTag(c)?.endsWith("Clr") === true);
+	const fill = poIs(fillNode, "a:noFill") ? "<a:noFill/>" : poIs(fillNode, "a:solidFill") ? solid(colorIn(fillNode)) : void 0;
+	const ln = kids.find((c) => poIs(c, "a:ln"));
+	const lnColor = solid(colorIn(ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0));
+	const w = poAttr(ln, "w");
+	const line = ln === void 0 ? void 0 : `<a:ln${w !== void 0 ? ` w="${esc(w)}"` : ""}>${lnColor ?? ""}</a:ln>`;
+	return {
+		...fill !== void 0 ? { fill } : {},
+		...line !== void 0 ? { line } : {}
+	};
+}
+function solid(color) {
+	const xml = color === void 0 ? "" : colorXml(color);
+	return xml === "" ? void 0 : `<a:solidFill>${xml}</a:solidFill>`;
+}
+function colorXml(color) {
+	const tag = poTag(color);
+	if (tag === void 0) return "";
+	const val = poAttr(color, "val");
+	const mods = poChildren(color).map((m) => {
+		const t = poTag(m);
+		const v = poAttr(m, "val");
+		return t === void 0 || v === void 0 ? "" : `<${t} val="${esc(v)}"/>`;
+	}).join("");
+	return `${val === void 0 ? `<${tag}>` : `<${tag} val="${esc(val)}">`}${mods}</${tag}>`;
+}
+function esc(s) {
+	return s.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/"/gu, "&quot;");
+}
+function findDescendant(tree, tag) {
+	for (const node of tree) {
+		if (poIs(node, tag)) return node;
+		const found = findDescendant(poChildren(node), tag);
+		if (found) return found;
+	}
+}
+//#endregion
+export { DiagramColors, pointPaint };

package/dist/esm/core/drawingml/diagram/data-model.d.ts

@@ -0,0 +1,47 @@
+import { PoNode } from '../../po-helpers.js';
+/** §21.4.2.27 `dgm:pt@type` — what a point is in the model. */
+export type PointType = 'doc' | 'node' | 'asst' | 'parTrans' | 'sibTrans' | 'pres';
+/** One point of the data model. */
+export interface DiagramPoint {
+    readonly id: string;
+    readonly type: PointType;
+    /** `dgm:t` — the point's text, as the `a:txBody` every other reader takes. */
+    readonly text?: PoNode;
+    /** `dgm:spPr` — the formatting the user overrode on this node. */
+    readonly spPr?: PoNode;
+    /** `dgm:prSet` — presentation properties (placeholder text, custom sizes). */
+    readonly prSet?: PoNode;
+}
+/**
+ * The data part as the layout engine asks about it: the point tree recovered
+ * from the connection list, plus the transition points that go with each edge.
+ */
+export declare class DiagramData {
+    private readonly byId;
+    private readonly kids;
+    /** The document point every layout starts from. */
+    readonly root: DiagramPoint | undefined;
+    /** §21.4.2.4 `dgm:bg` — the fill painted behind the whole diagram. */
+    readonly background: PoNode | undefined;
+    constructor(tree: ReadonlyArray<PoNode>);
+    /** The point with this id, if the model holds one. */
+    point(id: string): DiagramPoint | undefined;
+    /**
+     * The children of a point, in the order the connections give them.
+     *
+     * @param id       The parent's model id.
+     * @param ptType   Which kind of child to return — `node` skips the
+     *                 transitions, `sibTrans` returns them instead.
+     */
+    children(id: string, ptType?: 'node' | 'sibTrans' | 'parTrans'): Array<DiagramPoint>;
+    /**
+     * How many generations of `node` points the model holds below its root.
+     *
+     * §21.4.3.3 — a layout branches on this (`func="maxDepth" op="gte" val="2"`):
+     * the same part lays a chevron out as one box when the nodes have no
+     * children and as a labelled box over a body when they do.
+     */
+    get depth(): number;
+    /** The plain text of a point's `dgm:t`, paragraphs joined by newlines. */
+    static textOf(pt: DiagramPoint | undefined): string;
+}