reamkit 1.17.0 → 1.19.0

package/dist/esm/layout/styled-layout.js

@@ -4,6 +4,9 @@ import { createFontMeasure } from "../core/font/measure.js";
 import { halfPtToPt, pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { prepareImage } from "../core/images.js";
+import { PathBuilder, flipTransform } from "../core/vector.js";
+import { isEmf, readEmf } from "../core/metafile/emf.js";
+import { isWmf, readWmf } from "../core/metafile/wmf.js";
 import { segmentLevels } from "../core/bidi/segments.js";
 import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
 import { FORCED_BREAK, breakLines } from "../core/line-breaker/knuth-plass.js";
@@ -15,7 +18,6 @@ import { resolveParagraphProperties, resolveRunProperties } from "../core/style-
 import "../core/style-cascade/index.js";
 import { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
 import "../core/numbering/index.js";
-import { PathBuilder, flipTransform } from "../core/vector.js";
 import { buildSparkline } from "../core/drawingml/sparkline-geometry.js";
 import { arcPoint, arcToBeziers } from "../core/arc-to-bezier.js";
 import { buildChartScene, legendSeriesName } from "../core/drawingml/chart-geometry.js";
@@ -55,6 +57,35 @@ var MIN_WRAP_WIDTH = 36;
 function isOutOfFlowFloat(f) {
 	return f !== void 0 && f.wrap !== "topAndBottom";
 }
+/** The float's left edge, resolved from its horizontal anchor (§20.4.3.3). */
+function floatXIn(frame, f, widthPt) {
+	const h = f.posH;
+	if (!h) return frame.columnLeft;
+	const textRight = frame.marginLeft + frame.contentWidth;
+	const pageRight = frame.pageLeft + frame.pageWidth;
+	const base = h.relativeFrom === "page" || h.relativeFrom === "leftMargin" ? frame.pageLeft : h.relativeFrom === "column" ? frame.columnLeft : h.relativeFrom === "rightMargin" ? textRight : frame.marginLeft;
+	const span = h.relativeFrom === "page" ? frame.pageWidth : h.relativeFrom === "column" ? frame.columnWidth : h.relativeFrom === "leftMargin" ? frame.marginLeft - frame.pageLeft : h.relativeFrom === "rightMargin" ? pageRight - textRight : frame.contentWidth;
+	if (h.align === "center") return base + (span - widthPt) / 2;
+	if (h.align === "right") return base + span - widthPt;
+	return base + (h.offsetPt ?? 0);
+}
+/** The float's TOP, y-up, resolved from its vertical anchor (§20.4.3.4). */
+function floatTopYUpIn(frame, f, heightPt = 0) {
+	const v = f.posV;
+	if (!v) return frame.anchorY;
+	if (v.align !== void 0) {
+		const page = v.relativeFrom === "page";
+		const topYUp = page ? frame.pageTopYUp : frame.marginTopYUp;
+		const bottomYUp = page ? frame.pageBottomYUp : frame.marginBottomYUp;
+		if (v.align === "top") return topYUp;
+		if (v.align === "bottom") return bottomYUp + heightPt;
+		return bottomYUp + (topYUp - bottomYUp + heightPt) / 2;
+	}
+	if (v.relativeFrom === "page" || v.relativeFrom === "topMargin") return frame.pageTopYUp - (v.offsetPt ?? 0);
+	if (v.relativeFrom === "bottomMargin") return frame.marginBottomYUp - (v.offsetPt ?? 0);
+	if (v.relativeFrom === "margin") return frame.marginTopYUp - (v.offsetPt ?? 0);
+	return frame.anchorY - (v.offsetPt ?? 0);
+}
 var FOOTNOTE_RULE_WIDTH = 144;
 function assignNoteNumbers(body, commentIds) {
 	const footnotes = /* @__PURE__ */ new Map();
@@ -273,8 +304,8 @@ function layoutStyledDocument(body, options) {
 	const pdfaProfile = options.pdfA ? parsePdfAProfile(options.pdfA) : void 0;
 	const tagged = options.tagged === true || options.pdfUA === true || (pdfaProfile?.tagged ?? false);
 	const structBuilder = tagged ? new StructTreeBuilder() : void 0;
-	const fontResources = collectFontResources(numberedBody, numberedHeadersFooters, options);
 	const imageResources = collectImageResources(numberedBody, numberedHeadersFooters, options);
+	const fontResources = collectFontResources(numberedBody, numberedHeadersFooters, options, imageResources);
 	const sectionCtxs = sectionList.map((s) => buildSectionContext(s, options, numberedHeadersFooters, fontResources, imageResources));
 	let sectionIdx = 0;
 	const bodyFrames = frameGroups(numberedBody);
@@ -309,6 +340,7 @@ function layoutStyledDocument(body, options) {
 			spacingBeforePt: 0
 		};
 	}
+	flowLinkedTextBoxes(blocks);
 	const noteBlockCache = /* @__PURE__ */ new Map();
 	const notePlan = options.footnotes && noteAssigned.footnotes.size > 0 ? {
 		numbers: noteAssigned.footnotes,
@@ -400,7 +432,7 @@ function layoutStyledDocument(body, options) {
 	const commentNotes = options.commentAnnotations && options.comments ? buildCommentNotes(noteAssigned.comments, options.comments) : void 0;
 	const reflowParagraph = (paragraph, width, widths) => layoutParagraphBlock(paragraph, options, fontResources, imageResources, width, widths);
 	return {
-		pages: paginateSections(blocks, sectionCtxs, structBuilder, options.language ?? "en-US", notePlan, bookmarks, reflowParagraph, options.pageBackgroundFill?.imageResource !== void 0 ? imageResources.get(options.pageBackgroundFill.imageResource)?.resourceName : void 0),
+		pages: paginateSections(blocks, sectionCtxs, structBuilder, options.language ?? "en-US", notePlan, bookmarks, reflowParagraph, backgroundImageOf(options, imageResources)),
 		resources: options.resources ?? new ResourceStore(),
 		fontResources,
 		imageResources,
@@ -577,7 +609,7 @@ function balancedColumnHeight(bandHeightPt, colCount, roomPt) {
 /** Total laid-out height of a run of blocks, paragraph spacing included. */
 function blocksHeight(blocks) {
 	return blocks.reduce((sum, b) => {
-		if (b.kind !== "paragraph" && b.kind !== "table" && isOutOfFlowFloat(b.float)) return sum;
+		if (b.kind !== "paragraph" && isOutOfFlowFloat(b.float)) return sum;
 		return sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : b.heightPt);
 	}, 0);
 }
@@ -775,8 +807,98 @@ function frameShape(frame, paragraphs, widthPt, exact) {
 	};
 }
 /** §17.3.1.11 → §20.4.2.3: the frame's anchor, in the terms floats are placed in. */
+/**
+* `wps:linkedTxbx` — carry each chain's overflow from one box to the next.
+* The words all live in the chain's FIRST box; a box shows as many of its lines
+* as its height holds and hands the rest on, so LinkedTextBoxes.docx reads down
+* one column and continues at the top of the other. A box that ends a chain
+* keeps whatever is left, overflowing as it would have anyway.
+*
+* The lines are broken at the first box's width, so a chain of boxes of
+* different widths sets its later columns to the wrong measure; re-breaking
+* needs the source paragraphs split at the carry point, which the laid-out
+* lines no longer know.
+*/
+function flowLinkedTextBoxes(blocks) {
+	const chains = /* @__PURE__ */ new Map();
+	blocks.forEach((b, i) => {
+		if (b.kind !== "shape" || !b.textChain) return;
+		const at = chains.get(b.textChain.id) ?? [];
+		at.push(i);
+		chains.set(b.textChain.id, at);
+	});
+	for (const indices of chains.values()) {
+		if (indices.length < 2) continue;
+		indices.sort((a, b) => {
+			return (blocks[a].textChain?.seq ?? 0) - (blocks[b].textChain?.seq ?? 0);
+		});
+		let carried = [];
+		indices.forEach((idx, n) => {
+			const box = blocks[idx];
+			const all = n === 0 ? boxLines(box) : carried;
+			const last = n === indices.length - 1;
+			const room = box.heightPt - box.insetTopPt - box.insetBottomPt;
+			const kept = [];
+			let used = 0;
+			for (const l of all) {
+				const h = computeLineHeight(l.line, l.line.resolved) + l.gapPt;
+				if (!last && kept.length > 0 && used + h > room) break;
+				kept.push(l);
+				used += h;
+			}
+			carried = all.slice(kept.length);
+			blocks[idx] = rebuildBoxLines(box, kept);
+		});
+	}
+}
+function boxLines(box) {
+	return box.textLines.map((line, i) => ({
+		line,
+		gapPt: box.textLineGaps?.get(i) ?? 0,
+		...box.textCharts?.get(i) ? { chart: box.textCharts.get(i) } : {},
+		...box.textShapes?.get(i) ? { shape: box.textShapes.get(i) } : {},
+		...box.textTables?.get(i) ? { table: box.textTables.get(i) } : {}
+	}));
+}
+function rebuildBoxLines(box, lines) {
+	const charts = /* @__PURE__ */ new Map();
+	const shapes = /* @__PURE__ */ new Map();
+	const tables = /* @__PURE__ */ new Map();
+	const gaps = /* @__PURE__ */ new Map();
+	let height = 0;
+	lines.forEach((l, i) => {
+		if (l.chart) charts.set(i, l.chart);
+		if (l.shape) shapes.set(i, l.shape);
+		if (l.table) tables.set(i, l.table);
+		if (l.gapPt > 0) gaps.set(i, l.gapPt);
+		height += computeLineHeight(l.line, l.line.resolved) + l.gapPt;
+	});
+	const { textCharts: _c, textShapes: _s, textTables: _t, textLineGaps: _g, ...rest } = box;
+	return {
+		...rest,
+		textLines: lines.map((l) => l.line),
+		...charts.size > 0 ? { textCharts: charts } : {},
+		...shapes.size > 0 ? { textShapes: shapes } : {},
+		...tables.size > 0 ? { textTables: tables } : {},
+		...gaps.size > 0 ? { textLineGaps: gaps } : {},
+		textHeightPt: height
+	};
+}
+/**
+* §17.3.1.11 — whether the frame is placed DOWN THE PAGE by itself, rather than
+* where the flow has reached. `w:vAnchor="text"` (the default) measures `w:y`
+* from the paragraph's own position, so such frames stack as paragraphs do —
+* and a float takes no flow space, so lifting them out puts every one of them
+* on the same line: tdf105035_framePrB.docx writes its title and its author
+* line as text-anchored frames and both landed on the cursor, one over the
+* other. Only a frame anchored to the page or the margin, or aligned by
+* keyword, truly stands somewhere of its own.
+*/
+function framePositioned(frame) {
+	return frame.yAlign !== void 0 || frame.vAnchor !== void 0 && frame.vAnchor !== "text";
+}
 function frameFloat(frame) {
-	const wrap = frame.wrap === "none" ? "none" : frame.wrap === "notBeside" ? "topAndBottom" : "square";
+	const wrap = frame.wrap === "none" ? "none" : frame.wrap === "notBeside" ? framePositioned(frame) ? "notBeside" : "topAndBottom" : "square";
 	const hRel = frame.hAnchor === "page" ? "page" : frame.hAnchor === "margin" ? "margin" : "column";
 	const vRel = frame.vAnchor === "page" ? "page" : frame.vAnchor === "margin" ? "margin" : "paragraph";
 	const align = frame.xAlign === "left" || frame.xAlign === "center" || frame.xAlign === "right" ? frame.xAlign : void 0;
@@ -825,7 +947,10 @@ function laidOutBlocksFor(elements, options, fontResources, contentWidth, imageR
 function layoutBodyElement(el, options, fontResources, imageResources, contentWidth, maxHeight, box) {
 	if (el.kind === "paragraph") return layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, contentWidth);
 	if (el.kind === "table") return layoutTableBlock(el.table, options, fontResources, imageResources, contentWidth);
-	if (el.kind === "image") return layoutImageBlock(el.image, imageResources, contentWidth, maxHeight, box);
+	if (el.kind === "image") {
+		const meta = el.image.resource ? imageResources?.get(el.image.resource)?.metafile : void 0;
+		return meta ? layoutMetafileBlock(el.image, meta, options, fontResources, contentWidth, maxHeight, box) : layoutImageBlock(el.image, imageResources, contentWidth, maxHeight, box);
+	}
 	if (el.kind === "chart") return layoutChartBlock(el.chart, options, fontResources, contentWidth, maxHeight);
 	return layoutShapeBlock(el.shape, options, fontResources, imageResources, contentWidth, maxHeight, box);
 }
@@ -873,6 +998,7 @@ function layoutImageBlock(image, imageResources, contentWidth, maxHeight, box) {
 		resolvedAlignment,
 		resourceName: res?.resourceName ?? "",
 		...image.outline ? { outline: image.outline } : {},
+		...image.wash ? { wash: image.wash } : {},
 		...image.crop ? { crop: image.crop } : {},
 		...image.rotation60k ? { rotationDeg: image.rotation60k / 6e4 } : {},
 		...image.flipH ? { flipH: true } : {},
@@ -898,7 +1024,12 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		heightPt = maxHeight;
 	}
 	const fillGradient = shape.fill.kind === "gradient" ? shape.fill.gradient : void 0;
-	const fillImageResourceName = shape.fill.kind === "picture" && shape.fill.imageResource !== void 0 ? imageResources?.get(shape.fill.imageResource)?.resourceName : void 0;
+	const fillImage = shape.fill.kind === "picture" && shape.fill.imageResource !== void 0 ? imageResources?.get(shape.fill.imageResource) : void 0;
+	const fillImageResourceName = fillImage?.resourceName;
+	const fillImageTile = shape.fill.kind === "picture" && shape.fill.tiled === true && fillImage?.prepared ? {
+		widthPt: fillImage.prepared.widthPx * 72 / 96,
+		heightPt: fillImage.prepared.heightPx * 72 / 96
+	} : void 0;
 	const fillColorHex = shape.fill.kind === "solid" ? shape.fill.colorHex : fillGradient ? gradientToSolid(fillGradient) : void 0;
 	const stroke = buildStroke(shape.line);
 	const t = shape.transform;
@@ -1052,9 +1183,11 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		paths,
 		...markerPaths.length > 0 ? { markerPaths } : {},
 		...fillImageResourceName ? { fillImageResourceName } : {},
+		...fillImageTile ? { fillImageTile } : {},
 		...fillImageResourceName && shape.fill.imageCrop ? { fillImageCrop: shape.fill.imageCrop } : {},
 		...fillColorHex ? { fillColorHex } : {},
 		...fillGradient ? { fillGradient } : {},
+		...shape.fill.alpha !== void 0 && shape.fill.alpha < 1 ? { fillAlpha: shape.fill.alpha } : {},
 		...stroke ? { stroke } : {},
 		...shape.shadow ? { shadow: shape.shadow } : {},
 		rotation60k: t?.rotation60k ?? 0,
@@ -1069,6 +1202,7 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		...textTables.size > 0 ? { textTables } : {},
 		...textLineGaps.size > 0 ? { textLineGaps } : {},
 		textHeightPt,
+		...text?.chain ? { textChain: text.chain } : {},
 		insetLeftPt,
 		insetRightPt,
 		insetTopPt,
@@ -1079,6 +1213,144 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		...shape.float ? { float: shape.float } : {}
 	};
 }
+/**
+* MS-EMF / MS-WMF — a metafile picture as the primitives a chart is made of,
+* scaled from its own logical box into the box the drawing reserves.
+*
+* A metafile IS a little drawing program, and what it draws is paths and words:
+* the same two things a chart's layout carries, placed in the same local y-up
+* frame. So one is turned into the other rather than growing a block kind, a
+* pagination arm and an emitter of its own.
+*/
+function layoutMetafileBlock(image, pic, options, fontResources, contentWidth, maxHeight, box) {
+	const placed = layoutImageBlock(image, void 0, contentWidth, maxHeight, box);
+	const widthPt = placed.widthPt;
+	const heightPt = placed.heightPt;
+	const layout = rotateDrawing(metafileDrawing(pic, widthPt, heightPt, options, fontResources), (image.rotation60k ?? 0) / 6e4, widthPt / 2, heightPt / 2);
+	const pp = image.paragraphProperties;
+	return {
+		kind: "chart",
+		widthPt,
+		heightPt,
+		layout,
+		resolvedAlignment: pp.alignment ?? "left",
+		spacingBeforePt: pp.spacingBefore ?? 0,
+		spacingAfterPt: pp.spacingAfter ?? 0,
+		figureRole: "Image",
+		...image.altText ? { altText: image.altText } : {},
+		...image.float ? { float: image.float } : {}
+	};
+}
+/** The same primitives, turned `deg` CLOCKWISE about a point of the local frame. */
+function rotateDrawing(layout, deg, cx, cy) {
+	if (!deg) return layout;
+	const a = -deg * Math.PI / 180;
+	const cos = Math.cos(a);
+	const sin = Math.sin(a);
+	const at = (x, y) => ({
+		x: cx + (x - cx) * cos - (y - cy) * sin,
+		y: cy + (x - cx) * sin + (y - cy) * cos
+	});
+	return {
+		shapes: layout.shapes.map((sh) => ({
+			...sh,
+			paths: sh.paths.map((path) => ({
+				...path,
+				segments: path.segments.map((seg) => {
+					if (seg.op === "close") return seg;
+					if (seg.op === "cubic") {
+						const c1 = at(seg.x1, seg.y1);
+						const c2 = at(seg.x2, seg.y2);
+						const e = at(seg.x, seg.y);
+						return {
+							op: "cubic",
+							x1: c1.x,
+							y1: c1.y,
+							x2: c2.x,
+							y2: c2.y,
+							x: e.x,
+							y: e.y
+						};
+					}
+					const p = at(seg.x, seg.y);
+					return {
+						op: seg.op,
+						x: p.x,
+						y: p.y
+					};
+				})
+			}))
+		})),
+		texts: layout.texts.map((t) => {
+			const p = at(t.x, t.y);
+			return {
+				...t,
+				x: p.x,
+				y: p.y,
+				rotationDeg: (t.rotationDeg ?? 0) - deg
+			};
+		})
+	};
+}
+/**
+* A metafile's primitives, scaled from its own logical box into a `widthPt` ×
+* `heightPt` one and turned y-up about its bottom-left corner — the frame both
+* a chart block and an inline picture token are drawn in.
+*/
+function metafileDrawing(pic, widthPt, heightPt, options, fontResources) {
+	const sx = widthPt / pic.width;
+	const sy = heightPt / pic.height;
+	const mapX = (x) => (x - pic.left) * sx;
+	const mapY = (y) => heightPt - (y - pic.top) * sy;
+	const shapes = [];
+	const texts = [];
+	for (const prim of pic.prims) {
+		if (prim.kind === "path") {
+			shapes.push({
+				paths: prim.paths.map((path) => ({
+					...path,
+					segments: path.segments.map((seg) => seg.op === "close" ? seg : seg.op === "cubic" ? {
+						op: "cubic",
+						x1: mapX(seg.x1),
+						y1: mapY(seg.y1),
+						x2: mapX(seg.x2),
+						y2: mapY(seg.y2),
+						x: mapX(seg.x),
+						y: mapY(seg.y)
+					} : {
+						op: seg.op,
+						x: mapX(seg.x),
+						y: mapY(seg.y)
+					})
+				})),
+				...prim.fillColorHex !== void 0 ? { fillColorHex: prim.fillColorHex } : {},
+				...prim.stroke ? { stroke: {
+					...prim.stroke,
+					widthPt: Math.max(.25, prim.stroke.widthPt * sx)
+				} } : {}
+			});
+			continue;
+		}
+		if (prim.kind !== "text") continue;
+		const { variant } = options.registry.resolveByStyle(prim.bold === true, prim.italic === true);
+		const font = fontResources.get(variant);
+		if (!font) continue;
+		const sizePt = Math.max(1, prim.sizeLu * sy);
+		const line = makeChartLabelLine(prim.text, font, sizePt, prim.colorHex);
+		const shift = prim.alignH === "center" ? -line.contentWidthPt / 2 : prim.alignH === "right" ? -line.contentWidthPt : 0;
+		const baselineY = mapY(prim.y) - (prim.alignBaseline ? 0 : sizePt * .8);
+		texts.push({
+			line,
+			x: mapX(prim.x) + shift,
+			y: baselineY,
+			...prim.escapement ? { rotationDeg: prim.escapement / 10 } : {}
+		});
+	}
+	return {
+		shapes,
+		texts
+	};
+}
 function layoutChartBlock(block, options, fontResources, contentWidth, maxHeight) {
 	let widthPt = block.width;
 	let heightPt = block.height;
@@ -1346,6 +1618,21 @@ function makeChartLabelLine(text, font, sizePt, colorHex) {
 		isLastInParagraph: true
 	};
 }
+/**
+* §17.2.1 — the page background's picture, with the size a TILE of it is drawn
+* at: the picture's own pixels read at 96 dpi, which is the resolution Office
+* measures a picture in.
+*/
+function backgroundImageOf(options, imageResources) {
+	const id = options.pageBackgroundFill?.imageResource;
+	const res = id === void 0 ? void 0 : imageResources.get(id);
+	if (!res?.resourceName || !res.prepared) return void 0;
+	return {
+		name: res.resourceName,
+		widthPt: res.prepared.widthPx * 72 / 96,
+		heightPt: res.prepared.heightPx * 72 / 96
+	};
+}
 function collectImageResources(body, headersFooters, options) {
 	const out = /* @__PURE__ */ new Map();
 	if (!options.resources || options.resources.size === 0) return out;
@@ -1376,6 +1663,15 @@ function collectImageResources(body, headersFooters, options) {
 	for (const resourceId of seen) {
 		const bytes = options.resources.get(resourceId);
 		if (!bytes) continue;
+		if (isEmf(bytes) || isWmf(bytes)) {
+			try {
+				out.set(resourceId, {
+					resourceName: "",
+					metafile: isEmf(bytes) ? readEmf(bytes) : readWmf(bytes)
+				});
+			} catch {}
+			continue;
+		}
 		let prepared;
 		try {
 			prepared = prepareImage(bytes, { flattenAlpha });
@@ -1481,21 +1777,76 @@ function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
 		textY -= sh.textLineGaps?.get(i) ?? 0;
 	});
 }
+/** The page a table is being drawn onto, as a cell's floats need to see it. */
+function cellAnchorCtx(asm) {
+	return {
+		sink: (behind, zOrder) => PageAssembler.zSink(behind ? asm.floatsBehind : asm.floatsFront, zOrder),
+		frame: asm.floatFrame(),
+		exclude: (f, x, topYUp, widthPt, heightPt) => {
+			asm.excludeFloat(f, x, topYUp, widthPt, heightPt);
+		},
+		pageHeight: asm.ctx.pageHeight
+	};
+}
+function emitCellFloat(cf, ctx, frame) {
+	const float = cf.block.float;
+	if (!float) return;
+	const x = floatXIn(frame, float, cf.block.widthPt);
+	const topYUp = floatTopYUpIn(frame, float, cf.block.heightPt);
+	const sink = ctx.sink(float.behind === true, float.zOrder);
+	if (cf.block.kind === "shape") emitShapeItems(cf.block, x, topYUp - cf.block.heightPt, sink, ctx.pageHeight, void 0);
+	else {
+		const ins = cf.block.drawInset;
+		sink.push({
+			type: "image",
+			x: pt(x + (ins?.dxPt ?? 0)),
+			y: pt(ctx.pageHeight - (topYUp - (ins?.dyTopPt ?? 0))),
+			width: pt(ins?.widthPt ?? cf.block.widthPt),
+			height: pt(ins?.heightPt ?? cf.block.heightPt),
+			imageResourceName: cf.block.resourceName,
+			...cf.block.crop ? { crop: cf.block.crop } : {},
+			...cf.block.wash ? { wash: cf.block.wash } : {},
+			...cf.block.rotationDeg ? { rotationDeg: cf.block.rotationDeg } : {},
+			...cf.block.flipH ? { flipH: true } : {},
+			...cf.block.flipV ? { flipV: true } : {}
+		});
+		if (cf.block.outline) sink.push(...pictureOutlineItems(cf.block.outline, x + (ins?.dxPt ?? 0), ctx.pageHeight - (topYUp - (ins?.dyTopPt ?? 0)), ins?.widthPt ?? cf.block.widthPt, ins?.heightPt ?? cf.block.heightPt, void 0));
+	}
+	if (float.wrap !== "none") ctx.exclude(float, x, topYUp, cf.block.widthPt, cf.block.heightPt);
+}
 function emitShapeItems(sh, x, bottomYUp, sink, pageHeight, figId) {
-	if (sh.fillImageResourceName) sink.push({
-		type: "image",
-		x: pt(x),
-		y: pt(pageHeight - (bottomYUp + sh.heightPt)),
-		width: pt(sh.widthPt),
-		height: pt(sh.heightPt),
-		imageResourceName: sh.fillImageResourceName,
-		...sh.fillImageCrop ? { crop: sh.fillImageCrop } : {},
-		clip: {
+	if (sh.fillImageResourceName) {
+		const clip = {
 			paths: sh.paths,
 			transform: flipTransform(buildShapeTransform(x, bottomYUp, sh.widthPt, sh.heightPt, sh.rotation60k, sh.flipH, sh.flipV), pageHeight)
-		},
-		...figId !== void 0 ? { structId: figId } : {}
-	});
+		};
+		const fig = figId !== void 0 ? { structId: figId } : {};
+		const tile = sh.fillImageTile;
+		if (tile) for (const item of PageAssembler.tileItems(sh.fillImageResourceName, tile, {
+			x,
+			y: pageHeight - (bottomYUp + sh.heightPt),
+			width: sh.widthPt,
+			height: sh.heightPt
+		})) {
+			if (item.type !== "image") continue;
+			sink.push({
+				...item,
+				clip,
+				...fig
+			});
+		}
+		else sink.push({
+			type: "image",
+			x: pt(x),
+			y: pt(pageHeight - (bottomYUp + sh.heightPt)),
+			width: pt(sh.widthPt),
+			height: pt(sh.heightPt),
+			imageResourceName: sh.fillImageResourceName,
+			...sh.fillImageCrop ? { crop: sh.fillImageCrop } : {},
+			clip,
+			...fig
+		});
+	}
 	if (sh.markerPaths && sh.stroke) sink.push({
 		type: "shape",
 		shape: {
@@ -1511,6 +1862,7 @@ function emitShapeItems(sh, x, bottomYUp, sink, pageHeight, figId) {
 			paths: sh.paths,
 			...sh.fillColorHex ? { fillColorHex: sh.fillColorHex } : {},
 			...sh.fillGradient ? { fillGradient: sh.fillGradient } : {},
+			...sh.fillAlpha !== void 0 ? { fillAlpha: sh.fillAlpha } : {},
 			...sh.stroke ? { stroke: sh.stroke } : {},
 			...sh.shadow ? { shadow: sh.shadow } : {},
 			transform: flipTransform(buildShapeTransform(x, bottomYUp, sh.widthPt, sh.heightPt, sh.rotation60k, sh.flipH, sh.flipV), pageHeight)
@@ -1593,6 +1945,15 @@ function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth
 	const ordered = blocks.some(isBehind) ? [...blocks.filter(isBehind), ...blocks.filter((b) => !isBehind(b))] : blocks;
 	for (const block of ordered) {
 		if (block.kind === "table") {
+			const anchored = isOutOfFlowFloat(block.float) ? bandAnchor(block.float, block.totalWidthPt, contentWidth, startX) : void 0;
+			if (anchored !== void 0 && block.float) {
+				let rowY = bandAnchorTop(block.float, cursorY, pageHeight, block.heightPt, bandMargins);
+				for (const row of block.rows) {
+					emitRowChunk(out, row, startX + anchored, rowY, pageHeight, block.colCount);
+					rowY -= row.heightPt;
+				}
+				continue;
+			}
 			const tableX = startX + block.xOffsetPt;
 			for (const row of block.rows) {
 				emitRowChunk(out, row, tableX, cursorY, pageHeight, block.colCount);
@@ -1620,6 +1981,7 @@ function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth
 				height: pt(block.heightPt),
 				imageResourceName: block.resourceName,
 				...block.crop ? { crop: block.crop } : {},
+				...block.wash ? { wash: block.wash } : {},
 				...block.rotationDeg ? { rotationDeg: block.rotationDeg } : {},
 				...block.flipH ? { flipH: true } : {},
 				...block.flipV ? { flipV: true } : {}
@@ -1739,7 +2101,7 @@ function runFontKeyAndParsed(options, ascii, bold, italic) {
 function lookupFont(resources, fontKey) {
 	return resources.get(fontKey) ?? resources.values().next().value;
 }
-function collectFontResources(body, headersFooters, options) {
+function collectFontResources(body, headersFooters, options, imageResources) {
 	const used = /* @__PURE__ */ new Map();
 	const addRun = (run, para) => {
 		const resolved = resolveRunProperties(run.properties, para.properties, options.styles);
@@ -1774,30 +2136,48 @@ function collectFontResources(body, headersFooters, options) {
 			for (const ch of seg.text) bucket.gids.add(parsed.glyphForCodepoint(ch.codePointAt(0)));
 		}
 	};
-	const visit = (elements) => {
-		for (const el of elements) if (el.kind === "paragraph") for (const run of displayCapsRuns(el.paragraph, options)) {
-			if (run.math) {
-				addMath(run.math);
-				continue;
-			}
-			if (run.inlineImage && !run.text) continue;
-			if (run.field !== void 0) {
-				addRun({
-					text: `${run.text}0123456789`,
-					properties: run.properties
-				}, el.paragraph);
-				continue;
-			}
-			if (run.footnoteRef !== void 0 || run.endnoteRef !== void 0 || run.noteNumber) {
-				addRun({
-					text: `${run.text}0123456789 `,
-					properties: run.properties
-				}, el.paragraph);
-				continue;
+	const addMetafile = (resource) => {
+		const pic = resource ? imageResources.get(resource)?.metafile : void 0;
+		for (const prim of pic?.prims ?? []) {
+			if (prim.kind !== "text") continue;
+			const reg = options.registry.resolveByStyle(prim.bold === true, prim.italic === true);
+			let bucket = used.get(reg.variant);
+			if (!bucket) {
+				bucket = {
+					parsed: reg.parsed,
+					gids: /* @__PURE__ */ new Set()
+				};
+				used.set(reg.variant, bucket);
 			}
-			addRun(run, el.paragraph);
+			for (const ch of prim.text) bucket.gids.add(reg.parsed.glyphForCodepoint(ch.codePointAt(0)));
 		}
-		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) {
+	};
+	const visit = (elements) => {
+		for (const el of elements) if (el.kind === "paragraph") {
+			for (const run of el.paragraph.runs) addMetafile(run.inlineImage?.resource);
+			for (const run of displayCapsRuns(el.paragraph, options)) {
+				if (run.math) {
+					addMath(run.math);
+					continue;
+				}
+				if (run.inlineImage && !run.text) continue;
+				if (run.field !== void 0) {
+					addRun({
+						text: `${run.text}0123456789`,
+						properties: run.properties
+					}, el.paragraph);
+					continue;
+				}
+				if (run.footnoteRef !== void 0 || run.endnoteRef !== void 0 || run.noteNumber) {
+					addRun({
+						text: `${run.text}0123456789 `,
+						properties: run.properties
+					}, el.paragraph);
+					continue;
+				}
+				addRun(run, el.paragraph);
+			}
+		} else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) {
 			if (cell.properties.hashOnOverflow === true) for (const inner of cell.content) {
 				if (inner.kind !== "paragraph") continue;
 				for (const run of inner.paragraph.runs) addRun({
@@ -1813,7 +2193,8 @@ function collectFontResources(body, headersFooters, options) {
 				for (const child of sh.children ?? []) shapeText(child.shape);
 			};
 			shapeText(el.shape);
-		} else if (el.kind === "chart") {
+		} else if (el.kind === "image") addMetafile(el.image.resource);
+		else {
 			const chart = options.charts?.get(el.chart.chartRelId);
 			if (chart) {
 				const reg = options.registry.resolveByStyle(false, false);
@@ -2104,8 +2485,10 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 				imageWidthPt: widthPt,
 				imageHeightPt: heightPt,
 				imageResourceName: res?.resourceName ?? "",
+				...res?.metafile ? { imageMetafile: metafileDrawing(res.metafile, drawBox?.widthPt ?? widthPt, drawBox?.heightPt ?? heightPt, options, fontResources) } : {},
 				...run.inlineImage.outline ? { imageOutline: run.inlineImage.outline } : {},
 				...run.inlineImage.shadow ? { imageShadow: run.inlineImage.shadow } : {},
+				...run.inlineImage.wash ? { imageWash: run.inlineImage.wash } : {},
 				...run.inlineImage.crop ? { imageCrop: run.inlineImage.crop } : {},
 				...run.inlineImage.rotation60k ? { imageRotationDeg: run.inlineImage.rotation60k / 6e4 } : {},
 				...run.inlineImage.flipH ? { imageFlipH: true } : {},
@@ -2189,6 +2572,8 @@ function tokenizePlansLtr(plans) {
 				heightPt: plan.imageHeightPt,
 				...plan.imageOutline ? { outline: plan.imageOutline } : {},
 				...plan.imageShadow ? { shadow: plan.imageShadow } : {},
+				...plan.imageWash ? { wash: plan.imageWash } : {},
+				...plan.imageMetafile ? { metafile: plan.imageMetafile } : {},
 				...plan.imageCrop ? { crop: plan.imageCrop } : {},
 				...plan.imageRotationDeg ? { rotationDeg: plan.imageRotationDeg } : {},
 				...plan.imageFlipH ? { flipH: true } : {},
@@ -2260,6 +2645,8 @@ function tokenizePlansBidi(plans, realLevels) {
 				heightPt: plan.imageHeightPt,
 				...plan.imageOutline ? { outline: plan.imageOutline } : {},
 				...plan.imageShadow ? { shadow: plan.imageShadow } : {},
+				...plan.imageWash ? { wash: plan.imageWash } : {},
+				...plan.imageMetafile ? { metafile: plan.imageMetafile } : {},
 				...plan.imageCrop ? { crop: plan.imageCrop } : {},
 				...plan.imageRotationDeg ? { rotationDeg: plan.imageRotationDeg } : {},
 				...plan.imageFlipH ? { flipH: true } : {},
@@ -2872,9 +3259,67 @@ function alignmentOffset(alignment, lineWidth, available) {
 	if (alignment === "center") return Math.max(0, (available - lineWidth) / 2);
 	return 0;
 }
+/**
+* §17.4.85 `w:vMerge` — a vertical merge is ONE cell, so its continuation rows
+* are painted with the START cell's shading. Word writes the fill on the cell
+* that opens the merge and nothing on the rest; painting only what is written,
+* tdf123104.docx's three-row banner came out a staircase of yellow with white
+* notches where every merged cell continued.
+*/
+function withMergedShading(table, roles) {
+	const columnOf = table.rows.map((row) => {
+		const at = [];
+		let col = row.properties.gridBefore ?? 0;
+		for (const cell of row.cells) {
+			at.push(col);
+			col += Math.max(1, cell.properties.colSpan ?? 1);
+		}
+		return at;
+	});
+	let changed = false;
+	const rows = table.rows.map((row, r) => {
+		const cells = row.cells.map((cell, c) => {
+			const role = roles[r]?.[c] ?? "standalone";
+			if (role !== "middle" && role !== "end") return cell;
+			if (cell.properties.shading?.colorHex) return cell;
+			const col = columnOf[r]?.[c];
+			if (col === void 0) return cell;
+			for (let up = r - 1; up >= 0; up--) {
+				const idx = columnOf[up]?.indexOf(col) ?? -1;
+				if (idx < 0) break;
+				const above = table.rows[up]?.cells[idx];
+				const aboveRole = roles[up]?.[idx] ?? "standalone";
+				if (!above) break;
+				if (aboveRole === "start") {
+					const shading = above.properties.shading;
+					if (!shading?.colorHex) break;
+					changed = true;
+					return {
+						...cell,
+						properties: {
+							...cell.properties,
+							shading
+						}
+					};
+				}
+				if (aboveRole !== "middle") break;
+			}
+			return cell;
+		});
+		return {
+			...row,
+			cells
+		};
+	});
+	return changed ? {
+		...table,
+		rows
+	} : table;
+}
 function layoutTableBlock(table, options, fontResources, imageResources, contentWidth) {
 	const columnWidthsPt = computeColumnWidths(table, options, fontResources, contentWidth);
 	const mergeRoles = table.rows.map((r) => r.cells.map((c) => c.properties.merge ?? "standalone"));
+	table = withMergedShading(table, mergeRoles);
 	const rows = [];
 	const colCount = columnWidthsPt.length;
 	let aboveBordersByCol = [];
@@ -3158,7 +3603,8 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 			cells: cells.map((c) => clipCellToHeight(c, heightPt)),
 			columnXOffsets,
 			rowIdx,
-			rowCount
+			rowCount,
+			...row.properties.cantSplit ? { cantSplit: true } : {}
 		};
 	} else if (row.properties.height && row.properties.heightRule === "atLeast") heightPt = Math.max(heightPt, row.properties.height);
 	return {
@@ -3166,7 +3612,8 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		cells,
 		columnXOffsets,
 		rowIdx,
-		rowCount
+		rowCount,
+		...row.properties.cantSplit ? { cantSplit: true } : {}
 	};
 }
 /**
@@ -3212,6 +3659,7 @@ function imageRun(image) {
 		inlineImage: {
 			...image.resource ? { resource: image.resource } : {},
 			...image.outline ? { outline: image.outline } : {},
+			...image.wash ? { wash: image.wash } : {},
 			width: image.width,
 			height: image.height,
 			...image.crop ? { crop: image.crop } : {},
@@ -3235,6 +3683,7 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	const lines = [];
 	const nestedTables = [];
 	const cellShapes = [];
+	const cellFloats = [];
 	const lineGaps = /* @__PURE__ */ new Map();
 	let contentHeightPt = 0;
 	let clipped = false;
@@ -3288,7 +3737,14 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 			});
 			contentHeightPt += block.heightPt;
 			pendingGapPt = block.spacingAfterPt;
-		}
+		} else if (el.kind === "image" && isOutOfFlowFloat(el.image.float)) cellFloats.push({
+			block: layoutImageBlock(el.image, imageResources, innerWidth),
+			afterLine: lines.length
+		});
+		else if (el.kind === "shape" && isOutOfFlowFloat(el.shape.float)) cellFloats.push({
+			block: layoutShapeBlock(el.shape, options, fontResources, imageResources, innerWidth),
+			afterLine: lines.length
+		});
 		contentHeightPt += pendingGapPt;
 	}
 	const colEnd = colStart + colSpan - 1;
@@ -3309,6 +3765,7 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 		...lineGaps.size > 0 ? { lineGaps } : {},
 		...nestedTables.length > 0 ? { nestedTables } : {},
 		...cellShapes.length > 0 ? { shapes: cellShapes } : {},
+		...cellFloats.length > 0 ? { floats: cellFloats } : {},
 		contentHeightPt,
 		totalHeightPt,
 		...cell.properties.verticalAlign ? { verticalAlign: cell.properties.verticalAlign } : {},
@@ -3441,12 +3898,12 @@ var PageAssembler = class PageAssembler {
 	*                         `undefined` when there are none.
 	* @param bookmarkPositions Out-param: bookmark name → its GoTo destination.
 	*/
-	constructor(sectionCtxs, builder, notes, bookmarkPositions, backgroundImageName) {
+	constructor(sectionCtxs, builder, notes, bookmarkPositions, backgroundImage) {
 		this.sectionCtxs = sectionCtxs;
 		this.builder = builder;
 		this.notes = notes;
 		this.bookmarkPositions = bookmarkPositions;
-		this.backgroundImageName = backgroundImageName;
+		this.backgroundImage = backgroundImage;
 		this.ctx = sectionCtxs[0];
 		this.pageStartCtx = this.ctx;
 		this.pageNumber = this.ctx.properties.pageNumberStart ?? 1;
@@ -3488,6 +3945,12 @@ var PageAssembler = class PageAssembler {
 	/** The current column's width (the section content width when single-column). */
 	colWidth = () => this.ctx.columns?.[this.colIdx]?.widthPt ?? this.ctx.contentWidth;
 	/**
+	* The measure the section's blocks were BROKEN at — the first column's, since
+	* that is all the block pass can know. A column of another width has to
+	* re-break what lands in it.
+	*/
+	builtWidth = () => this.ctx.columns?.[0]?.widthPt ?? this.ctx.contentWidth;
+	/**
 	* Whether the current column is already in use.
 	*
 	* This gates every overflow break, so that a block too tall for an empty page
@@ -3639,44 +4102,36 @@ var PageAssembler = class PageAssembler {
 	*/
 	excludeFloat = (f, x, topYUp, w, h) => {
 		const d = f.wrapDist;
+		const wide = f.wrap === "notBeside";
 		this.exclusions.push({
-			x0: x - (d?.leftPt ?? 0),
-			x1: x + w + (d?.rightPt ?? 0),
+			x0: wide ? this.colLeft() : x - (d?.leftPt ?? 0),
+			x1: wide ? this.colLeft() + this.colWidth() : x + w + (d?.rightPt ?? 0),
 			topYUp: topYUp + (d?.topPt ?? 0),
-			bottomYUp: topYUp - h - (d?.bottomPt ?? 0)
+			bottomYUp: topYUp - h - (d?.bottomPt ?? 0),
+			...f.wrapSide === "bothSides" ? { wrapBothSides: true } : {}
 		});
 	};
+	/** The frame a float anchored in the body flow is resolved against. */
+	floatFrame = () => ({
+		pageLeft: 0,
+		pageWidth: this.ctx.pageWidth,
+		pageTopYUp: this.ctx.pageHeight,
+		pageBottomYUp: 0,
+		marginLeft: this.ctx.marginLeft,
+		contentWidth: this.ctx.contentWidth,
+		marginTopYUp: this.ctx.pageHeight - this.ctx.marginTop,
+		marginBottomYUp: this.ctx.marginBottom,
+		columnLeft: this.colLeft(),
+		columnWidth: this.colWidth(),
+		anchorY: this.cursorY
+	});
 	/** The float's left edge on the page, resolved from its horizontal anchor. */
-	floatX = (f, widthPt) => {
-		const h = f.posH;
-		if (!h) return this.colLeft();
-		const textRight = this.ctx.marginLeft + this.ctx.contentWidth;
-		const base = h.relativeFrom === "page" || h.relativeFrom === "leftMargin" ? 0 : h.relativeFrom === "column" ? this.colLeft() : h.relativeFrom === "rightMargin" ? textRight : this.ctx.marginLeft;
-		const span = h.relativeFrom === "page" ? this.ctx.pageWidth : h.relativeFrom === "column" ? this.colWidth() : h.relativeFrom === "leftMargin" ? this.ctx.marginLeft : h.relativeFrom === "rightMargin" ? this.ctx.pageWidth - textRight : this.ctx.contentWidth;
-		if (h.align === "center") return base + (span - widthPt) / 2;
-		if (h.align === "right") return base + span - widthPt;
-		return base + (h.offsetPt ?? 0);
-	};
+	floatX = (f, widthPt) => floatXIn(this.floatFrame(), f, widthPt);
 	/**
 	* The drawing's TOP in the y-up cursor frame. Paragraph/line-relative offsets
 	* hang off the anchoring paragraph's current position.
 	*/
-	floatTopYUp = (f, heightPt = 0) => {
-		const v = f.posV;
-		if (!v) return this.cursorY;
-		if (v.align !== void 0) {
-			const page = v.relativeFrom === "page";
-			const topYUp = page ? this.ctx.pageHeight : this.ctx.pageHeight - this.ctx.marginTop;
-			const bottomYUp = page ? 0 : this.ctx.marginBottom;
-			if (v.align === "top") return topYUp;
-			if (v.align === "bottom") return bottomYUp + heightPt;
-			return bottomYUp + (topYUp - bottomYUp + heightPt) / 2;
-		}
-		if (v.relativeFrom === "page" || v.relativeFrom === "topMargin") return this.ctx.pageHeight - (v.offsetPt ?? 0);
-		if (v.relativeFrom === "bottomMargin") return this.ctx.marginBottom - (v.offsetPt ?? 0);
-		if (v.relativeFrom === "margin") return this.ctx.pageHeight - this.ctx.marginTop - (v.offsetPt ?? 0);
-		return this.cursorY - (v.offsetPt ?? 0);
-	};
+	floatTopYUp = (f, heightPt = 0) => floatTopYUpIn(this.floatFrame(), f, heightPt);
 	/**
 	* Tagged PDF: the stack of open list levels (for L/LI/LBody nesting). Cleared
 	* whenever a non-list-item block interrupts the run of list paragraphs.
@@ -3739,6 +4194,14 @@ var PageAssembler = class PageAssembler {
 			xOffset: 0,
 			blockedUntilYUp: e.bottomYUp
 		};
+		if (leftRoom >= MIN_WRAP_WIDTH && rightRoom >= MIN_WRAP_WIDTH && e.wrapBothSides) return {
+			width: leftRoom,
+			xOffset: 0,
+			pair: {
+				width: rightRoom,
+				xOffset: full - rightRoom
+			}
+		};
 		if (rightRoom >= leftRoom) return {
 			width: rightRoom,
 			xOffset: full - rightRoom
@@ -3770,6 +4233,7 @@ var PageAssembler = class PageAssembler {
 				continue;
 			}
 			widths.push(g.width);
+			if (g.pair) widths.push(g.pair.width);
 			if (g.width < this.colWidth()) narrowed = true;
 			else if (narrowed) break;
 			y -= h0;
@@ -3947,19 +4411,49 @@ var PageAssembler = class PageAssembler {
 	*
 	* @returns The background items for this page (at most one).
 	*/
+	/**
+	* §14.1.2.5 `@type="tile"` — the picture repeated over a box at its own size,
+	* as image items. A tile is a texture, so its natural size is what makes it
+	* one: stretched over the page it is a blur, and its 128 pixels are 96 points
+	* at the resolution Office measures a picture in.
+	*/
+	static tileItems = (resourceName, natural, box) => {
+		const tw = Math.max(1, natural.widthPt);
+		const th = Math.max(1, natural.heightPt);
+		const cols = Math.min(200, Math.ceil(box.width / tw));
+		const rows = Math.min(200, Math.ceil(box.height / th));
+		const out = [];
+		for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) out.push({
+			type: "image",
+			x: pt(box.x + c * tw),
+			y: pt(box.y + r * th),
+			width: pt(tw),
+			height: pt(th),
+			imageResourceName: resourceName
+		});
+		return out;
+	};
 	pageBackgroundItems = () => {
 		const options = this.ctx.options;
 		const w = this.ctx.pageWidth;
 		const h = this.ctx.pageHeight;
 		const fill = options?.pageBackgroundFill;
-		if (fill?.kind === "picture" && this.backgroundImageName !== void 0) return [{
-			type: "image",
-			x: pt(0),
-			y: pt(0),
-			width: pt(w),
-			height: pt(h),
-			imageResourceName: this.backgroundImageName
-		}];
+		if (fill?.kind === "picture" && this.backgroundImage !== void 0) {
+			const bg = this.backgroundImage;
+			return fill.tiled ? PageAssembler.tileItems(bg.name, bg, {
+				x: 0,
+				y: 0,
+				width: w,
+				height: h
+			}) : [{
+				type: "image",
+				x: pt(0),
+				y: pt(0),
+				width: pt(w),
+				height: pt(h),
+				imageResourceName: bg.name
+			}];
+		}
 		if (fill?.kind === "gradient" && fill.gradient) return [{
 			type: "shape",
 			shape: {
@@ -4043,9 +4537,9 @@ var PageAssembler = class PageAssembler {
 		this.balanceHeightPt = 0;
 	};
 };
-function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", notes, bookmarkPositions, reflowParagraph, backgroundImageName) {
+function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", notes, bookmarkPositions, reflowParagraph, backgroundImage) {
 	if (sectionCtxs.length === 0) return [];
-	const asm = new PageAssembler(sectionCtxs, builder, notes, bookmarkPositions, backgroundImageName);
+	const asm = new PageAssembler(sectionCtxs, builder, notes, bookmarkPositions, backgroundImage);
 	const balanceIfEndsContinuous = (fromBlock) => {
 		const here = asm.ctx;
 		const next = sectionCtxs[asm.secIdx + 1];
@@ -4083,9 +4577,11 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			if ((block.resolved.pageBreakBefore || block.pageBreakBefore) && asm.pageHasContent()) asm.flushPage();
 			asm.cursorY -= block.spacingBeforePt;
 			let pb = block;
+			const colW = asm.colWidth();
+			if (reflowParagraph && pb.source && Math.abs(colW - asm.builtWidth()) > .5) pb = reflowParagraph(pb.source, colW);
 			if (reflowParagraph && pb.source && asm.exclusions.length > 0) {
-				const widths = asm.lineWidthsFor(block, asm.cursorY);
-				if (widths) pb = reflowParagraph(pb.source, asm.colWidth(), widths);
+				const widths = asm.lineWidthsFor(pb, asm.cursorY);
+				if (widths) pb = reflowParagraph(pb.source, colW, widths);
 			}
 			const borderTopY = asm.cursorY;
 			const borderPage = asm.pages.length;
@@ -4103,6 +4599,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				if (lang && lang !== defaultLang) builder.node(structId).lang = lang;
 			}
 			let firstLineOfBlock = true;
+			let pairPending;
 			for (const [lineIdx, line] of pb.lines.entries()) {
 				if (pb.columnBreakLines?.has(lineIdx) && asm.colHasContent()) asm.advanceColumn();
 				const h = computeLineHeight(line, pb.resolved);
@@ -4132,16 +4629,22 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 						});
 					}
 				}
-				for (let guard = 0; guard < 8 && asm.exclusions.length > 0; guard++) {
-					const blocked = asm.lineGeometryAt(asm.cursorY, h).blockedUntilYUp;
-					if (blocked === void 0 || blocked >= asm.cursorY) break;
-					asm.cursorY = blocked;
+				const pairedNow = pairPending;
+				pairPending = void 0;
+				if (pairedNow === void 0) {
+					for (let guard = 0; guard < 8 && asm.exclusions.length > 0; guard++) {
+						const blocked = asm.lineGeometryAt(asm.cursorY, h).blockedUntilYUp;
+						if (blocked === void 0 || blocked >= asm.cursorY) break;
+						asm.cursorY = blocked;
+					}
+					asm.cursorY -= h;
 				}
-				asm.cursorY -= h;
 				const indentLeft = pb.resolved.indentLeft + (line.firstLine ? pb.resolved.indentFirstLine : 0);
 				const offset = alignmentOffset(pb.resolved.alignment, line.contentWidthPt, line.availableWidthPt);
 				const baselineY = pt(asm.ctx.pageHeight - (asm.cursorY + lineBaselineOffset(line, pb.resolved)));
-				const exclusionShift = asm.exclusions.length > 0 ? asm.lineGeometryAt(asm.cursorY + h, h).xOffset : 0;
+				const geometry = asm.exclusions.length > 0 ? asm.lineGeometryAt(asm.cursorY + h, h) : void 0;
+				const exclusionShift = pairedNow ?? geometry?.xOffset ?? 0;
+				if (pairedNow === void 0 && geometry?.pair && Math.abs(line.availableWidthPt - geometry.width) < 1) pairPending = geometry.pair.xOffset;
 				const originX = asm.colLeft() + indentLeft + offset + exclusionShift;
 				if (markerLblId !== void 0 && line === firstLine) {
 					let k = 0;
@@ -4197,6 +4700,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 					height: pt(ins?.heightPt ?? block.heightPt),
 					imageResourceName: block.resourceName,
 					...block.crop ? { crop: block.crop } : {},
+					...block.wash ? { wash: block.wash } : {},
 					...block.rotationDeg ? { rotationDeg: block.rotationDeg } : {},
 					...block.flipH ? { flipH: true } : {},
 					...block.flipV ? { flipV: true } : {},
@@ -4236,7 +4740,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				asm.cursorY -= block.spacingAfterPt;
 			}
 		} else if (block.kind === "chart") {
-			const figId = builder ? createFigure(builder, block.altText, "Chart") : void 0;
+			const figId = builder ? createFigure(builder, block.altText, block.figureRole ?? "Chart") : void 0;
 			const emitChartAt = (x, bottomYUp, sink) => {
 				sink.push(...chartPageItems(block, x, bottomYUp, asm.ctx.pageHeight, figId));
 			};
@@ -4262,7 +4766,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				const sink = PageAssembler.zSink(block.float.behind ? asm.floatsBehind : asm.floatsFront, block.float.zOrder);
 				let rowY = fy;
 				for (const row of block.rows) {
-					emitRowChunk(sink, row, fx, rowY, asm.ctx.pageHeight, colCount);
+					emitRowChunk(sink, row, fx, rowY, asm.ctx.pageHeight, colCount, void 0, void 0, cellAnchorCtx(asm));
 					rowY -= row.heightPt;
 				}
 				if (block.float.wrap !== "none") asm.excludeFloat(block.float, fx, fy, block.totalWidthPt, block.heightPt);
@@ -4291,7 +4795,9 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 						return b.create("P", cellNode).id;
 					});
 				}
-				const chunks = row.heightPt > asm.ctx.pageContentHeight ? splitRowIntoChunks(row, asm.ctx.pageContentHeight) : [row];
+				const room = asm.cursorY - asm.bottomLimit();
+				const page = asm.ctx.pageContentHeight;
+				const chunks = !row.cantSplit && row.heightPt > room && asm.colHasContent() && room > 0 ? splitRowIntoChunks(row, room, page) : row.heightPt > page ? splitRowIntoChunks(row, page) : [row];
 				for (let ci = 0; ci < chunks.length; ci++) {
 					const chunk = chunks[ci];
 					const forcedBreak = ci === 0 && row.breakBefore && !isLeadingHeader && asm.current.length > 0;
@@ -4305,7 +4811,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 						}
 					}
 					const mergedHeights = chunks.length === 1 && row.cells.some((c) => c.mergeRole === "start") ? row.cells.map((c) => c.mergeRole === "start" ? mergedBoxHeightPt(block.rows, ri, c.colStart, asm.cursorY - asm.bottomLimit()) : void 0) : void 0;
-					emitRowChunk(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight, colCount, cellStructIds, mergedHeights);
+					emitRowChunk(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight, colCount, cellStructIds, mergedHeights, cellAnchorCtx(asm));
 					asm.cursorY -= chunk.heightPt;
 					if (ci === chunks.length - 1 && ri < block.rows.length - 1) {
 						const next = block.rows[ri + 1];
@@ -4374,7 +4880,7 @@ function tableCellRowSpan(rows, startRowIdx, colStart) {
 	}
 	return span;
 }
-function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds, mergedHeights) {
+function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds, mergedHeights, anchored) {
 	const rowTop = cursorY;
 	const rowBottom = cursorY - row.heightPt;
 	{
@@ -4553,7 +5059,7 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 				if (nt.afterLine !== n) continue;
 				for (const nrow of nt.block.rows) {
 					const nestedIds = structId !== void 0 ? nrow.cells.map(() => structId) : void 0;
-					emitRowChunk(out, nrow, nestedX, textY, pageHeight, nt.block.colCount, nestedIds);
+					emitRowChunk(out, nrow, nestedX, textY, pageHeight, nt.block.colCount, nestedIds, void 0, anchored);
 					textY -= nrow.heightPt;
 				}
 			}
@@ -4563,6 +5069,29 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 				textY -= cs.block.heightPt;
 				emitShapeItems(cs.block, nestedX + offset, textY, out, pageHeight, structId);
 			}
+			for (const cf of cell.floats ?? []) {
+				if (cf.afterLine !== n || !anchored) continue;
+				const inner = cell.widthPt - cell.padLeftPt - cell.padRightPt;
+				const cellTop = rowTop - cell.padTopPt;
+				const cellBottom = rowTop - (mergedHeights?.[i] ?? row.heightPt) + cell.padBottomPt;
+				const own = cf.block.float?.inCell !== false;
+				emitCellFloat(cf, anchored, {
+					...anchored.frame,
+					...own ? {
+						pageLeft: nestedX,
+						pageWidth: inner,
+						pageTopYUp: cellTop,
+						pageBottomYUp: cellBottom,
+						marginLeft: nestedX,
+						contentWidth: inner,
+						marginTopYUp: cellTop,
+						marginBottomYUp: cellBottom
+					} : {},
+					columnLeft: nestedX,
+					columnWidth: inner,
+					anchorY: textY
+				});
+			}
 		};
 		for (const [lineIdx, line] of cell.lines.entries()) {
 			drawNestedBefore(lineIdx);
@@ -4588,10 +5117,13 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 		drawNestedBefore(cell.lines.length);
 	}
 }
-function splitRowIntoChunks(row, capacity) {
+function splitRowIntoChunks(row, capacity, restCapacity = capacity) {
 	if (row.cells.some((c) => c.nestedTables && c.nestedTables.length > 0)) return [row];
 	const queues = row.cells.map((c) => ({
-		remaining: [...c.lines],
+		remaining: c.lines.map((line, i) => ({
+			line,
+			gapPt: c.lineGaps?.get(i) ?? 0
+		})),
 		template: c
 	}));
 	const anyHasLines = () => queues.some((q) => q.template.mergeRole === "middle" || q.template.mergeRole === "end" ? false : q.remaining.length > 0);
@@ -4609,23 +5141,31 @@ function splitRowIntoChunks(row, capacity) {
 				continue;
 			}
 			const padTop = isFirst ? tpl.padTopPt : 0;
-			const capacityForLines = Math.max(0, capacity - padTop);
+			const capacityForLines = Math.max(0, (isFirst ? capacity : restCapacity) - padTop);
 			const taken = [];
 			let takenHeight = 0;
 			while (q.remaining.length > 0) {
 				const next = q.remaining[0];
-				const lh = computeLineHeight(next, next.resolved);
+				const lh = computeLineHeight(next.line, next.line.resolved) + next.gapPt;
 				if (taken.length > 0 && takenHeight + lh > capacityForLines) break;
 				taken.push(next);
 				takenHeight += lh;
 				q.remaining.shift();
 			}
 			const cellHeight = padTop + takenHeight;
+			const gaps = /* @__PURE__ */ new Map();
+			taken.forEach((t, li) => {
+				if (t.gapPt > 0) gaps.set(li, t.gapPt);
+			});
+			const { lineGaps: _g, shapes: _s, floats: _f, ...restOfCell } = tpl;
 			const chunkCell = {
-				...tpl,
+				...restOfCell,
+				...isFirst && tpl.shapes ? { shapes: tpl.shapes } : {},
+				...isFirst && tpl.floats ? { floats: tpl.floats } : {},
+				...gaps.size > 0 ? { lineGaps: gaps } : {},
 				padTopPt: padTop,
 				padBottomPt: 0,
-				lines: taken,
+				lines: taken.map((t) => t.line),
 				contentHeightPt: takenHeight,
 				totalHeightPt: cellHeight
 			};
@@ -4664,7 +5204,8 @@ function splitRowIntoChunks(row, capacity) {
 			cells: chunkCells,
 			columnXOffsets: row.columnXOffsets,
 			rowIdx: row.rowIdx,
-			rowCount: row.rowCount
+			rowCount: row.rowCount,
+			...row.isHeader ? { isHeader: true } : {}
 		});
 		isFirst = false;
 	}