reamkit 1.23.0 → 1.24.0

package/dist/esm/core/drawingml/diagram/layout-engine.js

@@ -0,0 +1,948 @@
+import { poAttr, poChildren, poIs, poTag } from "../../po-helpers.js";
+//#region src/core/drawingml/diagram/layout-engine.ts
+/**
+* Lay a diagram out from its data and layout parts.
+*
+* @param layout The parsed `layout1.xml` tree.
+* @param data   The parsed data part.
+* @param cx     The frame's width in EMU, as the drawing states it.
+* @param cy     The frame's height in EMU.
+* @returns The boxes to draw, or an empty list when the layout uses an
+*          algorithm this slice does not run — the caller then reports the
+*          diagram as a loss exactly as before.
+*/
+function layoutDiagram(layout, data, cx, cy) {
+	const root = findChild(layout, "dgm:layoutDef");
+	const top = root ? findChild(poChildren(root), "dgm:layoutNode") : void 0;
+	if (!top || !data.root) return [];
+	const parsed = parseNode(top, {
+		maxDepth: data.depth,
+		data,
+		root: data.root
+	});
+	if (parsed.alg !== "snake" && parsed.alg !== "lin" && parsed.alg !== "composite" && parsed.alg !== "cycle" && parsed.alg !== "hier") return [];
+	return layoutIn(parsed, data.root, {
+		x: 0,
+		y: 0,
+		cx,
+		cy
+	}, data, 0);
+}
+/**
+* One layout node run inside the box it was given, by whichever algorithm it
+* names.
+*
+* @param node  The layout node.
+* @param point The data point it is laying out.
+* @param box   The rectangle it has to fill.
+* @param data  The data part.
+* @param index The point's place among its siblings, for the colour run.
+*/
+function layoutIn(node, point, box, data, index) {
+	if (node.alg === "composite") return compositeLayout(node, point, box, data, index);
+	if (node.alg === "hier") return hierarchyLayout(node, point, box, data);
+	if (node.alg === "cycle") return cycleLayout(node, point, box, data);
+	if (node.alg === "lin" || node.alg === "snake") return listLayout(node, point, box, data);
+	if (node.alg === "sp") {
+		const own = spokenFor(node, point, data).spPr;
+		return node.shapeType === void 0 ? [] : [{
+			point: {
+				id: `${point.id}/${node.name}`,
+				type: "node",
+				...own !== void 0 ? { spPr: own } : {}
+			},
+			shapeType: node.shapeType,
+			...styleOf(node),
+			index,
+			...box
+		}];
+	}
+	if (node.alg !== "tx") return [];
+	return [{
+		point: spokenFor(node, point, data),
+		shapeType: node.shapeType ?? "rect",
+		...styleOf(node),
+		index,
+		...box
+	}];
+}
+/**
+* §21.4.3.2 `hierRoot`/`hierChild` — the hierarchy family, which is the org
+* chart. `hierRoot` puts a node's box above its subtree and `hierChild` ranges
+* that subtree beneath it, each child being a `hierRoot` again; the two are one
+* tree walk written as two algorithms, and the engine runs them as one.
+*
+* The layout program that expresses this is deeply nested — a `choose` per
+* branch style at every level, with the same three boxes renamed each time —
+* but it says only one thing, and it says it in the constraints at the top: a
+* box is `w` wide and `0.5w` tall, levels are `0.21w` apart and so are
+* siblings. So the geometry is read from there and the shape of the tree from
+* the DATA, which is where it actually lives.
+*
+* @param node  The `hierChild`/`hierRoot` node at the top of the hierarchy.
+* @param point The data point it is rooted at.
+* @param box   The frame the tree has to fit.
+* @param data  The data part.
+*/
+function hierarchyLayout(node, point, box, data) {
+	const f = hierFactors(node.constrs);
+	const face = firstTextBox(node);
+	const build = (p) => {
+		const kids = data.children(p.id, "node").map(build);
+		const spread = kids.length === 0 ? 0 : kids.reduce((a, k) => a + k.units, 0) + f.sibSp * (kids.length - 1);
+		return {
+			point: p,
+			kids,
+			units: Math.max(1, spread),
+			spread
+		};
+	};
+	const roots = data.children(point.id, "node").map(build);
+	if (roots.length === 0) return [];
+	const wide = roots.reduce((a, r) => a + r.units, 0) + f.sibSp * (roots.length - 1);
+	const rows = (t) => 1 + t.kids.reduce((a, k) => Math.max(a, rows(k)), 0);
+	const deep = roots.reduce((a, r) => Math.max(a, rows(r)), 0);
+	const tall = deep * f.aspect + (deep - 1) * f.sp;
+	if (wide <= 0 || tall <= 0) return [];
+	const w = Math.min(box.cx / wide, box.cy / tall);
+	const out = [];
+	const top = box.y + (box.cy - tall * w) / 2;
+	const place = (t, left, depth) => {
+		out.push({
+			point: t.point,
+			shapeType: face?.shapeType ?? "rect",
+			styleLbl: `node${Math.min(depth, 4)}`,
+			...face === void 0 ? {} : textPlacing(face),
+			index: depth,
+			x: left + (t.units * w - w) / 2,
+			y: top + depth * (f.aspect + f.sp) * w,
+			cx: w,
+			cy: f.aspect * w
+		});
+		let at = left + (t.units - t.spread) * w / 2;
+		for (const kid of t.kids) {
+			place(kid, at, depth + 1);
+			at += (kid.units + f.sibSp) * w;
+		}
+	};
+	let at = box.x + (box.cx - wide * w) / 2;
+	for (const root of roots) {
+		place(root, at, 0);
+		at += (root.units + f.sibSp) * w;
+	}
+	return out;
+}
+function hierFactors(constrs) {
+	let aspect = .5;
+	let sp = .21;
+	let sibSp = .21;
+	for (const k of constrs) {
+		if (k.refType !== "w") continue;
+		if (k.type === "h" && k.refForName !== void 0) aspect = k.fact;
+		if (k.type === "sp") sp = k.fact;
+		if (k.type === "sibSp") sibSp = k.fact;
+	}
+	return {
+		aspect,
+		sp,
+		sibSp
+	};
+}
+function firstTextBox(node) {
+	const walk = (items) => {
+		for (const item of items) {
+			if (item.kind === "node" && item.alg === "tx") return item;
+			const found = walk(item.children);
+			if (found) return found;
+		}
+	};
+	return walk(node.children);
+}
+function textPlacing(node) {
+	const anchor = node.algParams.get("txAnchorVert");
+	const align = node.algParams.get("parTxLTRAlign");
+	return {
+		...anchor !== void 0 && anchor !== "" ? { anchor } : {},
+		...align !== void 0 && align !== "" ? { align } : {}
+	};
+}
+function styleOf(node) {
+	const sz = fontSize(node.constrs, void 0, "primFontSz");
+	const anchor = node.algParams.get("txAnchorVert");
+	const align = node.algParams.get("parTxLTRAlign");
+	return {
+		...node.styleLbl !== void 0 ? { styleLbl: node.styleLbl } : {},
+		...opt("fontSizePt", sz),
+		...bulleted(node) ? { bulleted: true } : {},
+		...node.hideGeom === true ? { hideGeom: true } : {},
+		...anchor !== void 0 && anchor !== "" ? { anchor } : {},
+		...align !== void 0 && align !== "" ? { align } : {},
+		...node.shapeRotation !== void 0 ? { rotation60k: node.shapeRotation * 6e4 } : {}
+	};
+}
+/**
+* §21.4.3.7 `dgm:presOf` — which points a box speaks for. `desOrSelf` is the
+* point and everything under it; `des` is everything under it and NOT the point,
+* which is how a list's second box holds the children's words and not a second
+* copy of the label. Anything else is the point itself.
+*/
+function spokenFor(box, point, data) {
+	if (box.presOfPath) return walkPath(box.presOfPath, point, data);
+	if (box.presOfAxis === "desOrSelf") return withDescendants(point, data);
+	if (box.presOfAxis === "des") return gatheredText(point, data.children(point.id, "node"));
+	return point;
+}
+/**
+* §21.4.3.7 — the `st`/`cnt` slice of a `presOf` path, read from the point the
+* box is being laid out for.
+*
+* The cycle-matrix layout is the reason this exists: each of its four quadrants
+* names ONE child (`axis="ch" st="3" cnt="1"`) and each of the four callouts
+* beside them names that child's own children (`axis="ch des" st="3 1"
+* cnt="1 0"`). Read as a plain axis, all eight boxes spoke for the root and the
+* whole diagram came out blank.
+*
+* @param path  The parsed axis / start / count triple.
+* @param point The point the box is laid out for.
+* @param data  The data part, for walking children.
+* @returns One point carrying the text of everything the path reached.
+*/
+function walkPath(path, point, data) {
+	let at = [point];
+	path.axis.forEach((step, i) => {
+		const next = step === "ch" ? at.flatMap((p) => data.children(p.id, "node")) : step === "des" ? at.flatMap((p) => descendants(p, data)) : step === "self" ? at : [];
+		const from = Math.max(0, (path.st[i] ?? 1) - 1);
+		const want = path.cnt[i] ?? 0;
+		at = next.slice(from, want === 0 ? next.length : from + want);
+	});
+	if (at.length === 1) return at[0];
+	const paragraphs = at.flatMap((p) => p.text ? poChildren(p.text) : []);
+	const id = `${point.id}/${path.axis.join(".")}`;
+	if (paragraphs.length === 0) return {
+		id,
+		type: "node"
+	};
+	return {
+		id,
+		type: "node",
+		text: { "dgm:t": paragraphs }
+	};
+}
+/** Every point under `point`, depth first — the `des` axis. */
+function descendants(point, data) {
+	const out = [];
+	const walk = (id) => {
+		for (const kid of data.children(id, "node")) {
+			out.push(kid);
+			walk(kid.id);
+		}
+	};
+	walk(point.id);
+	return out;
+}
+/**
+* §21.4.3.7 — a `presOf`'s axis PATH, when it names more than one step or
+* slices the one it names. A single unsliced axis stays with the plain
+* `presOfAxis` reading, which the rest of the engine already answers.
+*
+* @param presOf The `dgm:presOf` element, when the box has one.
+* @returns The path, or `undefined` when there is nothing to walk.
+*/
+function axisPath(presOf) {
+	if (!presOf) return void 0;
+	const axis = (poAttr(presOf, "axis") ?? "").split(/\s+/u).filter((a) => a !== "");
+	const nums = (name) => (poAttr(presOf, name) ?? "").split(/\s+/u).filter((v) => v !== "").map((v) => Number(v));
+	const st = nums("st");
+	const cnt = nums("cnt");
+	if (axis.length === 0) return void 0;
+	if (axis.length === 1 && st.length === 0 && cnt.length === 0) return void 0;
+	if (!axis.every((a) => a === "ch" || a === "des" || a === "self")) return void 0;
+	return {
+		axis,
+		st,
+		cnt
+	};
+}
+function withDescendants(point, data) {
+	const paragraphs = point.text ? [...poChildren(point.text)] : [];
+	const walk = (id) => {
+		for (const kid of data.children(id, "node")) {
+			if (kid.text) paragraphs.push(...poChildren(kid.text));
+			walk(kid.id);
+		}
+	};
+	walk(point.id);
+	if (paragraphs.length === 0) return point;
+	return {
+		...point,
+		text: { "dgm:t": paragraphs }
+	};
+}
+/**
+* §21.4.3.2 `composite` — the children are not a list, they are placed: each
+* states where its edges are against the parent's box or against a sibling's,
+* and then runs its own algorithm inside what it was given. A process arrow
+* across the frame with the steps standing along it is one node laid over
+* another, which no list algorithm can express.
+*/
+/**
+* §21.4.3.4 `<dgm:param type="ar"/>` — the width-to-height ratio the algorithm
+* wants its cell in. The cell shrinks to it on whichever axis is over, and
+* stays centred on what it had.
+*
+* The cycle-matrix layout is the reason this matters: it asks for 1.3, measures
+* its disc against the WIDTH it gets, and on a wide slide placeholder the disc
+* came out half again too big and its four quarters overlapped in a pinwheel.
+*
+* @param node The layout node, for its algorithm parameters.
+* @param box  The cell it was given.
+* @returns The cell at the stated ratio, or unchanged when it states none.
+*/
+function aspectFitted(node, box) {
+	const ar = Number(node.algParams.get("ar") ?? "");
+	if (!Number.isFinite(ar) || ar <= 0 || box.cx <= 0 || box.cy <= 0) return box;
+	const cx = Math.min(box.cx, box.cy * ar);
+	const cy = Math.min(box.cy, box.cx / ar);
+	return {
+		x: box.x + (box.cx - cx) / 2,
+		y: box.y + (box.cy - cy) / 2,
+		cx,
+		cy
+	};
+}
+function compositeLayout(node, point, box, data, index, outer = []) {
+	const kids = namedBoxes(node);
+	box = aspectFitted(node, box);
+	const run = (fontEmu) => {
+		const placed = /* @__PURE__ */ new Map();
+		return kids.map((child) => {
+			const rect = rectIn(node.constrs, child.name, box, placed, fontEmu, outer);
+			placed.set(child.name, rect);
+			return rect;
+		});
+	};
+	let rects = run(0);
+	if (kids.every((c) => fontHeight(outer, c.name) !== void 0)) {
+		const units = run(1).reduce((a, r) => Math.max(a, r.y - box.y + r.cy), 0);
+		if (units > 0) rects = run(box.cy / units);
+	}
+	const out = [];
+	kids.forEach((child, i) => {
+		const rect = rects[i];
+		if (rect) out.push(...layoutIn(child, point, rect, data, index));
+	});
+	return out;
+}
+function fontHeight(constrs, name) {
+	for (const k of constrs) if (k.type === "h" && k.forName === name && k.refType === "primFontSz" && k.op === void 0) return k.fact;
+}
+function places(constrs) {
+	return constrs.some((k) => k.type === "ctrX" || k.type === "ctrY" || k.type === "r" || k.type === "b" || (k.type === "l" || k.type === "t") && k.refType !== void 0 && k.refForName === void 0);
+}
+function rectIn(constrs, name, box, placed, fontEmu = 0, outer = []) {
+	let cx = box.cx;
+	let cy = box.cy;
+	let x;
+	let y;
+	const ref = (k) => {
+		const from = k.refForName === void 0 ? box : k.refForName === name ? {
+			cx,
+			cy
+		} : placed.get(k.refForName) ?? box;
+		return (k.refType === "w" ? from.cx : k.refType === "h" ? from.cy : k.refType === "primFontSz" ? fontEmu : 0) * k.fact;
+	};
+	const mine = [...outer, ...constrs].filter((k) => k.forName === name);
+	for (const k of mine) {
+		const v = ref(k);
+		switch (k.type) {
+			case "w":
+				cx = k.op === "lte" ? Math.min(cx, v) : v;
+				break;
+			case "h":
+				cy = k.op === "lte" ? Math.min(cy, v) : v;
+				break;
+			case "l":
+				x = box.x + v;
+				break;
+			case "r":
+				x = box.x + v - cx;
+				break;
+			case "t":
+				y = box.y + v;
+				break;
+			case "b":
+				y = box.y + v - cy;
+				break;
+			case "ctrX":
+				x = box.x + v - cx / 2;
+				break;
+			case "ctrY":
+				y = box.y + v - cy / 2;
+				break;
+			default: break;
+		}
+	}
+	return {
+		x: x ?? box.x,
+		y: y ?? box.y,
+		cx,
+		cy
+	};
+}
+/**
+* §21.4.3.2 `cycle` — the point's children around a circle, starting at
+* `stAng` and spanning `spanAng` (both in degrees, clockwise from twelve
+* o'clock). `ctrShpMap="fNode"` makes the FIRST child the hub in the middle
+* and its own children the ring around it, which is what a radial cycle is.
+*/
+function cycleLayout(node, point, box, data) {
+	const boxes = namedBoxes(node);
+	const hubNode = node.algParams.get("ctrShpMap") === "fNode" ? boxes[0] : void 0;
+	const ringNode = boxes[boxes.length - 1];
+	const kids = data.children(point.id, "node");
+	const hub = hubNode ? kids[0] : void 0;
+	const ring = hub ? data.children(hub.id, "node") : kids;
+	if (ring.length === 0 || !ringNode) return [];
+	const n = ring.length;
+	const stAng = Number(node.algParams.get("stAng") ?? "0");
+	const spanAng = Number(node.algParams.get("spanAng") ?? "360");
+	const step = spanAng / (Math.abs(spanAng) >= 359.5 ? n : Math.max(1, n - 1));
+	const stated = sizeFact(node.constrs, ringNode.name, "w");
+	const gap = siblingSpace(node.constrs, ringNode.name);
+	const chord = Math.sin(Math.PI / Math.max(2, n));
+	const least = Math.min(box.cx, box.cy);
+	const size = stated !== void 0 && stated < .99 ? {
+		cx: box.cx * stated,
+		cy: box.cy * (sizeFact(node.constrs, ringNode.name, "h") ?? stated)
+	} : {
+		cx: least * chord / (1 + gap + chord),
+		cy: least * chord / (1 + gap + chord)
+	};
+	const radius = Math.min((box.cx - size.cx) / 2, (box.cy - size.cy) / 2);
+	const midX = box.x + box.cx / 2;
+	const midY = box.y + box.cy / 2;
+	const out = [];
+	if (hub && hubNode) out.push(...splitCell(node, hubNode.name, hub, data, {
+		x: midX - size.cx / 2,
+		y: midY - size.cy / 2,
+		cx: size.cx,
+		cy: size.cy
+	}, hubNode.shapeType ?? "rect", 0));
+	ring.forEach((pt, i) => {
+		const a = (stAng + i * step) * Math.PI / 180;
+		const cellX = midX + radius * Math.sin(a) - size.cx / 2;
+		const cellY = midY - radius * Math.cos(a) - size.cy / 2;
+		out.push(...splitCell(node, ringNode.name, pt, data, {
+			x: cellX,
+			y: cellY,
+			cx: size.cx,
+			cy: size.cy
+		}, ringNode.shapeType ?? "rect", i));
+	});
+	return out;
+}
+function siblingSpace(constrs, childName) {
+	for (const k of constrs) if (k.type === "sibSp" && (k.refForName === childName || k.refForName === void 0)) return k.fact;
+	return .5;
+}
+/**
+* §21.4.3.2 `lin` / `snake` — the point's children in a row or a column, with
+* the gap the constraints state between them. `snake` wraps; `lin` does not.
+*/
+function listLayout(parsed, parent, box, data) {
+	const nodes = data.children(parent.id, "node");
+	if (nodes.length === 0) return [];
+	const childName = firstNodeName(parsed.children) ?? "node";
+	const c = resolve(parsed.constrs, childName);
+	const shapeType = childShapeType(parsed.children) ?? "rect";
+	const vertical = isVertical(parsed);
+	const body = namedBoxes(parsed);
+	const trans = transitionBox(parsed);
+	const n = nodes.length;
+	const cols = vertical ? 1 : parsed.alg === "snake" ? bestColumns(n, box.cx, box.cy, c.aspect, c.gap) : n;
+	const rows = Math.ceil(n / cols);
+	const cellW = box.cx / (cols + Math.max(0, cols - 1) * c.gap);
+	const gapW = cellW * c.gap;
+	const cellH = box.cy / (rows + Math.max(0, rows - 1) * c.gap);
+	const gapH = cellH * c.gap;
+	const out = [];
+	nodes.forEach((point, i) => {
+		const col = vertical ? Math.floor(i / rows) : i % cols;
+		const row = vertical ? i % rows : Math.floor(i / cols);
+		const inRow = vertical ? rows : Math.min(cols, n - row * cols);
+		const rowWidth = inRow * cellW + Math.max(0, inRow - 1) * gapW;
+		const left = vertical ? 0 : (box.cx - rowWidth) / 2;
+		const cell = {
+			x: box.x + left + col * (cellW + gapW),
+			y: box.y + row * (cellH + gapH),
+			cx: cellW,
+			cy: cellH
+		};
+		out.push(...body.length > 1 ? stackCell(parsed, body, point, data, cell, shapeType, i, vertical) : splitCell(parsed, childName, point, data, cell, shapeType, i));
+		const last = vertical ? row === rows - 1 : col === inRow - 1;
+		if (trans && !last) out.push(connector(trans, point, {
+			x: vertical ? cell.x : cell.x + cellW,
+			y: vertical ? cell.y + cellH : cell.y,
+			cx: vertical ? cellW : gapW,
+			cy: vertical ? gapH : cellH
+		}, vertical));
+	});
+	return out;
+}
+/**
+* §21.4.3.2 — the box a list draws in the gap between two cells.
+*
+* `dgm:shape type="conn"` is not a preset geometry, it is "whatever joins these
+* two", and for a list laid out across that is an arrow pointing the way the
+* list runs. Its own constraint sizes it against the gap it was given — the
+* accent process asks for a height of 62% of its width — and it is centred in
+* what is left.
+*/
+function connector(node, point, gap, vertical) {
+	let { cx, cy } = gap;
+	for (const k of node.constrs) {
+		if (k.forName !== void 0 || k.refType === void 0) continue;
+		if (k.type === "h" && k.refType === "w") cy = Math.min(gap.cy, gap.cx * k.fact);
+		if (k.type === "w" && k.refType === "h") cx = Math.min(gap.cx, gap.cy * k.fact);
+	}
+	return {
+		point: {
+			id: `${point.id}/${node.name}`,
+			type: "node"
+		},
+		shapeType: node.shapeType === "conn" || node.shapeType === void 0 ? vertical ? "downArrow" : "rightArrow" : node.shapeType,
+		...styleOf(node),
+		...node.styleLbl === void 0 ? { styleLbl: "sibTrans2D1" } : {},
+		index: 0,
+		x: gap.x + (gap.cx - cx) / 2,
+		y: gap.y + (gap.cy - cy) / 2,
+		cx,
+		cy
+	};
+}
+function transitionBox(node) {
+	for (const item of node.children) {
+		if (item.kind !== "forEach") continue;
+		for (const inner of item.children) {
+			if (inner.kind !== "forEach" || inner.ptType !== "sibTrans") continue;
+			for (const box of inner.children) if (box.kind === "node" && box.shapeType !== void 0 && box.hideGeom !== true) return box;
+		}
+	}
+}
+/**
+* §21.4.3 — a `forEach` body of SEVERAL boxes is a stack, not a box.
+*
+* The vertical list family gives each point three: the row holding its label,
+* a negative space, and the box its descendants' words go in. Laying out only
+* the first of them drew the labels and dropped every descendant.
+*
+* What each box states for its height divides the cell between them. A space
+* stated as negative is an overlap — one box pulled up over the one before it —
+* which this engine does not run, so it takes no room and the rest share the
+* cell; LibreOffice draws these layouts without the overlap too.
+*/
+function stackCell(parsed, body, point, data, cell, shapeType, index, vertical) {
+	const stated = body.map((b) => stackFact(parsed, b) ?? 0);
+	const total = stated.reduce((a, v) => a + Math.max(0, v), 0);
+	const shares = stated.map((v) => total > 0 ? Math.max(0, v) / total : 1 / body.length);
+	const out = [];
+	let at = vertical ? cell.y : cell.x;
+	body.forEach((b, k) => {
+		const span = (vertical ? cell.cy : cell.cx) * (shares[k] ?? 0);
+		if (span > 0 && !(b.alg === "sp" && b.shapeType === void 0)) {
+			const slice = {
+				x: vertical ? cell.x : at,
+				y: vertical ? at : cell.y,
+				cx: vertical ? cell.cx : span,
+				cy: vertical ? span : cell.cy
+			};
+			out.push(...splitCell(parsed, b.name, point, data, slice, b.shapeType ?? shapeType, index));
+		}
+		at += span;
+	});
+	return out;
+}
+/**
+* The boxes a wrapper INSETS, each at the width it states and where it falls.
+*
+* Widths that add up to the whole are a division and belong to the split; ones
+* that fall short are placements — a margin, then a label of seven tenths, then
+* nothing. Undefined when the boxes do not all state a width, or when they fill
+* the row between them.
+*/
+function insetBoxes(parent, child, width) {
+	const boxes = namedBoxes(child);
+	if (boxes.length < 2) return void 0;
+	const facts = boxes.map((b) => sizeFact(child.constrs, b.name, "w") ?? sizeFact(parent.constrs, b.name, "w"));
+	if (facts.some((v) => v === void 0)) return void 0;
+	if (facts.reduce((a, v) => a + (v ?? 0), 0) > .999) return void 0;
+	const out = [];
+	let at = 0;
+	boxes.forEach((box, i) => {
+		const cx = width * (facts[i] ?? 0);
+		out.push({
+			box,
+			x: at,
+			cx
+		});
+		at += cx;
+	});
+	return out;
+}
+function stackFact(parsed, box) {
+	const own = heightFact(parsed, box.name) ?? sizeFact(parsed.constrs, box.name, "h");
+	if (own !== void 0) return own;
+	for (const inner of namedBoxes(box)) {
+		const f = heightFact(parsed, inner.name) ?? sizeFact(parsed.constrs, inner.name, "h");
+		if (f !== void 0) return f;
+	}
+}
+/**
+* One data node's cell, split the way the child layoutNode divides it.
+*
+* A leaf child (`tx` on the node itself) takes the cell whole. A child that
+* nests further hands its own children a share of the cell, and the two
+* families that do differ in which way they cut it:
+*
+* - the `linNode` of the vertical block lists states `w` fractions for its
+*   children (0.36 for the label, 0.64 for the descendants' text) — a row;
+* - the `composite` of the picture and colour lists gives both children the
+*   full width and states their `h` against a font size (0.8 against 1.22) —
+*   a column.
+*
+* Laid out as one box either way, such a cell holds one text where it should
+* hold the node's label and its children's text in boxes of their own.
+*/
+function splitCell(parent, childName, point, data, cell, shapeType, index) {
+	const child = findNamed(parent.children, childName);
+	const inner = (child ? namedBoxes(child) : []).filter((b) => !(b.alg === "sp" && b.hideGeom === true));
+	const size = (box, type) => box === void 0 ? void 0 : fontSize(box.constrs, void 0, type) ?? fontSize(child?.constrs ?? [], box.name, type) ?? fontSize(parent.constrs, box.name, type);
+	const face = inner.length === 1 ? inner[0] : child;
+	const whole = () => [{
+		point: face === void 0 ? point : spokenFor(face, point, data),
+		shapeType: face?.shapeType ?? shapeType,
+		...face?.styleLbl !== void 0 ? { styleLbl: face.styleLbl } : {},
+		...opt("fontSizePt", size(face, "primFontSz")),
+		...face !== void 0 && bulleted(face) ? { bulleted: true } : {},
+		...face?.hideGeom === true ? { hideGeom: true } : {},
+		...face === void 0 ? {} : textPlacing(face),
+		index,
+		...cell
+	}];
+	if (child?.alg === "composite" && inner.length > 0 && places(child.constrs)) return compositeLayout(child, point, cell, data, index, parent.constrs);
+	const inset = child ? insetBoxes(parent, child, cell.cx) : void 0;
+	if (child && inset) {
+		const out = [];
+		for (const { box, x, cx } of inset) {
+			if (box.alg === "sp" && box.hideGeom === true) continue;
+			out.push(...splitCell(parent, box.name, point, data, {
+				...cell,
+				x: cell.x + x,
+				cx
+			}, box.shapeType ?? shapeType, index));
+		}
+		if (out.length > 0) return out;
+	}
+	if (!child || inner.length < 2) return whole();
+	const widths = inner.map((b) => sizeFact(child.constrs, b.name, "w"));
+	const across = widths.some((v) => v !== void 0 && v < .99);
+	const share = widths.reduce((a, v) => a + (v ?? 0), 0);
+	if (inner.length > 2 && !(across && widths.every((v) => v !== void 0) && Math.abs(share - 1) < .02)) return whole();
+	const kids = data.children(point.id, "node");
+	const shares = across ? fractions(widths) : fractions(inner.map((b) => sizeFact(child.constrs, b.name, "h") ?? heightFact(parent, b.name)));
+	const cap = inner.length === 2 ? heightCap(inner[0], across ? cell.cx * (shares[0] ?? 1) : cell.cx) : void 0;
+	if (!across && cap !== void 0) {
+		shares[0] = Math.min(cell.cy * (shares[0] ?? .5), cap) / cell.cy;
+		shares[1] = 1 - shares[0];
+	}
+	const out = [];
+	let at = across ? cell.x : cell.y;
+	inner.forEach((box, i) => {
+		const span = (across ? cell.cx : cell.cy) * (shares[i] ?? .5);
+		const spacer = box.alg === "sp" && box.shapeType === void 0;
+		if (span > 0 && !spacer && !(box.needsChildren && kids.length === 0)) out.push({
+			point: box.alg === "sp" ? {
+				id: `${point.id}/${box.name}`,
+				type: "node"
+			} : box.presOfAxis === void 0 ? i === 0 ? point : gatheredText(point, kids) : spokenFor(box, point, data),
+			shapeType: i === 0 ? shapeType : box.shapeType ?? "rect",
+			...box.styleLbl !== void 0 ? { styleLbl: box.styleLbl } : {},
+			...opt("fontSizePt", size(box, i === 0 ? "primFontSz" : "secFontSz")),
+			...bulleted(box) ? { bulleted: true } : {},
+			...box.hideGeom === true ? { hideGeom: true } : {},
+			...textPlacing(box),
+			index,
+			x: across ? at : cell.x,
+			y: across ? cell.y : at,
+			cx: across ? span : cell.cx,
+			cy: across ? cell.cy : span
+		});
+		at += span;
+	});
+	return out.length > 0 ? out : whole();
+}
+function fractions(facts) {
+	const total = facts.reduce((a, b) => a + (b ?? 0), 0);
+	if (total > 1.001) return facts.map((v) => (v ?? 0) / total);
+	const unstated = facts.filter((v) => v === void 0).length;
+	const rest = Math.max(0, 1 - total) / Math.max(1, unstated);
+	return facts.map((v) => v ?? rest);
+}
+function gatheredText(parent, kids) {
+	const paragraphs = kids.flatMap((k) => k.text ? poChildren(k.text) : []);
+	if (paragraphs.length === 0) return {
+		id: `${parent.id}/des`,
+		type: "node"
+	};
+	return {
+		id: `${parent.id}/des`,
+		type: "node",
+		text: { "dgm:t": paragraphs }
+	};
+}
+function bestColumns(n, cx, cy, aspect, gap) {
+	if (n <= 1) return 1;
+	let best = n;
+	let bestErr = Infinity;
+	for (let cols = 1; cols <= n; cols++) {
+		const rows = Math.ceil(n / cols);
+		const w = cx / (cols + Math.max(0, cols - 1) * gap);
+		const h = cy / (rows + Math.max(0, rows - 1) * gap);
+		const err = Math.abs(Math.log(h / w / (aspect || 1)));
+		if (err < bestErr - 1e-9) {
+			bestErr = err;
+			best = cols;
+		}
+	}
+	return best;
+}
+function findNamed(items, name) {
+	for (const item of items) if (item.kind === "node") {
+		if (item.name === name) return item;
+		const inner = findNamed(item.children, name);
+		if (inner) return inner;
+	} else {
+		const inner = findNamed(item.children, name);
+		if (inner) return inner;
+	}
+}
+function namedBoxes(node) {
+	const out = [];
+	for (const item of node.children) if (item.kind === "node") out.push(item);
+	else for (const inner of item.children) if (inner.kind === "node") out.push(inner);
+	return out;
+}
+function sizeFact(constrs, name, type) {
+	for (const k of constrs) if (k.type === type && k.forName === name && k.refType === type && k.refForName === void 0) return k.fact;
+}
+function fontSize(constrs, name, type) {
+	for (const k of constrs) {
+		if (k.type !== type || k.forName !== name) continue;
+		if (k.val !== void 0) return k.val;
+		if (k.refType === "primFontSz" && k.refForName !== void 0) {
+			const from = fontSize(constrs, k.refForName, "primFontSz");
+			if (from !== void 0) return from * (k.fact || 1);
+		}
+	}
+	return type === "secFontSz" ? fontSize(constrs, name, "primFontSz") : void 0;
+}
+function bulleted(node) {
+	return Number(node.algParams.get("stBulletLvl") ?? "0") >= 1;
+}
+function opt(name, v) {
+	return v === void 0 ? {} : { [name]: v };
+}
+function heightCap(box, widthEmu) {
+	for (const k of box?.constrs ?? []) if (k.type === "h" && k.refType === "w" && k.op === "lte") return widthEmu * k.fact;
+}
+function heightFact(parent, name) {
+	for (const k of parent.constrs) if (k.type === "h" && k.forName === name && k.refType === "primFontSz") return k.fact;
+}
+function resolve(constrs, childName) {
+	let aspect = .6;
+	let gap = .1;
+	for (const k of constrs) {
+		if (k.forName === childName && k.type === "h" && k.refType === "w") aspect = k.fact;
+		if (k.type === "w" && k.refForName === childName && k.forName !== childName) gap = k.fact;
+	}
+	return {
+		aspect,
+		gap
+	};
+}
+function isVertical(node) {
+	if (node.algParams.get("flowDir") === "col") return true;
+	const dir = node.algParams.get("linDir");
+	return dir === "fromT" || dir === "fromB";
+}
+function firstNodeName(items) {
+	for (const item of items) {
+		if (item.kind === "node") return item.name;
+		const inner = firstNodeName(item.children);
+		if (inner !== void 0) return inner;
+	}
+}
+function childShapeType(items) {
+	for (const item of items) {
+		if (item.kind === "node") return item.shapeType ?? childShapeType(item.children);
+		const inner = childShapeType(item.children);
+		if (inner !== void 0) return inner;
+	}
+}
+/**
+* §21.4.3.3 — a `choose` picks one branch by a function of the data, and what
+* the branch holds belongs to whatever the `choose` was standing in. The
+* direction variables are left at their defaults, so those take the first
+* `if`; `maxDepth` is answered from the model, because the branch it guards is
+* the difference between one box in a cell and two.
+*
+* @returns The children with every `choose` replaced by the branch taken, and
+*          the ones whose branch was guarded on a child count.
+*/
+function flattenChoose(kids, ctx) {
+	const flat = [];
+	const guarded = /* @__PURE__ */ new Set();
+	for (const k of kids) {
+		if (!poIs(k, "dgm:choose")) {
+			flat.push(k);
+			continue;
+		}
+		const branches = poChildren(k);
+		const taken = branches.find((b) => poIs(b, "dgm:if") && holds(b, ctx)) ?? branches.find((b) => poIs(b, "dgm:else")) ?? branches[0];
+		const onCount = taken !== void 0 && poIs(taken, "dgm:if") && countsChildren(taken);
+		const inner = flattenChoose(poChildren(taken), ctx);
+		for (const item of inner.flat) {
+			flat.push(item);
+			if (onCount || inner.guarded.has(item)) guarded.add(item);
+		}
+	}
+	return {
+		flat,
+		guarded
+	};
+}
+function parseNode(node, ctx) {
+	const { flat: flattened, guarded } = flattenChoose(poChildren(node), ctx);
+	const alg = flattened.find((k) => poIs(k, "dgm:alg"));
+	const shape = flattened.find((k) => poIs(k, "dgm:shape"));
+	const constrLst = flattened.find((k) => poIs(k, "dgm:constrLst"));
+	const params = /* @__PURE__ */ new Map();
+	for (const p of alg ? poChildren(alg) : []) {
+		const t = poAttr(p, "type");
+		const v = poAttr(p, "val");
+		if (t !== void 0 && v !== void 0) params.set(t, v);
+	}
+	const shapeType = shape ? poAttr(shape, "type") : void 0;
+	const styleLbl = poAttr(node, "styleLbl");
+	const presOf = flattened.find((k) => poIs(k, "dgm:presOf"));
+	const presOfAxis = poAttr(presOf, "axis");
+	const presOfPath = axisPath(presOf);
+	const shapeRot = shape ? Number(poAttr(shape, "rot") ?? "") : NaN;
+	return {
+		kind: "node",
+		name: poAttr(node, "name") ?? "",
+		...styleLbl !== void 0 && styleLbl !== "" ? { styleLbl } : {},
+		needsChildren: false,
+		alg: algOf(alg),
+		algParams: params,
+		...shapeType !== void 0 && shapeType !== "" ? { shapeType } : {},
+		...shape !== void 0 && poAttr(shape, "hideGeom") === "1" ? { hideGeom: true } : {},
+		...Number.isFinite(shapeRot) && shapeRot !== 0 ? { shapeRotation: shapeRot } : {},
+		...presOfAxis !== void 0 && presOfAxis !== "" ? { presOfAxis } : {},
+		...presOfPath ? { presOfPath } : {},
+		constrs: parseConstraints(constrLst),
+		children: flattened.flatMap((k) => parseItem(k, ctx, guarded.has(k)))
+	};
+}
+function holds(branch, ctx) {
+	const func = poAttr(branch, "func");
+	const axis = (poAttr(branch, "axis") ?? "").split(/\s+/u).filter((a) => a !== "");
+	if (func === "maxDepth") return compare(ctx.maxDepth, branch, "gte");
+	if (func === "cnt" && axis.length > 1) return compare(countAt(axis, branch, ctx), branch, "gte");
+	return true;
+}
+function countAt(axis, branch, ctx) {
+	const nums = (name) => (poAttr(branch, name) ?? "").split(/\s+/u).map((v) => Number(v));
+	const st = nums("st");
+	const cnt = nums("cnt");
+	const types = (poAttr(branch, "ptType") ?? "").split(/\s+/u);
+	let at = [ctx.root];
+	axis.forEach((step, i) => {
+		if (step !== "ch" && step !== "des") {
+			at = [];
+			return;
+		}
+		if ((types[i] === "node" || types[i] === void 0 ? "node" : void 0) === void 0) {
+			at = [];
+			return;
+		}
+		const next = at.flatMap((p) => ctx.data.children(p.id, "node"));
+		const from = Math.max(0, (st[i] ?? 1) - 1);
+		const want = cnt[i];
+		const take = want === void 0 || want === 0 ? next.length : want;
+		at = next.slice(from, from + take);
+	});
+	return at.length;
+}
+function compare(actual, branch, fallback) {
+	const val = Number(poAttr(branch, "val") ?? "0");
+	const op = poAttr(branch, "op") ?? fallback;
+	if (op === "gte") return actual >= val;
+	if (op === "gt") return actual > val;
+	if (op === "lte") return actual <= val;
+	if (op === "lt") return actual < val;
+	if (op === "neq") return actual !== val;
+	return actual === val;
+}
+function countsChildren(branch) {
+	return poAttr(branch, "func") === "cnt" && poAttr(branch, "axis") === "ch" && poAttr(branch, "ptType") === "node" && (poAttr(branch, "op") ?? "gte") === "gte" && Number(poAttr(branch, "val") ?? "1") >= 1;
+}
+function parseItem(node, ctx, guarded = false) {
+	if (poIs(node, "dgm:layoutNode")) return [{
+		...parseNode(node, ctx),
+		needsChildren: guarded
+	}];
+	if (poIs(node, "dgm:forEach")) {
+		const inner = flattenChoose(poChildren(node), ctx);
+		return [{
+			kind: "forEach",
+			axis: poAttr(node, "axis") ?? "",
+			ptType: poAttr(node, "ptType") ?? "",
+			children: inner.flat.flatMap((k) => parseItem(k, ctx, guarded || inner.guarded.has(k)))
+		}];
+	}
+	return [];
+}
+function parseConstraints(list) {
+	const out = [];
+	for (const k of list ? poChildren(list) : []) {
+		if (!poIs(k, "dgm:constr")) continue;
+		const type = poAttr(k, "type");
+		if (type === void 0) continue;
+		const forName = poAttr(k, "forName");
+		const op = poAttr(k, "op");
+		const refType = poAttr(k, "refType");
+		const refForName = poAttr(k, "refForName");
+		const val = poAttr(k, "val");
+		out.push({
+			type,
+			...forName !== void 0 ? { forName } : {},
+			...op !== void 0 ? { op } : {},
+			...refType !== void 0 ? { refType } : {},
+			...refForName !== void 0 ? { refForName } : {},
+			fact: Number(poAttr(k, "fact") ?? "1"),
+			...val !== void 0 ? { val: Number(val) } : {}
+		});
+	}
+	return out;
+}
+function algOf(alg) {
+	const t = alg ? poAttr(alg, "type") : void 0;
+	if (t === "hierRoot" || t === "hierChild") return "hier";
+	return t === "snake" || t === "lin" || t === "sp" || t === "tx" || t === "composite" || t === "cycle" ? t : "other";
+}
+function findChild(nodes, tag) {
+	return nodes.find((n) => poIs(n, tag) || poTag(n) === tag);
+}
+//#endregion
+export { layoutDiagram };