reamkit 1.15.4 → 1.17.0

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

@@ -1,11 +1,25 @@
 import { emuToPt, pt } from "../core/ir/units.js";
-import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poTag, poText } from "../core/po-helpers.js";
-import { resolveColorNode } from "../core/drawingml/colors.js";
+import { buildStroke } from "../core/drawingml/shape-render.js";
+import { poAttr, poAttrLocal, poChildren, poFindDescendant, poIntAttr, poIs, poIsLocal, poTag, poText } from "../core/po-helpers.js";
+import { applyColorMods, readColorMods, resolveColorNode } from "../core/drawingml/colors.js";
 //#region src/word/drawing-parser.ts
 var WPS_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
-var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
-var DIAGRAM_URI = "http://schemas.openxmlformats.org/drawingml/2006/diagram";
-var UNDERSTOOD_NS = new Set(["wps"]);
+var DRAWINGML_URI_BASES = ["http://schemas.openxmlformats.org/drawingml/2006/", "http://purl.oclc.org/ooxml/drawingml/"];
+function isDrawingMlUri(uri, name) {
+	return uri !== void 0 && DRAWINGML_URI_BASES.some((base) => uri === base + name);
+}
+var WPG_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup";
+var WPC_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas";
+var EMPTY_GEOMETRY = {
+	pathWidth: 0,
+	pathHeight: 0,
+	commands: []
+};
+var UNDERSTOOD_NS = new Set([
+	"wps",
+	"wpg",
+	"wpc"
+]);
 function parseFloatAnchor(anchor) {
 	if (!poIs(anchor, "wp:anchor")) return void 0;
 	const behindRaw = poAttr(anchor, "behindDoc");
@@ -15,20 +29,35 @@ function parseFloatAnchor(anchor) {
 	else if (poIs(child, "wp:wrapTight")) wrap = "tight";
 	else if (poIs(child, "wp:wrapThrough")) wrap = "through";
 	else if (poIs(child, "wp:wrapTopAndBottom")) wrap = "topAndBottom";
+	const zOrder = poIntAttr(anchor, "relativeHeight");
 	const posH = parseAnchorPos(anchor, "wp:positionH", [
 		"margin",
 		"page",
-		"column"
+		"column",
+		"leftMargin",
+		"rightMargin"
 	]);
 	const posV = parseAnchorPos(anchor, "wp:positionV", [
 		"margin",
 		"page",
 		"paragraph",
-		"line"
+		"line",
+		"topMargin",
+		"bottomMargin"
 	]);
+	const dist = (name) => emuToPt(poIntAttr(anchor, name) ?? 0);
+	const wrapDist = {
+		topPt: dist("distT"),
+		bottomPt: dist("distB"),
+		leftPt: dist("distL"),
+		rightPt: dist("distR")
+	};
+	const anyDist = Object.values(wrapDist).some((v) => v > 0);
 	return {
 		wrap,
 		...behind ? { behind: true } : {},
+		...zOrder !== void 0 ? { zOrder } : {},
+		...anyDist ? { wrapDist } : {},
 		...posH ? { posH } : {},
 		...posV ? { posV } : {}
 	};
@@ -38,8 +67,74 @@ var ANCHOR_ALIGNS = new Set([
 	"center",
 	"right"
 ]);
+var ANCHOR_V_ALIGNS = new Set([
+	"top",
+	"center",
+	"bottom"
+]);
+/**
+* `wp14:sizeRelH` / `wp14:sizeRelV` — the drawing's width and height as
+* hundredths of a percent of the page or the margins. Word writes the resolved
+* extent beside them for readers that do not know the namespace, which is what
+* we drew: dml-shape-relsize.docx asks for 40% of the margin and got the
+* fallback's 90pt.
+*
+* @param anchor The `wp:anchor` node.
+* @returns The relative size, or `undefined` when the anchor states none.
+*/
+function parseRelativeSize(anchor) {
+	const read = (tag, pctTag) => {
+		const node = expandMcChildren(poChildren(anchor)).find((c) => poIs(c, tag));
+		if (!node) return void 0;
+		const pctNode = poChildren(node).find((c) => poIs(c, pctTag));
+		const raw = pctNode ? Number(poText(pctNode).trim()) : NaN;
+		if (!Number.isFinite(raw) || raw <= 0) return void 0;
+		const from = poAttr(node, "relativeFrom") ?? "margin";
+		return {
+			pct: raw / 1e5,
+			from
+		};
+	};
+	const h = read("wp14:sizeRelH", "wp14:pctWidth");
+	const v = read("wp14:sizeRelV", "wp14:pctHeight");
+	if (!h && !v) return void 0;
+	return {
+		...h ? {
+			widthPct: h.pct,
+			widthFrom: relFromH(h.from)
+		} : {},
+		...v ? {
+			heightPct: v.pct,
+			heightFrom: relFromV(v.from)
+		} : {}
+	};
+}
+function relFromH(raw) {
+	if (raw === "page") return "page";
+	if (raw === "leftMargin" || raw === "insideMargin") return "leftMargin";
+	if (raw === "rightMargin" || raw === "outsideMargin") return "rightMargin";
+	return "margin";
+}
+function relFromV(raw) {
+	if (raw === "page") return "page";
+	if (raw === "topMargin" || raw === "insideMargin") return "topMargin";
+	if (raw === "bottomMargin" || raw === "outsideMargin") return "bottomMargin";
+	return "margin";
+}
+/**
+* The first ELEMENT among a node's children. `poTag` gives a text node no tag
+* at all, and a "not #text" test let the whitespace between pretty-printed
+* elements win: dashed_line_custdash_percentage.docx indents its `a:lnRef`, so
+* the colour inside it went unread and its blue rule came out black.
+*
+* @param node The parent node.
+* @returns The first child that is an element, or `undefined`.
+*/
+function firstElementChild(node) {
+	return poChildren(node).find((c) => poTag(c) !== void 0);
+}
 function parseAnchorPos(anchor, tag, allowed) {
-	const pos = poChildren(anchor).find((c) => poIs(c, tag));
+	const pos = expandMcChildren(poChildren(anchor)).find((c) => poIs(c, tag));
 	if (!pos) return void 0;
 	const relRaw = poAttr(pos, "relativeFrom") ?? "margin";
 	const relativeFrom = allowed.includes(relRaw) ? relRaw : allowed[0];
@@ -50,7 +145,8 @@ function parseAnchorPos(anchor, tag, allowed) {
 	return {
 		relativeFrom,
 		...Number.isFinite(offsetRaw) ? { offsetPt: emuToPt(offsetRaw) } : {},
-		...tag === "wp:positionH" && ANCHOR_ALIGNS.has(alignRaw) ? { align: alignRaw } : {}
+		...tag === "wp:positionH" && ANCHOR_ALIGNS.has(alignRaw) ? { align: alignRaw } : {},
+		...tag === "wp:positionV" && ANCHOR_V_ALIGNS.has(alignRaw) ? { align: alignRaw } : {}
 	};
 }
 /**
@@ -97,7 +193,7 @@ function expandMcChildren(children) {
 * @param parseBody    Optional body parser for a shape's text box (omitted ⇒ no text).
 * @returns The parsed content, or `null` when no anchor / recognizable graphic is found.
 */
-function parseDrawing(drawing, resolveColor, parseBody) {
+function parseDrawing(drawing, resolveColor, parseBody, resolveImage, resolveChartPart, themeLineWidths, themeStyles, parseDrawingText) {
 	const anchor = poChildren(drawing).find((c) => poIs(c, "wp:inline")) ?? poChildren(drawing).find((c) => poIs(c, "wp:anchor"));
 	if (!anchor) return null;
 	const extent = poFindDescendant(anchor, "wp:extent");
@@ -112,29 +208,78 @@ function parseDrawing(drawing, resolveColor, parseBody) {
 		...altText ? { altText } : {},
 		...float ? { float } : {}
 	};
+	const relativeSize = parseRelativeSize(anchor);
 	const graphicData = poFindDescendant(anchor, "a:graphicData");
 	const uri = graphicData ? poAttr(graphicData, "uri") : void 0;
 	if (graphicData && uri === WPS_URI) {
-		const data = parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody);
-		return data ? {
+		const data = parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+		if (!data) return null;
+		return {
 			kind: "shape",
-			data,
+			data: {
+				...data,
+				...relativeSize ? { relativeSize } : {}
+			},
 			...alt
-		} : null;
+		};
 	}
-	if (graphicData && uri === CHART_URI) {
+	if (graphicData && uri === WPG_URI) {
+		const data = parseWgp(graphicData, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+		if (!data) return null;
+		return {
+			kind: "shape",
+			data: {
+				...data,
+				...relativeSize ? { relativeSize } : {}
+			},
+			...alt
+		};
+	}
+	if (graphicData && isDrawingMlUri(uri, "lockedCanvas")) {
+		const data = parseLockedCanvas(graphicData, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+		if (!data) return null;
+		return {
+			kind: "shape",
+			data: {
+				...data,
+				...relativeSize ? { relativeSize } : {}
+			},
+			...alt
+		};
+	}
+	if (graphicData && uri === WPC_URI) {
+		const canvas = expandMcChildren(poChildren(graphicData)).find((c) => poIsLocal(c, "wpc"));
+		if (!canvas || extentCx === void 0 || extentCy === void 0) return null;
+		const children = groupChildren(canvas, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+		return {
+			kind: "shape",
+			data: {
+				width: emuToPt(extentCx),
+				height: emuToPt(extentCy),
+				...children.length > 0 ? { children } : {},
+				geometry: {
+					kind: "custom",
+					custom: EMPTY_GEOMETRY
+				},
+				fill: { kind: "none" },
+				...relativeSize ? { relativeSize } : {}
+			},
+			...alt
+		};
+	}
+	if (graphicData && isDrawingMlUri(uri, "chart")) {
 		const cChart = poFindDescendant(graphicData, "c:chart");
 		const chartRelId = cChart ? poAttr(cChart, "id") : void 0;
 		if (chartRelId && extentCx !== void 0 && extentCy !== void 0) return {
 			kind: "chart",
-			chartRelId,
+			chartRelId: resolveChartPart?.(chartRelId) ?? chartRelId,
 			width: emuToPt(extentCx),
 			height: emuToPt(extentCy),
 			...alt
 		};
 		return null;
 	}
-	if (graphicData && uri === DIAGRAM_URI) {
+	if (graphicData && isDrawingMlUri(uri, "diagram")) {
 		const relIds = poFindDescendant(graphicData, "dgm:relIds");
 		const dmRelId = relIds ? poAttr(relIds, "dm") : void 0;
 		if (dmRelId && extentCx !== void 0 && extentCy !== void 0) return {
@@ -148,13 +293,39 @@ function parseDrawing(drawing, resolveColor, parseBody) {
 	}
 	const blip = poFindDescendant(anchor, "a:blip");
 	const rId = blip ? poAttr(blip, "embed") : void 0;
-	if (extentCx !== void 0 && extentCy !== void 0 && rId) return {
-		kind: "image",
-		imageId: rId,
-		width: emuToPt(extentCx),
-		height: emuToPt(extentCy),
-		...alt
-	};
+	if (extentCx !== void 0 && extentCy !== void 0 && rId) {
+		const crop = parseSrcRect(poFindDescendant(anchor, "a:srcRect"));
+		const xfrm = poFindDescendant(anchor, "a:xfrm");
+		const rot = xfrm ? poIntAttr(xfrm, "rot") : void 0;
+		const on = (name) => xfrm !== void 0 && (poAttr(xfrm, name) === "1" || poAttr(xfrm, name) === "true");
+		const effect = poIs(anchor, "wp:inline") ? poChildren(anchor).find((c) => poIs(c, "wp:effectExtent")) : void 0;
+		const side = (name) => emuToPt(effect ? Math.max(0, poIntAttr(effect, name) ?? 0) : 0);
+		const box = {
+			leftPt: side("l"),
+			topPt: side("t"),
+			rightPt: side("r"),
+			bottomPt: side("b")
+		};
+		const effectExtent = Object.values(box).some((v) => v > 0) ? box : void 0;
+		const spPr = poFindDescendant(anchor, "pic:spPr");
+		const outline = spPr ? pictureOutline(parseLine(spPr, resolveColor)) : void 0;
+		const shadow = spPr ? parseShadow(spPr, resolveColor) : void 0;
+		return {
+			kind: "image",
+			imageId: rId,
+			width: emuToPt(extentCx),
+			height: emuToPt(extentCy),
+			...outline ? { outline } : {},
+			...shadow ? { shadow } : {},
+			...crop ? { crop } : {},
+			...rot ? { rotation60k: rot } : {},
+			...on("flipH") ? { flipH: true } : {},
+			...on("flipV") ? { flipV: true } : {},
+			...relativeSize ? { relativeSize } : {},
+			...effectExtent ? { effectExtent } : {},
+			...alt
+		};
+	}
 	return null;
 }
 /**
@@ -169,9 +340,9 @@ function parseDrawing(drawing, resolveColor, parseBody) {
 * @param node The `w:pict` / `w:object` node.
 * @returns The picture, or `null` when there is no embedded `v:imagedata` or no usable size.
 */
-function parseVmlPicture(node) {
-	const imagedata = poFindDescendant(node, "v:imagedata");
-	if (!imagedata) return null;
+function parseVmlPicture(node, parseBody) {
+	const imagedata = poChildren(node).some((c) => poIs(c, "v:group")) ? void 0 : poFindDescendant(node, "v:imagedata");
+	if (!imagedata) return parseVmlWordArt(node) ?? parseVmlShape(node, parseBody);
 	const imageId = poAttr(imagedata, "id");
 	if (imageId === void 0) return null;
 	const shape = poFindDescendant(node, "v:shape") ?? poFindDescendant(node, "v:rect") ?? poFindDescendant(node, "v:oval");
@@ -179,14 +350,754 @@ function parseVmlPicture(node) {
 	const height = vmlStyleLength(shape, "height");
 	if (width === void 0 || height === void 0) return null;
 	const altText = (shape ? poAttr(shape, "alt") : void 0)?.trim() || poAttr(imagedata, "title")?.trim() || void 0;
+	const float = shape ? vmlFloat(poAttr(shape, "style") ?? "", poIntAttr(shape, "z-index"), shape) : void 0;
+	const typeRef = shape ? poAttr(shape, "type")?.replace(/^#/u, "") : void 0;
+	const shapeType = typeRef !== void 0 ? vmlShapeTypes(node).get(typeRef) : void 0;
+	const stroked = shape ? poAttr(shape, "stroked") ?? (shapeType ? poAttr(shapeType, "stroked") : void 0) : void 0;
+	const outline = shape && (stroked === "t" || stroked === "true") ? pictureOutline(vmlLine(shape, shapeType)) : void 0;
 	return {
 		kind: "image",
 		imageId,
 		width,
 		height,
+		...outline ? { outline } : {},
+		...float ? { float } : {},
 		...altText ? { altText } : {}
 	};
 }
+/**
+* §14.1.2 — a legacy VML shape drawn as the DrawingML one it corresponds to:
+* `v:rect`, `v:roundrect`, `v:oval`, `v:line` and a `v:shape` we cannot resolve
+* a path for (drawn as its box). 113 corpus documents still hold one — older
+* Word wrote every drawing this way — and read only for its `v:imagedata`,
+* every one of them lost the shape, its fill, its outline and the text in it:
+* drawinglayer-pic-pos.docx frames its title in a `v:rect` and we printed the
+* page without it.
+*
+* @param node       The `w:pict` / `w:object` node.
+* @param parseBody  Body parser for a `v:textbox`'s content.
+* @returns The shape, or `null` when nothing drawable is found.
+*/
+function parseVmlShape(node, parseBody) {
+	const shape = poChildren(node).find((c) => VML_SHAPE_TAGS.has(poTag(c) ?? ""));
+	if (!shape) return null;
+	if (poIs(shape, "v:group")) {
+		const data = parseVmlGroup(shape, parseBody, vmlShapeTypes(node));
+		if (!data) return null;
+		const groupFloat = vmlFloat(poAttr(shape, "style") ?? "", poIntAttr(shape, "z-index"), shape);
+		return {
+			kind: "shape",
+			data,
+			...groupFloat ? { float: groupFloat } : {},
+			...poAttr(shape, "alt")?.trim() ? { altText: poAttr(shape, "alt").trim() } : {}
+		};
+	}
+	const tag = poTag(shape) ?? "";
+	const style = poAttr(shape, "style") ?? "";
+	const width = vmlStyleLength(shape, "width");
+	const height = vmlStyleLength(shape, "height");
+	const from = tag === "v:line" ? vmlPoint(poAttr(shape, "from")) : void 0;
+	const to = tag === "v:line" ? vmlPoint(poAttr(shape, "to")) : void 0;
+	const boxW = width ?? (from && to ? Math.abs(to.x - from.x) : void 0);
+	const boxH = height ?? (from && to ? Math.abs(to.y - from.y) : void 0);
+	if (boxW === void 0 || boxH === void 0) return null;
+	const data = vmlShapeData(shape, tag, pt(Math.max(1, boxW)), pt(Math.max(1, boxH)), parseBody, vmlShapeTypes(node));
+	if (!data) return null;
+	const float = vmlFloat(style, poIntAttr(shape, "z-index"), shape);
+	return {
+		kind: "shape",
+		data,
+		...float ? { float } : {},
+		...poAttr(shape, "alt")?.trim() ? { altText: poAttr(shape, "alt").trim() } : {}
+	};
+}
+/**
+* One VML primitive as {@link ShapeData}: its preset geometry, fill, outline
+* and the words in its text box.
+*
+* @param shape     The `v:rect` / `v:oval` / … node.
+* @param tag       Its tag, which picks the preset.
+* @param width     The box's width, already in points.
+* @param height    Its height.
+* @param parseBody Body parser for a `v:textbox`.
+* @returns The shape, or `null` when it draws nothing and says nothing.
+*/
+/**
+* §14.1.2.19 `v:shapetype` — the reusable shape definitions declared alongside
+* the shapes that reference them by `@type="#id"`, keyed by id.
+*
+* @param node The `w:pict` / `w:object` node.
+* @returns The shapetypes found anywhere within it.
+*/
+function vmlShapeTypes(node) {
+	const out = /* @__PURE__ */ new Map();
+	const walk = (n) => {
+		for (const c of poChildren(n)) {
+			if (poIs(c, "v:shapetype")) {
+				const id = poAttr(c, "id");
+				if (id !== void 0) out.set(id, c);
+			}
+			walk(c);
+		}
+	};
+	walk(node);
+	return out;
+}
+function vmlShapeData(shape, tag, width, height, parseBody, shapeTypes) {
+	const typeRef = poAttr(shape, "type")?.replace(/^#/u, "");
+	const shapeType = typeRef !== void 0 ? shapeTypes?.get(typeRef) : void 0;
+	const fill = vmlFill(shape, shapeType);
+	const line = vmlLine(shape, shapeType);
+	const text = parseBody ? vmlTextBox(shape, parseBody) : void 0;
+	if (fill.kind === "none" && !line && !text) return null;
+	const rotationDeg = vmlStyleNumber(shape, "rotation");
+	const flip = vmlStyleValue(shape, "flip")?.toLowerCase() ?? "";
+	const flipH = flip.includes("x");
+	const flipV = flip.includes("y");
+	const spun = rotationDeg !== void 0 && rotationDeg % 360 !== 0 ? rotationDeg : void 0;
+	const transform = spun !== void 0 || flipH || flipV ? {
+		...spun !== void 0 ? { rotation60k: Math.round(spun * 6e4) } : {},
+		...flipH ? { flipH: true } : {},
+		...flipV ? { flipV: true } : {}
+	} : void 0;
+	const wordArt = vmlWordArtBody(shape, width, height);
+	if (wordArt) return {
+		width,
+		height,
+		geometry: {
+			kind: "preset",
+			preset: "rect",
+			adjust: /* @__PURE__ */ new Map()
+		},
+		fill: { kind: "none" },
+		text: wordArt,
+		...transform ? { transform } : {}
+	};
+	return {
+		width,
+		height,
+		geometry: vmlCustomGeometry(shape, shapeType) ?? {
+			kind: "preset",
+			preset: (shapeType && VML_SPT_PRESETS[poAttrLocal(shapeType, "spt") ?? ""]) ?? VML_PRESETS[tag] ?? "rect",
+			adjust: /* @__PURE__ */ new Map()
+		},
+		fill,
+		...line ? { line } : {},
+		...transform ? { transform } : {},
+		...text ? { text } : {}
+	};
+}
+/**
+* §14.1.4 `@path` — a VML shape's own outline, in the coordinate space its
+* `@coordsize` declares (1000×1000 by default) with `@coordorigin` at the
+* corner. Word writes freeform shapes this way, as plain numbers; a path that
+* names a FORMULA (`@n`) or an arc command is left to the preset fallback.
+*
+* @param shape     The `v:shape`/`v:rect`/… node.
+* @param shapeType Its `v:shapetype`, which may carry the path instead.
+* @returns The geometry, or `undefined` when there is no path we can read.
+*/
+function vmlCustomGeometry(shape, shapeType) {
+	const raw = poAttr(shape, "path") ?? (shapeType ? poAttr(shapeType, "path") : void 0);
+	if (raw === void 0 || raw === "" || raw.includes("@")) return void 0;
+	const size = poAttr(shape, "coordsize") ?? (shapeType ? poAttr(shapeType, "coordsize") : void 0);
+	const origin = poAttr(shape, "coordorigin") ?? (shapeType ? poAttr(shapeType, "coordorigin") : void 0);
+	const [sx, sy] = pairOf(size) ?? [1e3, 1e3];
+	const [ox, oy] = pairOf(origin) ?? [0, 0];
+	if (sx <= 0 || sy <= 0) return void 0;
+	const commands = vmlPathCommands(raw, ox, oy);
+	if (commands === void 0 || commands.length === 0) return void 0;
+	return {
+		kind: "custom",
+		custom: {
+			pathWidth: sx,
+			pathHeight: sy,
+			commands
+		}
+	};
+}
+function pairOf(v) {
+	const m = v !== void 0 ? /^\s*(-?\d+)[ ,]+(-?\d+)\s*$/u.exec(v) : null;
+	return m ? [Number(m[1]), Number(m[2])] : void 0;
+}
+var VML_PATH_PAIRS = new Set([
+	"nf",
+	"ns",
+	"qx",
+	"qy",
+	"qb",
+	"at",
+	"wa",
+	"ar",
+	"ae"
+]);
+function vmlPathCommands(raw, originX, originY) {
+	const out = [];
+	let x = 0;
+	let y = 0;
+	let i = 0;
+	const isLetter = (c) => /[a-z]/iu.test(c);
+	while (i < raw.length) {
+		const c = raw[i];
+		if (!isLetter(c)) {
+			if (/[\s,]/u.test(c)) {
+				i++;
+				continue;
+			}
+			return;
+		}
+		let cmd = c.toLowerCase();
+		i++;
+		if (i < raw.length && isLetter(raw[i])) {
+			const pair = cmd + raw[i].toLowerCase();
+			if (VML_PATH_PAIRS.has(pair)) {
+				cmd = pair;
+				i++;
+			}
+		}
+		const start = i;
+		while (i < raw.length && !isLetter(raw[i])) i++;
+		const args = raw.slice(start, i);
+		if (cmd === "e" || cmd === "n" || cmd === "nf" || cmd === "ns") continue;
+		if (cmd === "x") {
+			out.push({ cmd: "close" });
+			continue;
+		}
+		const nums = vmlPathNumbers(args);
+		if (nums === void 0) return void 0;
+		const rel = cmd === "t" || cmd === "r" || cmd === "v";
+		if (cmd === "m" || cmd === "l" || cmd === "t" || cmd === "r") {
+			if (nums.length < 2 || nums.length % 2 !== 0) return void 0;
+			for (let k = 0; k < nums.length; k += 2) {
+				x = rel ? x + nums[k] : nums[k];
+				y = rel ? y + nums[k + 1] : nums[k + 1];
+				const move = (cmd === "m" || cmd === "t") && k === 0;
+				out.push({
+					cmd: move ? "move" : "line",
+					x: x - originX,
+					y: y - originY
+				});
+			}
+			continue;
+		}
+		if (cmd === "c" || cmd === "v") {
+			if (nums.length < 6 || nums.length % 6 !== 0) return void 0;
+			for (let k = 0; k < nums.length; k += 6) {
+				const x1 = rel ? x + nums[k] : nums[k];
+				const y1 = rel ? y + nums[k + 1] : nums[k + 1];
+				const x2 = rel ? x + nums[k + 2] : nums[k + 2];
+				const y2 = rel ? y + nums[k + 3] : nums[k + 3];
+				x = rel ? x + nums[k + 4] : nums[k + 4];
+				y = rel ? y + nums[k + 5] : nums[k + 5];
+				out.push({
+					cmd: "cubic",
+					x1: x1 - originX,
+					y1: y1 - originY,
+					x2: x2 - originX,
+					y2: y2 - originY,
+					x: x - originX,
+					y: y - originY
+				});
+			}
+			continue;
+		}
+		return;
+	}
+	return out;
+}
+function vmlPathNumbers(args) {
+	const fields = args.trim().split(/\s*,\s*|\s+/u);
+	const out = [];
+	for (const f of fields) {
+		if (f === "") {
+			out.push(0);
+			continue;
+		}
+		if (!/^-?\d+$/u.test(f)) return void 0;
+		out.push(Number(f));
+	}
+	return out;
+}
+/**
+* §14.1.2.7 `v:group` — a VML group: its `@style` gives the box on the page,
+* its `@coordsize`/`@coordorigin` the space its children are positioned in.
+* dml-textshape.docx draws its whole diagram inside one, and read as a single
+* shape it drew nothing at all.
+*
+* @param group     The `v:group` node.
+* @param parseBody Body parser for the members' text boxes.
+* @returns The group as a shape with members, or `null` when it has no box.
+*/
+function parseVmlGroup(group, parseBody, shapeTypes, sizePt) {
+	const width = sizePt?.w ?? vmlStyleLength(group, "width");
+	const height = sizePt?.h ?? vmlStyleLength(group, "height");
+	if (width === void 0 || height === void 0) return null;
+	const size = vmlPair(poAttr(group, "coordsize")) ?? {
+		x: width,
+		y: height
+	};
+	const origin = vmlPair(poAttr(group, "coordorigin")) ?? {
+		x: 0,
+		y: 0
+	};
+	const sx = size.x > 0 ? width / size.x : 1;
+	const sy = size.y > 0 ? height / size.y : 1;
+	const children = [];
+	for (const child of poChildren(group)) {
+		const tag = poTag(child) ?? "";
+		if (!VML_SHAPE_TAGS.has(tag)) continue;
+		const ends = tag === "v:line" ? {
+			from: vmlPair(poAttr(child, "from")),
+			to: vmlPair(poAttr(child, "to"))
+		} : void 0;
+		const span = ends?.from && ends.to ? ends : void 0;
+		const left = span ? Math.min(span.from.x, span.to.x) : vmlStyleNumber(child, "left") ?? 0;
+		const top = span ? Math.min(span.from.y, span.to.y) : vmlStyleNumber(child, "top") ?? 0;
+		const w = span ? Math.abs(span.to.x - span.from.x) : vmlStyleNumber(child, "width");
+		const h = span ? Math.abs(span.to.y - span.from.y) : vmlStyleNumber(child, "height");
+		if (w === void 0 || h === void 0) continue;
+		const data = tag === "v:group" ? parseVmlGroup(child, parseBody, shapeTypes, {
+			w: Math.max(1, w * sx),
+			h: Math.max(1, h * sy)
+		}) : vmlShapeData(child, tag, pt(Math.max(1, w * sx)), pt(Math.max(1, h * sy)), parseBody, shapeTypes);
+		if (!data) continue;
+		children.push({
+			shape: {
+				...data,
+				paragraphProperties: {}
+			},
+			xPt: pt((left - origin.x) * sx),
+			yPt: pt((top - origin.y) * sy)
+		});
+	}
+	if (children.length === 0) return null;
+	return {
+		width: pt(width),
+		height: pt(height),
+		children,
+		geometry: {
+			kind: "custom",
+			custom: EMPTY_GEOMETRY
+		},
+		fill: { kind: "none" }
+	};
+}
+var VML_SHAPE_TAGS = new Set([
+	"v:rect",
+	"v:roundrect",
+	"v:oval",
+	"v:line",
+	"v:shape",
+	"v:group"
+]);
+/** A bare `x,y` attribute pair (`coordsize`, `coordorigin`). */
+function vmlPair(raw) {
+	if (!raw) return void 0;
+	const [a, b] = raw.split(",");
+	const x = Number(a);
+	const y = Number(b);
+	return Number.isFinite(x) && Number.isFinite(y) ? {
+		x,
+		y
+	} : void 0;
+}
+/** A unitless `@style` number (a child inside a group is in coord units). */
+/** §14.1.2.19 — a CSS-like `@style` property's raw value ("flip:xy" → "xy"). */
+function vmlStyleValue(shape, prop) {
+	const style = poAttr(shape, "style");
+	if (style === void 0) return void 0;
+	return new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "iu").exec(style)?.[1]?.trim();
+}
+function vmlStyleNumber(shape, prop) {
+	const style = poAttr(shape, "style");
+	if (style === void 0) return void 0;
+	const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*(-?[0-9.]+)`, "iu").exec(style);
+	if (!m) return void 0;
+	const v = Number.parseFloat(m[1]);
+	return Number.isFinite(v) ? v : void 0;
+}
+var VML_SPT_PRESETS = {
+	"1": "rect",
+	"2": "roundRect",
+	"3": "ellipse",
+	"4": "diamond",
+	"5": "triangle",
+	"6": "rtTriangle",
+	"7": "parallelogram",
+	"8": "trapezoid",
+	"9": "hexagon",
+	"12": "star5",
+	"13": "rightArrow",
+	"20": "line",
+	"32": "line",
+	"33": "bentConnector2",
+	"34": "bentConnector3",
+	"56": "pentagon",
+	"58": "star8",
+	"59": "star16",
+	"60": "star32",
+	"66": "leftArrow",
+	"67": "downArrow",
+	"68": "upArrow"
+};
+var VML_PRESETS = {
+	"v:rect": "rect",
+	"v:roundrect": "roundRect",
+	"v:oval": "ellipse",
+	"v:line": "line",
+	"v:shape": "rect"
+};
+/** A VML `from`/`to` point ("0,0" or "10pt,20pt"), in points. */
+function vmlPoint(raw) {
+	if (!raw) return void 0;
+	const parts = raw.split(",");
+	if (parts.length !== 2) return void 0;
+	const num = (t) => {
+		const m = /(-?[0-9.]+)\s*(pt|in|px|cm|mm|pc)?/iu.exec(t.trim());
+		if (!m) return NaN;
+		return Number.parseFloat(m[1]) * (VML_UNIT_TO_PT[(m[2] ?? "px").toLowerCase()] ?? 1);
+	};
+	const x = num(parts[0]);
+	const y = num(parts[1]);
+	return Number.isFinite(x) && Number.isFinite(y) ? {
+		x,
+		y
+	} : void 0;
+}
+/** §14.1.2.11 — a VML colour: `#rrggbb`, a named colour, or a system one. */
+function vmlColor(raw) {
+	if (!raw) return void 0;
+	const v = raw.trim().replace(/^#/u, "").split(" ")[0] ?? "";
+	if (/^[0-9A-Fa-f]{6}$/u.test(v)) return v.toUpperCase();
+	if (/^[0-9A-Fa-f]{3}$/u.test(v)) return [...v].map((c) => c + c).join("").toUpperCase();
+	return VML_NAMED_COLORS[v.toLowerCase()];
+}
+var VML_NAMED_COLORS = {
+	black: "000000",
+	silver: "C0C0C0",
+	gray: "808080",
+	grey: "808080",
+	white: "FFFFFF",
+	maroon: "800000",
+	red: "FF0000",
+	purple: "800080",
+	fuchsia: "FF00FF",
+	green: "008000",
+	lime: "00FF00",
+	olive: "808000",
+	yellow: "FFFF00",
+	navy: "000080",
+	blue: "0000FF",
+	teal: "008080",
+	aqua: "00FFFF",
+	window: "FFFFFF",
+	windowtext: "000000"
+};
+/**
+* §14.1.2.5 — `@filled="f"` or a `<v:fill type="none">` says the shape is not
+* filled; otherwise `@fillcolor`, defaulting to VML's own white. Exported
+* because §17.2.1's page background is a `v:background` with exactly this fill
+* on it — the same gradients and the same pictures.
+*
+* @param shape       The VML element carrying the fill.
+* @param shapeType   Its `v:shapetype`, for the attributes it does not state.
+* @param resolveImage Resolver for a `v:fill` that paints a PICTURE (`@r:id`).
+* @returns The fill.
+*/
+function vmlFill(shape, shapeType, resolveImage) {
+	const filled = poAttr(shape, "filled") ?? (shapeType ? poAttr(shapeType, "filled") : void 0);
+	if (filled === "f" || filled === "false") return { kind: "none" };
+	const fillEl = poChildren(shape).find((c) => poIs(c, "v:fill"));
+	if (fillEl && (poAttr(fillEl, "type") === "none" || poAttr(fillEl, "on") === "f")) return { kind: "none" };
+	const base = vmlColor(poAttr(shape, "fillcolor")) ?? (fillEl ? vmlColor(poAttr(fillEl, "color")) : void 0) ?? vmlColor(shapeType ? poAttr(shapeType, "fillcolor") : void 0) ?? "FFFFFF";
+	const fillRelId = fillEl && poAttr(fillEl, "type") === "frame" ? poAttr(fillEl, "r:id") : void 0;
+	const picture = fillRelId !== void 0 ? resolveImage?.(fillRelId) : void 0;
+	if (picture !== void 0) return {
+		kind: "picture",
+		imageResource: picture
+	};
+	const gradient = fillEl ? vmlGradient(fillEl, base) : void 0;
+	if (gradient) return {
+		kind: "gradient",
+		gradient
+	};
+	return {
+		kind: "solid",
+		colorHex: base
+	};
+}
+function vmlGradient(fillEl, base) {
+	const type = poAttr(fillEl, "type");
+	if (type !== "gradient" && type !== "gradientRadial") return void 0;
+	const color2 = vmlColor(poAttr(fillEl, "color2"));
+	if (color2 === void 0) return void 0;
+	const raw = Number.parseFloat(poAttr(fillEl, "angle") ?? "");
+	const angle = (90 + (Number.isFinite(raw) ? raw : 0)) % 360;
+	const center = type === "gradientRadial" ? vmlRadialCenter(raw, poAttr(fillEl, "focus")) : void 0;
+	return {
+		kind: type === "gradientRadial" ? "radial" : "linear",
+		...type === "gradientRadial" ? { sweep: "rect" } : { angle },
+		...center ? { center } : {},
+		stops: vmlStops(poAttr(fillEl, "colors")) ?? vmlFocusStops(poAttr(fillEl, "focus"), base, color2)
+	};
+}
+function vmlRadialCenter(angleRaw, focus) {
+	const pct = Number.parseFloat((focus ?? "").replace("%", ""));
+	if (!Number.isFinite(pct) || Math.abs(pct) < 99) return void 0;
+	const rad = (Number.isFinite(angleRaw) ? angleRaw : 0) * Math.PI / 180;
+	const dx = Math.sin(rad);
+	const dy = Math.cos(rad);
+	const snap = (v) => v > .5 ? 1 : v < -.5 ? 0 : .5;
+	return {
+		x: snap(dx),
+		y: snap(dy)
+	};
+}
+function vmlFocusStops(raw, base, color2) {
+	const pct = Number.parseFloat((raw ?? "").replace("%", ""));
+	const f = Number.isFinite(pct) ? Math.abs(pct) / 100 : 0;
+	if (f <= .01 || f >= .99) return [{
+		offset: 0,
+		colorHex: base
+	}, {
+		offset: 1,
+		colorHex: color2
+	}];
+	return [
+		{
+			offset: 0,
+			colorHex: base
+		},
+		{
+			offset: f,
+			colorHex: color2
+		},
+		{
+			offset: 1,
+			colorHex: base
+		}
+	];
+}
+function vmlStops(raw) {
+	if (raw === void 0 || raw.trim() === "") return void 0;
+	const stops = [];
+	for (const part of raw.split(";")) {
+		const [posRaw, colorRaw] = part.trim().split(/\s+/u);
+		const colorHex = vmlColor(colorRaw);
+		if (posRaw === void 0 || colorHex === void 0) continue;
+		const pct = posRaw.endsWith("%");
+		const n = Number.parseFloat(pct ? posRaw.slice(0, -1) : posRaw.replace(/f$/iu, ""));
+		if (!Number.isFinite(n)) continue;
+		const offset = pct ? n / 100 : n > 1 ? n / 65536 : n;
+		stops.push({
+			offset: Math.min(1, Math.max(0, offset)),
+			colorHex
+		});
+	}
+	if (stops.length < 2) return void 0;
+	return stops.sort((a, b) => a.offset - b.offset);
+}
+function vmlLine(shape, shapeType) {
+	const stroked = poAttr(shape, "stroked") ?? (shapeType ? poAttr(shapeType, "stroked") : void 0);
+	if (stroked === "f" || stroked === "false") return void 0;
+	const strokeEl = poChildren(shape).find((c) => poIs(c, "v:stroke"));
+	if (strokeEl && poAttr(strokeEl, "on") === "f") return void 0;
+	const colorHex = vmlColor(poAttr(shape, "strokecolor")) ?? (strokeEl ? vmlColor(poAttr(strokeEl, "color")) : void 0) ?? "000000";
+	const arrow = (kind) => {
+		const type = VML_ARROWS.get(poAttr(strokeEl, `${kind}arrow`) ?? "");
+		if (type === void 0) return void 0;
+		const w = VML_ARROW_SIZES.get(poAttr(strokeEl, `${kind}arrowwidth`) ?? "");
+		const len = VML_ARROW_SIZES.get(poAttr(strokeEl, `${kind}arrowlength`) ?? "");
+		return {
+			type,
+			...w ? { width: w } : {},
+			...len ? { length: len } : {}
+		};
+	};
+	const headEnd = arrow("start");
+	const tailEnd = arrow("end");
+	const weight = poAttr(shape, "strokeweight");
+	const m = weight ? /(-?[0-9.]+)\s*(pt|in|px|cm|mm|pc)?/iu.exec(weight) : null;
+	const widthPt = m ? Number.parseFloat(m[1]) * (VML_UNIT_TO_PT[(m[2] ?? "px").toLowerCase()] ?? 1) : .75;
+	return {
+		fill: "solid",
+		colorHex,
+		width: pt(Number.isFinite(widthPt) ? widthPt : .75),
+		...headEnd ? { headEnd } : {},
+		...tailEnd ? { tailEnd } : {}
+	};
+}
+var VML_ARROWS = new Map([
+	["block", "triangle"],
+	["classic", "stealth"],
+	["diamond", "diamond"],
+	["oval", "oval"],
+	["open", "arrow"]
+]);
+var VML_ARROW_SIZES = new Map([
+	["narrow", "sm"],
+	["short", "sm"],
+	["medium", "med"],
+	["wide", "lg"],
+	["long", "lg"]
+]);
+function vmlWordArtBody(shape, width, height) {
+	const textpath = poChildren(shape).find((c) => poIs(c, "v:textpath"));
+	const string = textpath ? poAttr(textpath, "string") : void 0;
+	if (string === void 0 || string === "") return void 0;
+	const fill = poAttr(shape, "fillcolor");
+	const colorHex = fill && /^#?[0-9A-Fa-f]{6}$/u.test(fill) ? fill.replace("#", "").toUpperCase() : void 0;
+	const lines = string.split(/\r\n|[\r\n]/u);
+	const fontSizePt = pt(Math.max(1, height / lines.length));
+	return {
+		content: lines.map((line) => ({
+			kind: "paragraph",
+			paragraph: {
+				properties: {
+					alignment: "center",
+					spacingBefore: pt(0),
+					spacingAfter: pt(0),
+					spacingLine: pt(12),
+					spacingLineRule: "auto"
+				},
+				runs: [{
+					text: line,
+					properties: {
+						fontSizePt,
+						bold: true,
+						...colorHex ? { colorHex } : {}
+					}
+				}]
+			}
+		})),
+		anchor: "ctr",
+		fitToBox: true,
+		insetLeft: pt(0),
+		insetRight: pt(0),
+		insetTop: pt(0),
+		insetBottom: pt(0)
+	};
+}
+function vmlTextBox(shape, parseBody) {
+	const box = poChildren(shape).find((c) => poIs(c, "v:textbox"));
+	const content = box ? poFindDescendant(box, "w:txbxContent") : void 0;
+	if (!content) return void 0;
+	const blocks = parseBody(poChildren(content));
+	return blocks.length > 0 ? { content: blocks } : void 0;
+}
+/**
+* The `@style` of a positioned VML shape as a float anchor: `position:absolute`
+* with `margin-left`/`margin-top` (or `left`/`top`) against whatever
+* `mso-position-*-relative` names.
+*
+* @param style  The shape's `@style`.
+* @param zIndex The shape's z-index, when it has one.
+* @returns The anchor, or `undefined` for an inline shape.
+*/
+function vmlWrap(shape) {
+	const w = shape ? poChildren(shape).find((c) => poIsLocal(c, "wrap")) : void 0;
+	if (!w) return "none";
+	const type = poAttr(w, "type");
+	if (type === "topAndBottom") return "topAndBottom";
+	if (type === "none") return "none";
+	return "square";
+}
+function vmlFloat(style, zIndexAttr, shape) {
+	if (!/position\s*:\s*absolute/iu.test(style)) return void 0;
+	const prop = (name) => {
+		const m = new RegExp(`(?:^|;)\\s*${name}\\s*:\\s*(-?[0-9.]+)(pt|in|px|cm|mm|pc)?`, "iu").exec(style);
+		if (!m) return void 0;
+		const v = Number.parseFloat(m[1]) * (VML_UNIT_TO_PT[(m[2] ?? "px").toLowerCase()] ?? 1);
+		return Number.isFinite(v) ? v : void 0;
+	};
+	const rel = (name) => new RegExp(`mso-position-${name}-relative\\s*:\\s*([a-z-]+)`, "iu").exec(style)?.[1];
+	const hRaw = rel("horizontal");
+	const vRaw = rel("vertical");
+	const align = /mso-position-horizontal\s*:\s*(center|right|left)/iu.exec(style)?.[1];
+	const vAlign = /mso-position-vertical\s*:\s*(center|top|bottom)/iu.exec(style)?.[1];
+	const x = prop("margin-left") ?? prop("left") ?? 0;
+	const y = prop("margin-top") ?? prop("top") ?? 0;
+	const zIndex = prop("z-index") ?? zIndexAttr;
+	return {
+		wrap: vmlWrap(shape),
+		...zIndex !== void 0 && zIndex < 0 ? { behind: true } : {},
+		...zIndex !== void 0 ? { zOrder: Math.abs(zIndex) } : {},
+		posH: {
+			relativeFrom: hRaw === "page" ? "page" : hRaw === "margin" ? "margin" : "column",
+			...align ? { align } : { offsetPt: pt(x) }
+		},
+		posV: {
+			relativeFrom: vRaw === "page" ? "page" : vRaw === "margin" ? "margin" : vRaw === "line" ? "line" : "paragraph",
+			...vAlign ? { align: vAlign } : {},
+			offsetPt: pt(y)
+		}
+	};
+}
+/**
+* §14.1.2.22 `v:textpath` — legacy WordArt: text bent along a preset path, whose
+* STRING lives in an attribute rather than in the document body. The path is a
+* `v:shapetype` of formulas we do not evaluate, so the words are set flat in
+* the shape's box — which is the whole of what the page says. Read nowhere,
+* WordArt.docx printed an empty page.
+*
+* @param node The `w:pict` / `w:object` node.
+* @returns The shape, or `null` when there is no textpath or no usable size.
+*/
+function parseVmlWordArt(node) {
+	const shape = poFindDescendant(node, "v:shape");
+	const textpath = shape ? poFindDescendant(shape, "v:textpath") : void 0;
+	const string = textpath ? poAttr(textpath, "string") : void 0;
+	if (string === void 0 || string === "") return null;
+	const width = vmlStyleLength(shape, "width");
+	const height = vmlStyleLength(shape, "height");
+	if (width === void 0 || height === void 0) return null;
+	const fill = poAttr(shape, "fillcolor");
+	const colorHex = fill && /^#?[0-9A-Fa-f]{6}$/u.test(fill) ? fill.replace("#", "").toUpperCase() : void 0;
+	const lines = string.split(/\r\n|[\r\n]/u);
+	const fontSizePt = pt(Math.max(1, height / lines.length));
+	return {
+		kind: "shape",
+		data: {
+			width,
+			height,
+			geometry: {
+				kind: "preset",
+				preset: "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill: { kind: "none" },
+			text: {
+				content: lines.map((line) => ({
+					kind: "paragraph",
+					paragraph: {
+						properties: {
+							alignment: "center",
+							spacingBefore: pt(0),
+							spacingAfter: pt(0),
+							spacingLine: pt(12),
+							spacingLineRule: "auto"
+						},
+						runs: [{
+							text: line,
+							properties: {
+								fontSizePt,
+								bold: true,
+								...colorHex ? { colorHex } : {}
+							}
+						}]
+					}
+				})),
+				anchor: "ctr",
+				fitToBox: true,
+				insetLeft: pt(0),
+				insetRight: pt(0),
+				insetTop: pt(0),
+				insetBottom: pt(0)
+			}
+		},
+		...poAttr(shape, "alt")?.trim() ? { altText: poAttr(shape, "alt").trim() } : {}
+	};
+}
 var VML_UNIT_TO_PT = {
 	pt: 1,
 	in: 72,
@@ -204,10 +1115,276 @@ function vmlStyleLength(shape, prop) {
 	if (!Number.isFinite(value) || value <= 0) return void 0;
 	return pt(value * (VML_UNIT_TO_PT[(m[2] ?? "px").toLowerCase()] ?? 1));
 }
-function parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody) {
+/**
+* §20.1.8.55 `a:srcRect` — the picture's own edges, cut away before it is
+* fitted to its frame. Each is a percentage in thousandths (ST_Percentage), so
+* `l="14711"` drops the left 14.711%.
+*
+* @param node The `a:srcRect` element, or `undefined` when the fill declares none.
+* @returns The crop, or `undefined` when nothing is cut away.
+*/
+function parseSrcRect(node) {
+	if (!node) return void 0;
+	const edge = (name) => {
+		const v = Number(poAttr(node, name));
+		return Number.isFinite(v) && v > 0 ? v / 1e5 : 0;
+	};
+	const crop = {
+		left: edge("l"),
+		top: edge("t"),
+		right: edge("r"),
+		bottom: edge("b")
+	};
+	if (crop.left + crop.top + crop.right + crop.bottom === 0) return void 0;
+	if (crop.left + crop.right >= 1 || crop.top + crop.bottom >= 1) return void 0;
+	return crop;
+}
+/**
+* §20.5.2.17 `wpg:wgp` — a drawing group: a box holding shapes of its own, in
+* its own coordinate space. `a:xfrm` gives the box (`a:off`/`a:ext`) and the
+* space its members are written in (`a:chOff`/`a:chExt`); a member at (x, y) in
+* that space lands at `off + (x − chOff) · ext / chExt` in the group's.
+*
+* The group draws nothing itself. Left unread, Tdf147485.docx — whose whole
+* picture is one — printed an empty page: the `mc:Fallback` beside the group is
+* VML, a geometry language of its own that we do not read either.
+*
+* @returns The group as a shape with children, or `null` when it states no size.
+*/
+/**
+* §20.3 — a `lc:lockedCanvas`: the same content model as a group, so it lays
+* out as one. Its own `a:grpSpPr/a:xfrm` states the child coordinate space the
+* members are placed in; the drawing's `wp:extent` states the box that space
+* is drawn into.
+*/
+function parseLockedCanvas(graphicData, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText) {
+	const canvas = expandMcChildren(poChildren(graphicData)).find((c) => poIsLocal(c, "lockedCanvas"));
+	if (!canvas) return null;
+	const raw = groupChildren(canvas, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+	if (extentCx === void 0 || extentCy === void 0) return null;
+	const space = canvasChildSpace(canvas);
+	let children;
+	if (space) {
+		const sx = emuToPt(extentCx) / space.w;
+		const sy = emuToPt(extentCy) / space.h;
+		children = raw.map((c) => ({
+			shape: {
+				...c.shape,
+				width: pt(c.shape.width * sx),
+				height: pt(c.shape.height * sy)
+			},
+			xPt: pt((c.xPt - space.x) * sx),
+			yPt: pt((c.yPt - space.y) * sy)
+		}));
+	} else {
+		const origin = contentOrigin(raw);
+		children = raw.map((c) => ({
+			...c,
+			xPt: pt(c.xPt - origin.x),
+			yPt: pt(c.yPt - origin.y)
+		}));
+	}
+	return {
+		width: emuToPt(extentCx),
+		height: emuToPt(extentCy),
+		...children.length > 0 ? { children } : {},
+		geometry: {
+			kind: "custom",
+			custom: EMPTY_GEOMETRY
+		},
+		fill: { kind: "none" }
+	};
+}
+function canvasChildSpace(canvas) {
+	const grpSpPr = poChildren(canvas).find((c) => poIsLocal(c, "grpSpPr"));
+	const xfrm = grpSpPr ? poChildren(grpSpPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+	const chOff = xfrm ? poChildren(xfrm).find((c) => poIs(c, "a:chOff")) : void 0;
+	const chExt = xfrm ? poChildren(xfrm).find((c) => poIs(c, "a:chExt")) : void 0;
+	const cx = chExt ? poIntAttr(chExt, "cx") : void 0;
+	const cy = chExt ? poIntAttr(chExt, "cy") : void 0;
+	if (cx === void 0 || cy === void 0 || cx <= 0 || cy <= 0) return void 0;
+	return {
+		x: emuToPt((chOff ? poIntAttr(chOff, "x") : void 0) ?? 0),
+		y: emuToPt((chOff ? poIntAttr(chOff, "y") : void 0) ?? 0),
+		w: emuToPt(cx),
+		h: emuToPt(cy)
+	};
+}
+function parseWgp(graphicData, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText) {
+	const wgp = expandMcChildren(poChildren(graphicData)).find((c) => poIs(c, "wpg:wgp"));
+	if (!wgp) return null;
+	const children = groupChildren(wgp, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+	const grpSpPr = poChildren(wgp).find((c) => poIs(c, "wpg:grpSpPr"));
+	const ext = grpSpPr ? poChildren(poChildren(grpSpPr).find((c) => poIs(c, "a:xfrm")) ?? grpSpPr).find((c) => poIs(c, "a:ext")) : void 0;
+	const widthEmu = extentCx ?? (ext ? poIntAttr(ext, "cx") : void 0);
+	const heightEmu = extentCy ?? (ext ? poIntAttr(ext, "cy") : void 0);
+	if (widthEmu === void 0 || heightEmu === void 0) return null;
+	return {
+		width: emuToPt(widthEmu),
+		height: emuToPt(heightEmu),
+		...children.length > 0 ? { children } : {},
+		geometry: {
+			kind: "custom",
+			custom: EMPTY_GEOMETRY
+		},
+		fill: { kind: "none" }
+	};
+}
+function groupChildren(wgp, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText, unitScale = {
+	x: 1,
+	y: 1
+}) {
+	const grpSpPr = poChildren(wgp).find((c) => poIsLocal(c, "grpSpPr"));
+	const xfrm = grpSpPr ? poChildren(grpSpPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+	const at = (tag, ax, ay) => {
+		const n = xfrm ? poChildren(xfrm).find((c) => poIs(c, tag)) : void 0;
+		const x = n ? poIntAttr(n, ax) : void 0;
+		const y = n ? poIntAttr(n, ay) : void 0;
+		return x !== void 0 && y !== void 0 ? {
+			x,
+			y
+		} : void 0;
+	};
+	const ext = at("a:ext", "cx", "cy");
+	const chExt = at("a:chExt", "cx", "cy");
+	const sx = (ext && chExt && chExt.x > 0 ? ext.x / chExt.x : 1) * unitScale.x;
+	const sy = (ext && chExt && chExt.y > 0 ? ext.y / chExt.y : 1) * unitScale.y;
+	const declared = at("a:chOff", "x", "y");
+	const chOff = xfrm !== void 0 && (!chExt || chExt.x <= 0 || chExt.y <= 0) ? memberOrigin(wgp, declared ?? {
+		x: 0,
+		y: 0
+	}) : declared ?? {
+		x: 0,
+		y: 0
+	};
+	const out = [];
+	for (const child of expandMcChildren(poChildren(wgp))) {
+		const nested = poIsLocal(child, "grpSp");
+		const picture = poIsLocal(child, "pic");
+		if (!isGroupMember(child)) continue;
+		const spPr = poChildren(child).find((c) => poIsLocal(c, nested ? "grpSpPr" : "spPr"));
+		const childXfrm = spPr ? poChildren(spPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+		const cOff = childXfrm ? poChildren(childXfrm).find((c) => poIs(c, "a:off")) : void 0;
+		const cExt = childXfrm ? poChildren(childXfrm).find((c) => poIs(c, "a:ext")) : void 0;
+		const cx = cExt ? poIntAttr(cExt, "cx") : void 0;
+		const cy = cExt ? poIntAttr(cExt, "cy") : void 0;
+		if (cx === void 0 || cy === void 0) continue;
+		const data = nested ? parseNestedGroup(child, cx * sx, cy * sy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText, {
+			x: sx,
+			y: sy
+		}) : picture ? parseGroupPicture(child, cx, cy, resolveImage) : parseWspNode(child, cx, cy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText);
+		if (!data) continue;
+		const x = (poIntAttr(cOff, "x") ?? 0) - chOff.x;
+		const y = (poIntAttr(cOff, "y") ?? 0) - chOff.y;
+		out.push({
+			shape: {
+				...data,
+				width: emuToPt(cx * sx),
+				height: emuToPt(cy * sy),
+				paragraphProperties: {}
+			},
+			xPt: emuToPt(x * sx),
+			yPt: emuToPt(y * sy)
+		});
+	}
+	return out;
+}
+/**
+* The top-left corner the drawn content actually occupies, in the group's own
+* coordinates — nested members counted at their absolute position.
+*
+* @param children The group's members.
+* @returns The minimum x/y over the whole tree (0,0 when it is empty).
+*/
+function contentOrigin(children) {
+	let minX = Infinity;
+	let minY = Infinity;
+	const walk = (list, ox, oy) => {
+		for (const c of list) {
+			const x = ox + c.xPt;
+			const y = oy + c.yPt;
+			if (c.shape.children && c.shape.children.length > 0) {
+				walk(c.shape.children, x, y);
+				continue;
+			}
+			if (x < minX) minX = x;
+			if (y < minY) minY = y;
+		}
+	};
+	walk(children, 0, 0);
+	return {
+		x: Number.isFinite(minX) ? minX : 0,
+		y: Number.isFinite(minY) ? minY : 0
+	};
+}
+/** A node that is a group MEMBER: a shape, a connector, a picture, or a nested group. */
+function isGroupMember(node) {
+	return poIsLocal(node, "wsp") || poIsLocal(node, "sp") || poIsLocal(node, "cxnSp") || poIsLocal(node, "grpSp") || poIsLocal(node, "pic");
+}
+/**
+* The top-left corner of a group's members, in the child coordinate space —
+* the origin to use when the group declares no child space of its own.
+*
+* @param wgp      The group / canvas node.
+* @param fallback What to return when no member states an offset.
+* @returns The minimum `a:off` over the members.
+*/
+function memberOrigin(wgp, fallback) {
+	let minX = Infinity;
+	let minY = Infinity;
+	for (const child of expandMcChildren(poChildren(wgp))) {
+		if (!isGroupMember(child)) continue;
+		const xfrm = poChildren(poChildren(child).find((c) => poIsLocal(c, "spPr") || poIsLocal(c, "grpSpPr"))).find((c) => poIs(c, "a:xfrm"));
+		const off = xfrm ? poChildren(xfrm).find((c) => poIs(c, "a:off")) : void 0;
+		const x = poIntAttr(off, "x");
+		const y = poIntAttr(off, "y");
+		if (x !== void 0 && x < minX) minX = x;
+		if (y !== void 0 && y < minY) minY = y;
+	}
+	return {
+		x: Number.isFinite(minX) ? minX : fallback.x,
+		y: Number.isFinite(minY) ? minY : fallback.y
+	};
+}
+function parseNestedGroup(grpSp, widthEmu, heightEmu, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText, unitScale) {
+	const children = groupChildren(grpSp, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText, unitScale);
+	return {
+		width: emuToPt(widthEmu),
+		height: emuToPt(heightEmu),
+		...children.length > 0 ? { children } : {},
+		geometry: {
+			kind: "custom",
+			custom: EMPTY_GEOMETRY
+		},
+		fill: { kind: "none" }
+	};
+}
+function parseGroupPicture(pic, widthEmu, heightEmu, resolveImage) {
+	const blip = poFindDescendant(pic, "a:blip");
+	const relId = blip ? poAttr(blip, "embed") : void 0;
+	const resource = relId !== void 0 ? resolveImage?.(relId) : void 0;
+	if (resource === void 0) return null;
+	return {
+		width: emuToPt(widthEmu),
+		height: emuToPt(heightEmu),
+		geometry: {
+			kind: "preset",
+			preset: "rect",
+			adjust: /* @__PURE__ */ new Map()
+		},
+		fill: {
+			kind: "picture",
+			imageResource: resource
+		}
+	};
+}
+function parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText) {
 	const wsp = expandMcChildren(poChildren(graphicData)).find((c) => poIs(c, "wps:wsp"));
 	if (!wsp) return null;
-	const spPr = poChildren(wsp).find((c) => poIs(c, "wps:spPr"));
+	return parseWspNode(wsp, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles);
+}
+function parseWspNode(wsp, extentCx, extentCy, resolveColor, parseBody, resolveImage, themeLineWidths, themeStyles, parseDrawingText) {
+	const spPr = poChildren(wsp).find((c) => poIsLocal(c, "spPr"));
 	let geometry = {
 		kind: "preset",
 		preset: "rect",
@@ -234,10 +1411,24 @@ function parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody) {
 		const cust = poChildren(spPr).find((c) => poIs(c, "a:custGeom"));
 		if (prst) geometry = parsePrstGeom(prst);
 		else if (cust) geometry = parseCustGeom(cust);
-		fill = parseFill(spPr, resolveColor);
+		fill = parseFill(spPr, resolveColor, resolveImage);
 		line = parseLine(spPr, resolveColor);
 	}
-	const text = parseBody ? parseTextBox(wsp, parseBody) : void 0;
+	const txSp = poChildren(wsp).find((c) => poIs(c, "a:txSp"));
+	const txBody = poChildren(wsp).find((c) => poIs(c, "a:txBody")) ?? (txSp ? poChildren(txSp).find((c) => poIs(c, "a:txBody")) : void 0);
+	const text = (parseBody ? parseTextBox(wsp, parseBody) : void 0) ?? (txBody && parseDrawingText ? parseDrawingText(txBody, resolveColor) : void 0);
+	const style = poChildren(wsp).find((c) => poIsLocal(c, "style"));
+	if (style && fill.kind === "none" && !statesFill(spPr)) fill = styleRefFill(style, resolveColor, themeStyles);
+	const styleLine = style ? styleRefLine(style, resolveColor, themeLineWidths) : void 0;
+	if (styleLine) {
+		const own = line;
+		line = own ? {
+			...styleLine,
+			...Object.fromEntries(Object.entries(own).filter(([, v]) => v !== void 0))
+		} : styleLine;
+	}
+	const styled = style && text ? withStyleFontColor(text, style, resolveColor) : text;
+	const shadow = (spPr ? parseShadow(spPr, resolveColor) : void 0) ?? (style ? styleRefShadow(style, resolveColor, themeStyles?.effects) : void 0);
 	if (widthEmu === void 0 || heightEmu === void 0) return null;
 	return {
 		width: emuToPt(widthEmu),
@@ -245,8 +1436,96 @@ function parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody) {
 		geometry,
 		fill,
 		...line ? { line } : {},
+		...shadow ? { shadow } : {},
 		...transform ? { transform } : {},
-		...text ? { text } : {}
+		...styled ? { text: styled } : {}
+	};
+}
+/**
+* §20.1.4.2.8 `<a:effectRef>` — the shadow a gallery style names: a 1-based
+* index into the theme's `a:effectStyleLst`, plus the colour to put wherever
+* that style says `phClr`. The same mechanism as the fill and the outline
+* beside it.
+*
+* @param style             The shape's `<wps:style>` node.
+* @param resolveColor      The document's colour resolver.
+* @param themeEffectStyles The theme's effect styles, in list order.
+* @returns The shadow, or undefined when the style names none.
+*/
+function styleRefShadow(style, resolveColor, themeEffectStyles) {
+	const ref = poChildren(style).find((c) => poIs(c, "a:effectRef"));
+	const idx = ref ? Number(poAttr(ref, "idx") ?? "") : NaN;
+	if (!ref || !Number.isFinite(idx) || idx < 1) return void 0;
+	const slot = themeEffectStyles?.[idx - 1];
+	const list = slot ? poChildren(slot).find((c) => poIs(c, "a:effectLst")) : void 0;
+	const shdw = list ? poChildren(list).find((c) => poIs(c, "a:outerShdw")) : void 0;
+	if (!shdw) return void 0;
+	const child = firstElementChild(ref);
+	const phHex = child ? resolveColorNode(child, resolveColor) : void 0;
+	return shadowFromOuterShdw(shdw, phHex ? placeholderColors(resolveColor, phHex) : resolveColor);
+}
+function placeholderColors(base, phHex) {
+	return (raw) => "scheme" in raw && raw.scheme === "phClr" ? applyColorMods(phHex, raw.mods ?? []) : base(raw);
+}
+var FILL_TAGS = new Set([
+	"a:noFill",
+	"a:solidFill",
+	"a:gradFill",
+	"a:blipFill",
+	"a:pattFill",
+	"a:grpFill"
+]);
+function statesFill(spPr) {
+	return spPr !== void 0 && poChildren(spPr).some((c) => FILL_TAGS.has(poTag(c) ?? ""));
+}
+function styleRefFill(style, resolveColor, themeStyles) {
+	const ref = poChildren(style).find((c) => poIs(c, "a:fillRef"));
+	if (!ref || poAttr(ref, "idx") === "0") return { kind: "none" };
+	const child = firstElementChild(ref);
+	const colorHex = child ? resolveColorNode(child, resolveColor) : void 0;
+	const idx = Number(poAttr(ref, "idx") ?? "");
+	const slot = Number.isFinite(idx) && idx >= 1001 ? themeStyles?.bgFills?.[idx - 1001] : Number.isFinite(idx) && idx >= 1 ? themeStyles?.fills?.[idx - 1] : void 0;
+	if (slot) {
+		const fill = fillFromNode(slot, colorHex ? placeholderColors(resolveColor, colorHex) : resolveColor);
+		if (fill) return fill;
+	}
+	return colorHex === void 0 ? { kind: "none" } : {
+		kind: "solid",
+		colorHex
+	};
+}
+function styleRefLine(style, resolveColor, themeLineWidths) {
+	const ref = poChildren(style).find((c) => poIs(c, "a:lnRef"));
+	if (!ref || poAttr(ref, "idx") === "0") return void 0;
+	const child = firstElementChild(ref);
+	const colorHex = child ? resolveColorNode(child, resolveColor) : void 0;
+	if (colorHex === void 0) return void 0;
+	const idx = poIntAttr(ref, "idx");
+	return {
+		fill: "solid",
+		colorHex,
+		width: pt((idx !== void 0 && idx > 0 ? themeLineWidths?.[idx - 1] : void 0) ?? .75)
+	};
+}
+function withStyleFontColor(text, style, resolveColor) {
+	const child = firstElementChild(poChildren(style).find((c) => poIs(c, "a:fontRef")));
+	const colorHex = child ? resolveColorNode(child, resolveColor) : void 0;
+	if (colorHex === void 0) return text;
+	return {
+		...text,
+		content: text.content.map((block) => block.kind === "paragraph" ? {
+			...block,
+			paragraph: {
+				...block.paragraph,
+				properties: {
+					...block.paragraph.properties,
+					inheritedRun: {
+						...block.paragraph.properties.inheritedRun,
+						colorHex
+					}
+				}
+			}
+		} : block)
 	};
 }
 function parseTextBox(wsp, parseBody) {
@@ -263,8 +1542,13 @@ function parseTextBox(wsp, parseBody) {
 	const bIns = bodyPr ? poIntAttr(bodyPr, "bIns") : void 0;
 	const a = bodyPr ? poAttr(bodyPr, "anchor") : void 0;
 	const anchor = a === "ctr" ? "ctr" : a === "b" ? "b" : a === "t" ? "t" : void 0;
+	const v = bodyPr ? poAttr(bodyPr, "vert") : void 0;
+	const vertical = v === "vert270" ? "vert270" : v !== void 0 && v !== "horz" ? "vert" : void 0;
+	const autoFit = bodyPr !== void 0 && poChildren(bodyPr).some((c) => poIs(c, "a:spAutoFit"));
 	return {
 		content,
+		...vertical ? { vertical } : {},
+		...autoFit ? { autoFit: true } : {},
 		...lIns !== void 0 ? { insetLeft: emuToPt(lIns) } : {},
 		...tIns !== void 0 ? { insetTop: emuToPt(tIns) } : {},
 		...rIns !== void 0 ? { insetRight: emuToPt(rIns) } : {},
@@ -273,6 +1557,16 @@ function parseTextBox(wsp, parseBody) {
 	};
 }
 var isTrue = (v) => v === "1" || v === "true" || v === "on";
+/**
+* §20.1.7.6 `a:xfrm` — how a shape sits in its box: rotated about its centre by
+* `@rot` (sixtieth-thousandths of a degree) and mirrored by `@flipH`/`@flipV`.
+* The box itself comes from elsewhere — the anchor on a sheet, the extent in a
+* document — and holds the shape UNROTATED, which is what makes this a separate
+* transform rather than a different rectangle.
+*
+* @param xfrm The `a:xfrm` element.
+* @returns The transform; empty when it states neither rotation nor a flip.
+*/
 function parseXfrm(xfrm) {
 	const rot = poIntAttr(xfrm, "rot");
 	const flipH = isTrue(poAttr(xfrm, "flipH"));
@@ -415,27 +1709,174 @@ var firstPt = (node) => pts(node)[0];
 * @param spPr         The `wps:spPr` node.
 * @param resolveColor Resolver for theme/scheme colours.
 */
-function parseFill(spPr, resolveColor) {
+function parseFill(spPr, resolveColor, resolveImage) {
 	for (const child of poChildren(spPr)) {
-		if (poIs(child, "a:noFill")) return { kind: "none" };
-		if (poIs(child, "a:solidFill")) {
-			const hex = colorFromContainer(child, resolveColor);
-			return hex ? {
-				kind: "solid",
-				colorHex: hex
-			} : { kind: "none" };
-		}
-		if (poIs(child, "a:gradFill")) {
-			const gradient = parseGradient(child, resolveColor);
-			return gradient ? {
-				kind: "gradient",
-				gradient
-			} : { kind: "none" };
-		}
+		const own = fillFromNode(child, resolveColor, resolveImage);
+		if (own) return own;
 	}
 	return { kind: "none" };
 }
 /**
+* One fill ELEMENT — `a:noFill` / `a:solidFill` / `a:gradFill` / `a:blipFill` —
+* as a {@link ShapeFill}. The same reader serves a shape's own `a:spPr` and the
+* theme slot a `<a:fillRef>` names, which is a fill in its own right.
+*
+* @param child        The candidate node (anything else returns undefined).
+* @param resolveColor The colour resolver (with `phClr` bound, for a theme slot).
+* @param resolveImage Resolver for a picture fill's relationship.
+* @returns The fill, or undefined when the node is not one.
+*/
+function fillFromNode(child, resolveColor, resolveImage) {
+	if (poIs(child, "a:noFill")) return { kind: "none" };
+	if (poIs(child, "a:blipFill")) {
+		const blip = poFindDescendant(child, "a:blip");
+		const relId = blip ? poAttr(blip, "embed") : void 0;
+		const resource = relId !== void 0 ? resolveImage?.(relId) : void 0;
+		if (resource === void 0) return { kind: "none" };
+		const crop = parseSrcRect(poFindDescendant(child, "a:srcRect")) ?? fillRectCrop(child);
+		return {
+			kind: "picture",
+			imageResource: resource,
+			...crop ? { imageCrop: crop } : {}
+		};
+	}
+	if (poIs(child, "a:solidFill")) {
+		const hex = colorFromContainer(child, resolveColor);
+		return hex ? {
+			kind: "solid",
+			colorHex: hex
+		} : { kind: "none" };
+	}
+	if (poIs(child, "a:pattFill")) {
+		const fg = poChildren(child).find((c) => poIs(c, "a:fgClr"));
+		const bg = poChildren(child).find((c) => poIs(c, "a:bgClr"));
+		const fgHex = fg ? colorFromContainer(fg, resolveColor) : void 0;
+		const bgHex = bg ? colorFromContainer(bg, resolveColor) : "FFFFFF";
+		if (!fgHex) return { kind: "none" };
+		return {
+			kind: "solid",
+			colorHex: blendHex(fgHex, bgHex ?? "FFFFFF", patternCoverage(poAttr(child, "prst")))
+		};
+	}
+	if (poIs(child, "a:gradFill")) {
+		const gradient = parseGradient(child, resolveColor);
+		return gradient ? {
+			kind: "gradient",
+			gradient
+		} : { kind: "none" };
+	}
+}
+/**
+* §20.1.8.37 — roughly how much of a tile the preset pattern inks, which is
+* what decides how strongly the foreground colour shows through. The families
+* carry the answer: `pctNN` states it outright, `lt*` is sparse, `dk*` dense,
+* and the woven ones cover about half.
+*
+* @param prst The `a:pattFill` `@prst` value.
+* @returns The ink coverage, 0..1.
+*/
+function patternCoverage(prst) {
+	if (!prst) return .25;
+	const pct = /^pct(\d+)$/u.exec(prst);
+	if (pct) return Math.min(1, Number(pct[1]) / 100);
+	if (prst.startsWith("lt")) return .15;
+	if (prst.startsWith("dk")) return .5;
+	if (prst.startsWith("wd")) return .2;
+	if (prst.startsWith("nar")) return .35;
+	if (prst.endsWith("Grid") || prst === "divot" || prst === "wave") return .15;
+	if (DENSE_PATTERNS.has(prst)) return .5;
+	return .25;
+}
+var DENSE_PATTERNS = new Set([
+	"trellis",
+	"weave",
+	"plaid",
+	"smCheck",
+	"lgCheck",
+	"solidDmnd",
+	"sphere",
+	"dkCross",
+	"dkDiagCross"
+]);
+/** `a` mixed over `b` at `t` (0 = all `b`, 1 = all `a`), as 6-hex. */
+function blendHex(a, b, t) {
+	const ch = (hex, i) => parseInt(hex.slice(i, i + 2), 16);
+	const mix = (i) => Math.round(ch(a, i) * t + ch(b, i) * (1 - t)).toString(16).padStart(2, "0");
+	return (mix(0) + mix(2) + mix(4)).toUpperCase();
+}
+/**
+* §20.1.8.30 `a:stretch/a:fillRect` — where the picture's edges land relative
+* to the shape's box, in 1000ths of a percent of that box. A NEGATIVE inset
+* pushes the edge outside the box, which is how a fill zooms in: what remains
+* inside is the part the box shows, so the insets convert straight to the crop
+* fractions of the SOURCE. crop-roundtrip.docx frames the middle of its photo
+* that way and we drew the whole of it.
+*
+* @param blipFill The `a:blipFill` node.
+* @returns The crop, or `undefined` when the fill states no `a:fillRect`.
+*/
+function fillRectCrop(blipFill) {
+	const stretch = poChildren(blipFill).find((c) => poIs(c, "a:stretch"));
+	const rect = stretch ? poChildren(stretch).find((c) => poIs(c, "a:fillRect")) : void 0;
+	if (!rect) return void 0;
+	const side = (name) => (poIntAttr(rect, name) ?? 0) / 1e5;
+	const l = side("l");
+	const t = side("t");
+	const r = side("r");
+	const b = side("b");
+	if (l === 0 && t === 0 && r === 0 && b === 0) return void 0;
+	const spanX = 1 - l - r;
+	const spanY = 1 - t - b;
+	if (spanX <= 0 || spanY <= 0) return void 0;
+	const clamp = (v) => Math.min(.99, Math.max(0, v));
+	return {
+		left: clamp(-l / spanX),
+		top: clamp(-t / spanY),
+		right: clamp(-r / spanX),
+		bottom: clamp(-b / spanY)
+	};
+}
+/**
+* Parse a shape's drop shadow from its `a:spPr` (§20.1.8.40 `a:effectLst` →
+* `a:outerShdw`).
+*
+* The spec states the displacement in polar form: `dist` in EMU and `dir` in
+* 60 000ths of a degree, measured clockwise from due east in a frame whose y
+* grows DOWNWARD — so the standard 2 700 000 (45°) puts the shadow down and to
+* the right, which is where every reader draws it.
+*
+* @param spPr         The shape's `spPr` node.
+* @param resolveColor Resolver for theme/scheme colours.
+* @returns The shadow, or undefined when the shape declares none.
+*/
+function parseShadow(spPr, resolveColor) {
+	const list = poChildren(spPr).find((c) => poIs(c, "a:effectLst"));
+	const shdw = list ? poChildren(list).find((c) => poIs(c, "a:outerShdw")) : void 0;
+	return shdw ? shadowFromOuterShdw(shdw, resolveColor) : void 0;
+}
+/**
+* Build a {@link ShapeShadow} from an `a:outerShdw` node.
+*
+* @param shdw         The `a:outerShdw` node.
+* @param resolveColor Resolver for theme/scheme colours.
+* @returns The shadow, or undefined when its colour will not resolve.
+*/
+function shadowFromOuterShdw(shdw, resolveColor) {
+	const colorNode = poChildren(shdw).find((c) => resolveColorNode(c, resolveColor) !== void 0);
+	const colorHex = colorNode ? resolveColorNode(colorNode, resolveColor) : void 0;
+	if (!colorHex) return void 0;
+	const alphaMod = colorNode ? readColorMods(colorNode).find((m) => m.kind === "alpha") : void 0;
+	const dist = emuToPt(poIntAttr(shdw, "dist") ?? 0);
+	const rad = (poIntAttr(shdw, "dir") ?? 0) / 6e4 * Math.PI / 180;
+	return {
+		dxPt: dist * Math.cos(rad),
+		dyPt: dist * Math.sin(rad),
+		blurPt: emuToPt(poIntAttr(shdw, "blurRad") ?? 0),
+		colorHex,
+		alpha: alphaMod ? alphaMod.val : 1
+	};
+}
+/**
 * Parse a shape's outline (`a:ln`) from its `a:spPr` into a {@link ShapeLine}:
 * width, cap, solid colour, dash pattern, and an explicit `a:noFill` (an unstroked
 * outline). Returns `undefined` when the shape has no `a:ln`.
@@ -452,17 +1893,94 @@ function parseLine(spPr, resolveColor) {
 	let noFill = false;
 	let colorHex;
 	let dash;
+	let customDash;
+	let headEnd;
+	let tailEnd;
 	for (const c of poChildren(ln)) if (poIs(c, "a:noFill")) noFill = true;
 	else if (poIs(c, "a:solidFill")) colorHex = colorFromContainer(c, resolveColor);
 	else if (poIs(c, "a:prstDash")) dash = normalizeDash(poAttr(c, "val"));
+	else if (poIs(c, "a:custDash")) customDash = parseCustDash(c);
+	else if (poIs(c, "a:headEnd")) headEnd = parseLineEnd(c);
+	else if (poIs(c, "a:tailEnd")) tailEnd = parseLineEnd(c);
 	return {
 		...widthEmu !== void 0 ? { width: emuToPt(widthEmu) } : {},
 		...colorHex ? { colorHex } : {},
 		...dash ? { dash } : {},
+		...customDash && customDash.length > 0 ? { customDash } : {},
 		...cap ? { cap } : {},
-		...noFill ? { fill: "none" } : {}
+		...noFill ? { fill: "none" } : {},
+		...headEnd ? { headEnd } : {},
+		...tailEnd ? { tailEnd } : {}
+	};
+}
+/**
+* A picture's frame from the line its `pic:spPr` (or its VML shape) states —
+* colour and width only, since a picture border is a rule around the box and
+* carries none of a shape outline's ends or joins.
+*
+* @param line The parsed line, or `undefined`.
+* @returns The outline, or `undefined` when the picture is drawn bare.
+*/
+function pictureOutline(line) {
+	const stroke = buildStroke(line);
+	if (!stroke || stroke.widthPt <= 0) return void 0;
+	return {
+		colorHex: stroke.colorHex,
+		widthPt: pt(stroke.widthPt)
 	};
 }
+var LINE_END_TYPES = new Set([
+	"triangle",
+	"stealth",
+	"diamond",
+	"oval",
+	"arrow"
+]);
+var LINE_END_SIZES = new Set([
+	"sm",
+	"med",
+	"lg"
+]);
+/**
+* §20.1.8.24 / §20.1.8.42 — one end decoration: `@type` plus the `@w`/`@len`
+* size steps. `none` (and an unknown type) leaves the end bare.
+*
+* @param node The `a:headEnd` / `a:tailEnd` node.
+* @returns The parsed end, or `undefined` when nothing is drawn there.
+*/
+function parseLineEnd(node) {
+	const type = poAttr(node, "type");
+	if (type === void 0 || !LINE_END_TYPES.has(type)) return void 0;
+	const w = poAttr(node, "w");
+	const len = poAttr(node, "len");
+	const size = (v) => v !== void 0 && LINE_END_SIZES.has(v) ? v : void 0;
+	const width = size(w);
+	const length = size(len);
+	return {
+		type,
+		...width ? { width } : {},
+		...length ? { length } : {}
+	};
+}
+/**
+* §20.1.8.21 `a:custDash` — the dash/space lengths of the author's own
+* pattern. Each `a:ds` states them in 1000ths of a percent of the line's
+* width, so the numbers here are plain multiples of that width.
+*
+* @param custDash The `a:custDash` node.
+* @returns The pattern as [dash, space, dash, space, …], or `undefined`.
+*/
+function parseCustDash(custDash) {
+	const out = [];
+	for (const ds of poChildren(custDash)) {
+		if (!poIs(ds, "a:ds")) continue;
+		const d = (poIntAttr(ds, "d") ?? 0) / 1e5;
+		const sp = (poIntAttr(ds, "sp") ?? 0) / 1e5;
+		if (d <= 0 && sp <= 0) continue;
+		out.push(Math.max(0, d), Math.max(0, sp));
+	}
+	return out.length > 0 ? out : void 0;
+}
 var DASH_VALUES = new Set([
 	"solid",
 	"dot",
@@ -506,10 +2024,28 @@ function parseGradient(grad, resolveColor) {
 	}
 	if (stops.length === 0) return void 0;
 	stops.sort((a, b) => a.offset - b.offset);
-	if (poChildren(grad).some((c) => poIs(c, "a:path"))) return {
-		kind: "radial",
-		stops
-	};
+	const path = poChildren(grad).find((c) => poIs(c, "a:path"));
+	if (path) {
+		const rect = poChildren(path).find((c) => poIs(c, "a:fillToRect"));
+		const side = (name) => {
+			const v = rect ? poIntAttr(rect, name) : void 0;
+			return v === void 0 ? void 0 : v / 1e5;
+		};
+		const l = side("l");
+		const r = side("r");
+		const t = side("t");
+		const b = side("b");
+		const center = l !== void 0 || r !== void 0 || t !== void 0 || b !== void 0 ? {
+			x: clampUnit(((l ?? 0) + 1 - (r ?? 0)) / 2),
+			y: clampUnit(((t ?? 0) + 1 - (b ?? 0)) / 2)
+		} : void 0;
+		return {
+			kind: "radial",
+			stops,
+			...poAttr(path, "path") === "rect" ? { sweep: "rect" } : {},
+			...center ? { center } : {}
+		};
+	}
 	const lin = poChildren(grad).find((c) => poIs(c, "a:lin"));
 	const ang = lin ? poIntAttr(lin, "ang") : void 0;
 	return {
@@ -522,4 +2058,4 @@ function clampUnit(x) {
 	return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 //#endregion
-export { expandMcChildren, parseCustGeom, parseDrawing, parseFill, parseLine, parsePrstGeom, parseVmlPicture };
+export { expandMcChildren, parseCustGeom, parseDrawing, parseFill, parseLine, parsePrstGeom, parseShadow, parseVmlPicture, parseXfrm, shadowFromOuterShdw, vmlFill };