reamkit 1.16.0 → 1.18.0

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

@@ -4,23 +4,26 @@ 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";
 import { greedyBreakLines } from "../core/line-breaker/greedy.js";
 import { cjkBreakBetween, splitCjkSegment } from "../core/line-breaker/cjk.js";
 import "../core/line-breaker/index.js";
-import { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
 import { DEFAULT_RESOLVED_PARAGRAPH, DEFAULT_RESOLVED_RUN } from "../core/style-cascade/types.js";
 import { resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
-import { PathBuilder, flipTransform } from "../core/vector.js";
+import { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
+import "../core/numbering/index.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";
 import { layoutMath, mathGlyphSegments, variantStyle } from "./math-layout.js";
 import { rectPath } from "../core/drawingml/preset-geometry.js";
-import { buildShapePaths, buildShapeTransform, buildStroke, gradientToSolid } from "../core/drawingml/shape-render.js";
+import { buildShapePaths, buildShapeTransform, buildStroke, gradientToSolid, lineEndPaths } from "../core/drawingml/shape-render.js";
 import { StructTreeBuilder } from "../pdf/struct-tree.js";
 //#region src/layout/styled-layout.ts
 function parsePdfAProfile(pdfA) {
@@ -33,6 +36,14 @@ function parsePdfAProfile(pdfA) {
 		version: part === 1 ? "1.4" : "1.7"
 	};
 }
+/** §17.6.4 — how heavy Word draws the rule between columns. */
+var COLUMN_SEPARATOR_PT = .5;
+/**
+* How far a space may be squeezed below its natural width — the shrink the
+* line breaker offers when it weighs a line, and therefore the shrink the
+* emitter owes it back when it draws one.
+*/
+var GLUE_SHRINK_RATIO = .3;
 var TWIP_TO_PT = 1 / 20;
 var EIGHTH_PT = 1 / 8;
 var DEFAULT_CELL_PADDING_TWIPS = 108;
@@ -40,11 +51,41 @@ var DEFAULT_BORDER_SIZE_EIGHTH = 4;
 var FOOTNOTE_RULE_PT = .75;
 var FOOTNOTE_RULE_GAP_ABOVE = 4;
 var FOOTNOTE_SEPARATOR_HEIGHT = 10;
+var LINE_NUMBER_GAP_PT = 18;
 var FLOAT_TEXT_GAP = 6;
 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();
@@ -257,21 +298,49 @@ function commentTailBlocks(comment, n, opts) {
 */
 function layoutStyledDocument(body, options) {
 	const sectionList = resolveSectionList(body, options);
-	const noteAssigned = assignNoteNumbers(applyNumbering(body, options.numbering), options.comments ? new Set(options.comments.keys()) : void 0);
+	const noteAssigned = assignNoteNumbers(applyNumbering(body, options.numbering, options.styles), options.comments ? new Set(options.comments.keys()) : void 0);
 	const numberedBody = noteAssigned.body;
-	const numberedHeadersFooters = applyNumberingToHeadersFooters(options.headersFooters, options.numbering);
+	const numberedHeadersFooters = applyNumberingToHeadersFooters(options.headersFooters, options.numbering, options.styles);
 	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 sectionCtxs = sectionList.map((s) => buildSectionContext(s, options, numberedHeadersFooters, fontResources));
+	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);
 	const blocks = numberedBody.map((el, idx) => {
 		while (sectionIdx < sectionCtxs.length - 1 && idx >= sectionCtxs[sectionIdx].endIndex) sectionIdx++;
 		const ctx = sectionCtxs[sectionIdx];
-		return layoutBodyElement(el, options, fontResources, imageResources, ctx.columns ? ctx.columns[0].widthPt : ctx.contentWidth, ctx.pageContentHeight);
+		const width = ctx.columns ? ctx.columns[0].widthPt : ctx.contentWidth;
+		const box = {
+			pageWidthPt: ctx.pageWidth,
+			pageHeightPt: ctx.pageHeight,
+			marginLeftPt: ctx.marginLeft,
+			marginRightPt: ctx.pageWidth - ctx.marginLeft - ctx.contentWidth,
+			marginTopPt: ctx.marginTop,
+			marginBottomPt: ctx.marginBottom
+		};
+		const group = bodyFrames.starts.get(idx);
+		if (group) return layoutFrameBlock(group, ctx.options ?? options, fontResources, imageResources, width);
+		if (bodyFrames.continued.has(idx)) return emptyBlock(options);
+		return layoutBodyElement(el, ctx.options ?? options, fontResources, imageResources, width, ctx.pageContentHeight, box);
 	});
+	for (let i = 0; i < blocks.length; i++) {
+		const here = blocks[i];
+		const next = blocks[i + 1];
+		if (here?.kind !== "paragraph" || next?.kind !== "paragraph") continue;
+		if (here.source?.properties.styleId !== next.source?.properties.styleId) continue;
+		if (here.resolved.contextualSpacing) blocks[i] = {
+			...here,
+			spacingAfterPt: 0
+		};
+		if (next.resolved.contextualSpacing) blocks[i + 1] = {
+			...next,
+			spacingBeforePt: 0
+		};
+	}
+	flowLinkedTextBoxes(blocks);
 	const noteBlockCache = /* @__PURE__ */ new Map();
 	const notePlan = options.footnotes && noteAssigned.footnotes.size > 0 ? {
 		numbers: noteAssigned.footnotes,
@@ -286,7 +355,7 @@ function layoutStyledDocument(body, options) {
 			const n = noteAssigned.footnotes.get(id);
 			let laid = void 0;
 			if (content && n !== void 0 && !noteAssigned.deferredFootnotes.includes(id)) {
-				const noteBlocks = substituteNoteNumber(content, n).map((el) => layoutBodyElement(el, options, fontResources, imageResources, sectionCtx.contentWidth, sectionCtx.pageContentHeight));
+				const noteBlocks = substituteNoteNumber(content, n).map((el) => layoutBodyElement(el, sectionCtx.options ?? options, fontResources, imageResources, sectionCtx.contentWidth, sectionCtx.pageContentHeight));
 				laid = {
 					blocks: noteBlocks,
 					heightPt: noteBlocks.reduce((sum, b) => sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : 0), 0)
@@ -314,7 +383,24 @@ function layoutStyledDocument(body, options) {
 				n
 			});
 		}
-		for (const note of tailNotes.sort((a, b) => a.n - b.n)) for (const el of substituteNoteNumber(note.content, note.n)) blocks.push(layoutBodyElement(el, options, fontResources, imageResources, lastCtx.contentWidth, lastCtx.pageContentHeight));
+		if (tailNotes.length > 0) blocks.push(layoutShapeBlock({
+			width: pt(FOOTNOTE_RULE_WIDTH),
+			height: pt(FOOTNOTE_RULE_PT),
+			geometry: {
+				kind: "preset",
+				preset: "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill: {
+				kind: "solid",
+				colorHex: "000000"
+			},
+			paragraphProperties: {
+				spacingBefore: pt(FOOTNOTE_SEPARATOR_HEIGHT),
+				spacingAfter: pt(FOOTNOTE_RULE_GAP_ABOVE)
+			}
+		}, options, fontResources, imageResources, lastCtx.contentWidth));
+		for (const note of tailNotes.sort((a, b) => a.n - b.n)) for (const el of substituteNoteNumber(note.content, note.n)) blocks.push(layoutBodyElement(el, lastCtx.options ?? options, fontResources, imageResources, lastCtx.contentWidth, lastCtx.pageContentHeight));
 		const commentNums = noteAssigned.comments;
 		const threadDepth = (id) => {
 			let depth = 0;
@@ -346,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),
+		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),
 		resources: options.resources ?? new ResourceStore(),
 		fontResources,
 		imageResources,
@@ -367,14 +453,16 @@ function resolvePageDimensions(options, section) {
 	const sectionRight = section?.margins?.right !== void 0 ? section.margins.right : void 0;
 	const sectionTop = section?.margins?.top !== void 0 ? section.margins.top : void 0;
 	const sectionBottom = section?.margins?.bottom !== void 0 ? section.margins.bottom : void 0;
+	const gutter = section?.margins?.gutter ?? 0;
+	const atTop = options.gutterAtTop === true;
 	const headerOffsetPt = section?.margins?.header ?? 720 * TWIP_TO_PT;
 	const footerOffsetPt = section?.margins?.footer ?? 720 * TWIP_TO_PT;
 	return {
 		pageWidth: options.pageWidth ?? sectionPageWidth ?? 595,
 		pageHeight: options.pageHeight ?? sectionPageHeight ?? 842,
-		marginLeft: options.marginLeft ?? sectionLeft ?? 72,
+		marginLeft: (options.marginLeft ?? sectionLeft ?? 72) + (atTop ? 0 : gutter),
 		marginRight: options.marginRight ?? sectionRight ?? 72,
-		marginTop: options.marginTop ?? sectionTop ?? 72,
+		marginTop: (options.marginTop ?? sectionTop ?? 72) + (atTop ? gutter : 0),
 		marginBottom: options.marginBottom ?? sectionBottom ?? 72,
 		headerOffsetPt,
 		footerOffsetPt
@@ -394,13 +482,32 @@ function resolveSectionList(body, options) {
 		endIndex: body.length
 	}];
 }
-function buildSectionContext(section, options, headersFooters, fontResources) {
+function buildSectionContext(section, options, headersFooters, fontResources, imageResources) {
 	const dims = resolvePageDimensions(options, section.properties);
 	const contentWidth = dims.pageWidth - dims.marginLeft - dims.marginRight;
-	const headerSet = layoutHeaderSet(section.properties, headersFooters, options, fontResources, contentWidth, dims.marginLeft, dims.pageHeight, dims.headerOffsetPt);
-	const footerSet = layoutFooterSet(section.properties, headersFooters, options, fontResources, contentWidth, dims.marginLeft, dims.pageHeight, dims.footerOffsetPt);
+	const secOptions = section.properties.gridLinePitchPt !== void 0 ? {
+		...options,
+		gridLinePitchPt: section.properties.gridLinePitchPt
+	} : options;
+	const relativeBox = {
+		pageWidthPt: dims.pageWidth,
+		pageHeightPt: dims.pageHeight,
+		marginLeftPt: dims.marginLeft,
+		marginRightPt: dims.marginRight,
+		marginTopPt: dims.marginTop,
+		marginBottomPt: dims.marginBottom
+	};
+	const headerSet = layoutHeaderSet(section.properties, headersFooters, secOptions, fontResources, imageResources, contentWidth, dims.marginLeft, dims.pageHeight, dims.headerOffsetPt, {
+		top: dims.marginTop,
+		bottom: dims.marginBottom
+	}, relativeBox);
+	const footerSet = layoutFooterSet(section.properties, headersFooters, secOptions, fontResources, imageResources, contentWidth, dims.marginLeft, dims.pageHeight, dims.footerOffsetPt, {
+		top: dims.marginTop,
+		bottom: dims.marginBottom
+	}, relativeBox);
 	const columns = buildColumnGeometry(section.properties.columns, contentWidth);
-	const headerBottom = dims.headerOffsetPt + Math.max(headerSet.default.heightPt ?? 0, headerSet.first.heightPt ?? 0, headerSet.even.heightPt ?? 0);
+	const headerHeight = Math.max(headerSet.default.heightPt ?? 0, section.properties.titlePg === true ? headerSet.first.heightPt ?? 0 : 0, section.properties.evenAndOddHeaders === true ? headerSet.even.heightPt ?? 0 : 0);
+	const headerBottom = headerHeight > 0 ? dims.headerOffsetPt + headerHeight : 0;
 	const marginTop = Math.max(dims.marginTop, headerBottom);
 	return {
 		endIndex: section.endIndex,
@@ -416,7 +523,9 @@ function buildSectionContext(section, options, headersFooters, fontResources) {
 		headerSet,
 		footerSet,
 		titlePg: section.properties.titlePg === true,
-		evenAndOddHeaders: section.properties.evenAndOddHeaders === true
+		evenAndOddHeaders: section.properties.evenAndOddHeaders === true,
+		continuous: section.properties.sectionStart === "continuous",
+		options: secOptions
 	};
 }
 function buildColumnGeometry(cols, contentWidth) {
@@ -451,7 +560,7 @@ function markPagination(cmds) {
 		artifact: "pagination"
 	}));
 }
-function layoutHeaderSet(section, headersFooters, options, fontResources, contentWidth, marginLeft, pageHeight, headerOffsetPt) {
+function layoutHeaderSet(section, headersFooters, options, fontResources, imageResources, contentWidth, marginLeft, pageHeight, headerOffsetPt, bandMargins, relativeBox) {
 	const band = (type) => {
 		const ref = refByType(section.headers, type);
 		if (!ref) return { commands: [] };
@@ -459,9 +568,9 @@ function layoutHeaderSet(section, headersFooters, options, fontResources, conten
 		if (!content) return { commands: [] };
 		let measured = 0;
 		const render = (c) => {
-			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth);
+			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth, imageResources, relativeBox);
 			measured = blocksHeight(blocks);
-			return markPagination(drawBlocksSequentially(blocks, marginLeft, pageHeight - headerOffsetPt, pageHeight));
+			return markPagination(drawBlocksSequentially(blocks, marginLeft, pageHeight - headerOffsetPt, pageHeight, contentWidth, void 0, bandMargins));
 		};
 		if (contentHasPageFields(content)) {
 			render(substitutePageFields(content, 1, 1));
@@ -482,19 +591,37 @@ function layoutHeaderSet(section, headersFooters, options, fontResources, conten
 		even: band("even")
 	};
 }
+/**
+* §17.6.4 — the height each column of a BALANCED band is given: the band's
+* share, but never more than the page has room for, and never so little that
+* the band could not fit the columns at all.
+*
+* @param bandHeightPt The band's whole laid-out height.
+* @param colCount     How many columns it has to share.
+* @param roomPt       What the page has left below the band's top.
+* @returns The per-column height, or 0 when the band should just fill.
+*/
+function balancedColumnHeight(bandHeightPt, colCount, roomPt) {
+	if (bandHeightPt <= 0 || colCount < 2 || roomPt <= 0) return 0;
+	if (bandHeightPt > roomPt * colCount) return 0;
+	return Math.min(roomPt, bandHeightPt / colCount);
+}
 /** Total laid-out height of a run of blocks, paragraph spacing included. */
 function blocksHeight(blocks) {
-	return blocks.reduce((sum, b) => sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : b.heightPt), 0);
+	return blocks.reduce((sum, b) => {
+		if (b.kind !== "paragraph" && b.kind !== "table" && isOutOfFlowFloat(b.float)) return sum;
+		return sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : b.heightPt);
+	}, 0);
 }
-function layoutFooterSet(section, headersFooters, options, fontResources, contentWidth, marginLeft, pageHeight, footerOffsetPt) {
+function layoutFooterSet(section, headersFooters, options, fontResources, imageResources, contentWidth, marginLeft, pageHeight, footerOffsetPt, bandMargins, relativeBox) {
 	const band = (type) => {
 		const ref = refByType(section.footers, type);
 		if (!ref) return { commands: [] };
 		const content = headersFooters.get(ref.relationshipId);
 		if (!content) return { commands: [] };
 		const render = (c) => {
-			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth);
-			return markPagination(drawBlocksSequentially(blocks, marginLeft, footerOffsetPt + blocks.reduce((sum, b) => sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : b.heightPt), 0), pageHeight));
+			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth, imageResources, relativeBox);
+			return markPagination(drawBlocksSequentially(blocks, marginLeft, footerOffsetPt + blocksHeight(blocks), pageHeight, contentWidth, void 0, bandMargins));
 		};
 		if (contentHasPageFields(content)) return {
 			commands: [],
@@ -530,7 +657,7 @@ function substitutePageFields(content, pageNumber, totalPages) {
 }
 function pickBand(set, band) {
 	const has = (e) => e.commands.length > 0 || e.renderDynamic !== void 0;
-	if (band === "first") return has(set.first) ? set.first : set.default;
+	if (band === "first") return set.first;
 	if (band === "even") return has(set.even) ? set.even : set.default;
 	return set.default;
 }
@@ -539,24 +666,329 @@ function bandForPage(pageInSection, globalPageIdx, titlePg, evenAndOddHeaders) {
 	if (evenAndOddHeaders && (globalPageIdx + 1) % 2 === 0) return "even";
 	return "default";
 }
-function laidOutBlocksFor(elements, options, fontResources, contentWidth) {
-	return elements.map((el) => layoutBodyElement(el, options, fontResources, void 0, contentWidth));
+/**
+* §17.3.1.11 — the runs of consecutive paragraphs that carry the SAME frame.
+* Word treats them as one floating text frame, so they lay out together in one
+* box; the entries after the first become empty blocks, which keeps every
+* caller's element indexing (and its section bounds) intact.
+*
+* @param elements The body elements, in order.
+* @returns `starts`: the index each frame begins at → its paragraphs;
+*          `continued`: the indices swallowed by a frame that began earlier.
+*/
+function frameGroups(elements) {
+	const starts = /* @__PURE__ */ new Map();
+	const continued = /* @__PURE__ */ new Set();
+	const key = (p) => p.properties.frame ? JSON.stringify(p.properties.frame) : void 0;
+	let i = 0;
+	while (i < elements.length) {
+		const el = elements[i];
+		const k = el.kind === "paragraph" ? key(el.paragraph) : void 0;
+		if (k === void 0) {
+			i++;
+			continue;
+		}
+		const members = [el.paragraph];
+		let j = i + 1;
+		while (j < elements.length) {
+			const next = elements[j];
+			if (next.kind !== "paragraph" || key(next.paragraph) !== k) break;
+			members.push(next.paragraph);
+			continued.add(j);
+			j++;
+		}
+		starts.set(i, members);
+		i = j;
+	}
+	return {
+		starts,
+		continued
+	};
+}
+/** A block that occupies no space at all — the tail of a frame group. */
+function emptyBlock(options) {
+	return {
+		kind: "paragraph",
+		resolved: resolveParagraphProperties({}, options.styles),
+		lines: [],
+		heightPt: 0,
+		spacingBeforePt: 0,
+		spacingAfterPt: 0
+	};
+}
+/**
+* A text frame as the floating box it is: the paragraphs inside it lay out at
+* the frame's width, the box takes the height the frame states or the text
+* needs, and the body flows past it as its `w:wrap` says.
+*
+* @param paragraphs   The frame's paragraphs, in order.
+* @param options      Render options.
+* @param fontResources Fonts by variant.
+* @param imageResources Images by resource id.
+* @param contentWidth The width available where the frame is anchored.
+* @returns The laid-out frame.
+*/
+function layoutFrameBlock(paragraphs, options, fontResources, imageResources, contentWidth) {
+	const frame = paragraphs[0].properties.frame;
+	const exact = frame.heightRule === "exact" && frame.heightPt !== void 0;
+	const raw = (widthPt, pin) => layoutShapeBlock(frameShape(frame, paragraphs, widthPt, pin), options, fontResources, imageResources, contentWidth);
+	const atLeast = !exact && frame.heightPt !== void 0 && frame.heightRule !== "auto" ? frame.heightPt : 0;
+	const build = (widthPt) => {
+		const laid = raw(widthPt, exact);
+		return laid.kind === "shape" && atLeast > laid.heightPt ? raw(widthPt, true) : laid;
+	};
+	if (frame.widthPt !== void 0) return build(frame.widthPt);
+	const measured = build(contentWidth);
+	const natural = measured.kind === "shape" ? Math.max(1, ...measured.textLines.map((l) => l.contentWidthPt)) : contentWidth;
+	return build(Math.min(contentWidth, natural));
+}
+var MAX_FIT_PASSES = 4;
+function scaleTextBody(text, k) {
+	return {
+		...text,
+		content: text.content.map((el) => el.kind === "paragraph" ? {
+			...el,
+			paragraph: {
+				...el.paragraph,
+				runs: el.paragraph.runs.map((run) => ({
+					...run,
+					properties: {
+						...run.properties,
+						fontSizePt: pt((run.properties.fontSizePt ?? 11) * k)
+					}
+				}))
+			}
+		} : el)
+	};
+}
+function frameShape(frame, paragraphs, widthPt, exact) {
+	const lead = paragraphs[0]?.properties;
+	const edge = lead?.borders?.top ?? lead?.borders?.left;
+	const vertical = lead?.textDirection === "btLr" ? "vert270" : lead?.textDirection === "tbRl" ? "vert" : void 0;
+	const painted = lead?.shading !== void 0 || edge !== void 0 && edge.style !== "none";
+	return {
+		width: pt(widthPt),
+		height: pt(exact ? frame.heightPt ?? 0 : 0),
+		geometry: painted ? {
+			kind: "preset",
+			preset: "rect",
+			adjust: /* @__PURE__ */ new Map()
+		} : {
+			kind: "custom",
+			custom: {
+				pathWidth: 0,
+				pathHeight: 0,
+				commands: []
+			}
+		},
+		fill: lead?.shading ? {
+			kind: "solid",
+			colorHex: lead.shading.colorHex
+		} : { kind: "none" },
+		...edge && edge.style !== "none" ? { line: {
+			fill: "solid",
+			colorHex: edge.colorHex ?? "000000",
+			width: edge.width ?? pt(.75)
+		} } : {},
+		float: frameFloat(frame),
+		paragraphProperties: {},
+		text: {
+			content: paragraphs.map((paragraph) => ({
+				kind: "paragraph",
+				paragraph
+			})),
+			insetLeft: pt(0),
+			insetRight: pt(0),
+			insetTop: pt(0),
+			insetBottom: pt(0),
+			...vertical ? { vertical } : {},
+			...exact ? {} : { autoFit: true }
+		}
+	};
+}
+/** §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" ? 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;
+	const vAlign = frame.yAlign === "top" || frame.yAlign === "center" || frame.yAlign === "bottom" ? frame.yAlign : void 0;
+	return {
+		wrap,
+		posH: {
+			relativeFrom: hRel,
+			...align ? { align } : { offsetPt: frame.xPt ?? pt(0) }
+		},
+		posV: {
+			relativeFrom: vRel,
+			...vAlign ? { align: vAlign } : { offsetPt: frame.yPt ?? pt(0) }
+		}
+	};
+}
+/**
+* A drawing's width when it states one as a share of the page or the margins.
+*
+* @param rel     The relative size, if any.
+* @param content The margin box's width.
+* @param box     The page box, when the caller knows it.
+* @returns The width in points, or `undefined` when none is stated.
+*/
+function relativeWidth(rel, content, box) {
+	if (!rel?.widthPct) return void 0;
+	const from = rel.widthFrom;
+	return (box === void 0 || from === void 0 || from === "margin" ? content : from === "page" ? box.pageWidthPt : from === "leftMargin" ? box.marginLeftPt : box.marginRightPt) * rel.widthPct;
 }
-function layoutBodyElement(el, options, fontResources, imageResources, contentWidth, maxHeight) {
+/** The height twin of {@link relativeWidth}; the margin box's height is the page's content height. */
+function relativeHeight(rel, contentHeight, box) {
+	if (!rel?.heightPct) return void 0;
+	const from = rel.heightFrom;
+	const base = box === void 0 || from === void 0 || from === "margin" ? contentHeight : from === "page" ? box.pageHeightPt : from === "topMargin" ? box.marginTopPt : box.marginBottomPt;
+	return base === void 0 ? void 0 : base * rel.heightPct;
+}
+function laidOutBlocksFor(elements, options, fontResources, contentWidth, imageResources, box) {
+	const frames = frameGroups(elements);
+	return elements.map((el, idx) => {
+		const group = frames.starts.get(idx);
+		if (group) return layoutFrameBlock(group, options, fontResources, imageResources, contentWidth);
+		if (frames.continued.has(idx)) return emptyBlock(options);
+		return layoutBodyElement(el, options, fontResources, imageResources, contentWidth, void 0, box);
+	});
+}
+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);
+	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);
+	return layoutShapeBlock(el.shape, options, fontResources, imageResources, contentWidth, maxHeight, box);
 }
-function layoutImageBlock(image, imageResources, contentWidth) {
-	let widthPt = image.width;
-	let heightPt = image.height;
-	if (widthPt > contentWidth) {
+function layoutImageBlock(image, imageResources, contentWidth, maxHeight, box) {
+	let widthPt = relativeWidth(image.relativeSize, contentWidth, box) ?? image.width;
+	let heightPt = relativeHeight(image.relativeSize, maxHeight, box) ?? (image.relativeSize?.widthPct && image.width > 0 ? image.height * (widthPt / image.width) : image.height);
+	if (widthPt > contentWidth && !image.float) {
 		const scale = contentWidth / widthPt;
 		widthPt = contentWidth;
 		heightPt = heightPt * scale;
 	}
+	let drawInset;
+	const eff = image.effectExtent;
+	if (eff) {
+		const s = image.width > 0 ? widthPt / image.width : 1;
+		let box = {
+			dxPt: eff.leftPt * s,
+			dyTopPt: eff.topPt * s,
+			widthPt,
+			heightPt
+		};
+		let reservedW = widthPt + (eff.leftPt + eff.rightPt) * s;
+		let reservedH = heightPt + (eff.topPt + eff.bottomPt) * s;
+		if (reservedW > contentWidth) {
+			const k = contentWidth / reservedW;
+			reservedW = contentWidth;
+			reservedH *= k;
+			box = {
+				dxPt: box.dxPt * k,
+				dyTopPt: box.dyTopPt * k,
+				widthPt: box.widthPt * k,
+				heightPt: box.heightPt * k
+			};
+		}
+		widthPt = reservedW;
+		heightPt = reservedH;
+		drawInset = box;
+	}
 	const res = image.resource ? imageResources?.get(image.resource) : void 0;
 	const resolvedAlignment = image.paragraphProperties.alignment ?? "left";
 	return {
@@ -565,27 +997,34 @@ function layoutImageBlock(image, imageResources, contentWidth) {
 		heightPt,
 		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 } : {},
+		...image.flipV ? { flipV: true } : {},
+		...drawInset ? { drawInset } : {},
 		spacingBeforePt: image.paragraphProperties.spacingBefore ?? 0,
 		spacingAfterPt: image.paragraphProperties.spacingAfter ?? 0,
 		...image.altText ? { altText: image.altText } : {},
 		...image.float ? { float: image.float } : {}
 	};
 }
-function layoutShapeBlock(shape, options, fontResources, imageResources, contentWidth, maxHeight) {
-	let widthPt = shape.width;
-	let heightPt = shape.height;
-	if (widthPt > contentWidth && widthPt > 0) {
+function layoutShapeBlock(shape, options, fontResources, imageResources, contentWidth, maxHeight, box, fitPass = 0) {
+	let widthPt = relativeWidth(shape.relativeSize, contentWidth, box) ?? shape.width;
+	let heightPt = relativeHeight(shape.relativeSize, maxHeight, box) ?? (shape.relativeSize?.widthPct && shape.width > 0 ? shape.height * (widthPt / shape.width) : shape.height);
+	if (!shape.float && widthPt > contentWidth && widthPt > 0) {
 		const scale = contentWidth / widthPt;
 		widthPt = contentWidth;
 		heightPt *= scale;
 	}
-	if (maxHeight !== void 0 && heightPt > maxHeight && heightPt > 0) {
+	if (!shape.float && maxHeight !== void 0 && heightPt > maxHeight && heightPt > 0) {
 		const scale = maxHeight / heightPt;
 		widthPt *= scale;
 		heightPt = maxHeight;
 	}
-	const paths = buildShapePaths(shape.geometry, widthPt, heightPt);
 	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 fillColorHex = shape.fill.kind === "solid" ? shape.fill.colorHex : fillGradient ? gradientToSolid(fillGradient) : void 0;
 	const stroke = buildStroke(shape.line);
 	const t = shape.transform;
@@ -596,35 +1035,153 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 	const insetTopPt = text?.insetTop ?? 3.6;
 	const insetBottomPt = text?.insetBottom ?? 3.6;
 	const textLines = [];
+	const textCharts = /* @__PURE__ */ new Map();
+	const textShapes = /* @__PURE__ */ new Map();
+	const textTables = /* @__PURE__ */ new Map();
+	const textLineGaps = /* @__PURE__ */ new Map();
 	let textHeightPt = 0;
+	const vertical = text?.vertical;
 	if (text && text.content.length > 0) {
-		const innerWidth = Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		const innerWidth = vertical ? Math.max(1, heightPt - insetTopPt - insetBottomPt) : Math.max(1, widthPt - insetLeftPt - insetRightPt);
 		for (const el of text.content) {
-			if (el.kind !== "paragraph") continue;
+			if (el.kind === "image") {
+				const res = el.image.resource ? imageResources?.get(el.image.resource) : void 0;
+				const scaled = Math.min(1, innerWidth / Math.max(1, el.image.width));
+				const line = {
+					tokens: [{
+						kind: "image",
+						imageResourceName: res?.resourceName ?? "",
+						widthPt: el.image.width * scaled,
+						heightPt: el.image.height * scaled,
+						isSpace: false,
+						bidiLevel: 0
+					}],
+					contentWidthPt: el.image.width * scaled,
+					maxFontSizePt: el.image.height * scaled,
+					availableWidthPt: innerWidth,
+					firstLine: true,
+					resolved: resolveParagraphProperties(el.image.paragraphProperties, options.styles),
+					isLastInParagraph: true
+				};
+				textLines.push(line);
+				textHeightPt += computeLineHeight(line, line.resolved);
+				continue;
+			}
+			if (el.kind === "chart") {
+				const laid = layoutChartBlock(el.chart, options, fontResources, innerWidth);
+				const line = {
+					tokens: [],
+					contentWidthPt: laid.widthPt,
+					maxFontSizePt: laid.heightPt,
+					availableWidthPt: innerWidth,
+					firstLine: true,
+					resolved: resolveParagraphProperties(el.chart.paragraphProperties, options.styles),
+					isLastInParagraph: true
+				};
+				textCharts.set(textLines.length, laid);
+				textLines.push(line);
+				textHeightPt += computeLineHeight(line, line.resolved);
+				continue;
+			}
+			if (el.kind === "shape") {
+				const laid = layoutShapeBlock(el.shape, options, fontResources, imageResources, innerWidth);
+				const line = {
+					tokens: [],
+					contentWidthPt: laid.widthPt,
+					maxFontSizePt: laid.heightPt,
+					availableWidthPt: innerWidth,
+					firstLine: true,
+					resolved: resolveParagraphProperties(el.shape.paragraphProperties, options.styles),
+					isLastInParagraph: true
+				};
+				textShapes.set(textLines.length, laid);
+				textLines.push(line);
+				textHeightPt += computeLineHeight(line, line.resolved);
+				continue;
+			}
+			if (el.kind === "table") {
+				const laid = layoutTableBlock(el.table, options, fontResources, imageResources, innerWidth);
+				const line = {
+					tokens: [],
+					contentWidthPt: laid.totalWidthPt,
+					maxFontSizePt: laid.heightPt,
+					metricHeightPt: laid.heightPt,
+					availableWidthPt: innerWidth,
+					firstLine: true,
+					resolved: resolveParagraphProperties({}, options.styles),
+					isLastInParagraph: true
+				};
+				textTables.set(textLines.length, laid);
+				textLines.push(line);
+				textHeightPt += computeLineHeight(line, line.resolved);
+				continue;
+			}
 			const blk = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, innerWidth);
-			const lines = blk.lines.length > 0 ? blk.lines : [{
-				tokens: [],
-				contentWidthPt: 0,
-				maxFontSizePt: el.paragraph.runs[0]?.properties.fontSizePt ?? options.styles.defaultRunProperties.fontSizePt ?? pt(11),
-				availableWidthPt: innerWidth,
-				firstLine: true,
-				resolved: blk.resolved,
-				isLastInParagraph: true
-			}];
-			for (const line of lines) {
+			const before = textLines.length > 0 ? blk.spacingBeforePt : 0;
+			if (before > 0) {
+				const last = textLines.length - 1;
+				textLineGaps.set(last, (textLineGaps.get(last) ?? 0) + before);
+				textHeightPt += before;
+			}
+			for (const line of blk.lines) {
 				textLines.push(line);
 				textHeightPt += computeLineHeight(line, blk.resolved);
 			}
+			if (blk.spacingAfterPt > 0) {
+				const last = textLines.length - 1;
+				textLineGaps.set(last, (textLineGaps.get(last) ?? 0) + blk.spacingAfterPt);
+			}
 			textHeightPt += blk.spacingAfterPt;
 		}
 	}
+	if (text?.autoFit && !vertical && textLines.length > 0) heightPt = textHeightPt + insetTopPt + insetBottomPt;
+	if (text?.fitToBox === true && textLines.length > 0 && fitPass < MAX_FIT_PASSES) {
+		const innerW = Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		const innerH = Math.max(1, heightPt - insetTopPt - insetBottomPt);
+		let widest = 0;
+		let running = 0;
+		let paragraphs = 0;
+		for (const l of textLines) {
+			running += l.contentWidthPt;
+			if (l.isLastInParagraph) {
+				widest = Math.max(widest, running);
+				running = 0;
+				paragraphs++;
+			}
+		}
+		widest = Math.max(1, widest, running);
+		const perLine = textHeightPt / Math.max(1, textLines.length);
+		const naturalHeight = Math.max(1, perLine * Math.max(1, paragraphs || textLines.length));
+		const k = Math.min(innerW / widest, innerH / naturalHeight);
+		if (Number.isFinite(k) && k > .05 && k < 20 && Math.abs(k - 1) > .02) return layoutShapeBlock({
+			...shape,
+			text: scaleTextBody(text, k)
+		}, options, fontResources, imageResources, contentWidth, maxHeight, box, fitPass + 1);
+	}
+	const paths = buildShapePaths(shape.geometry, widthPt, heightPt);
+	const markerPaths = lineEndPaths(paths, shape.line, stroke?.widthPt ?? 0);
+	const scale = shape.width > 0 ? widthPt / shape.width : 1;
+	const children = (shape.children ?? []).map((child) => ({
+		laid: layoutShapeBlock({
+			...child.shape,
+			width: pt(child.shape.width * scale),
+			height: pt(child.shape.height * scale)
+		}, options, fontResources, imageResources, Number.POSITIVE_INFINITY),
+		xPt: child.xPt * scale,
+		yPt: child.yPt * scale
+	}));
 	return {
 		kind: "shape",
 		widthPt,
 		heightPt,
+		...children.length > 0 ? { children } : {},
 		paths,
+		...markerPaths.length > 0 ? { markerPaths } : {},
+		...fillImageResourceName ? { fillImageResourceName } : {},
+		...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,
@@ -634,16 +1191,160 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		spacingBeforePt: pp.spacingBefore ?? 0,
 		spacingAfterPt: pp.spacingAfter ?? 0,
 		textLines,
+		...textCharts.size > 0 ? { textCharts } : {},
+		...textShapes.size > 0 ? { textShapes } : {},
+		...textTables.size > 0 ? { textTables } : {},
+		...textLineGaps.size > 0 ? { textLineGaps } : {},
 		textHeightPt,
+		...text?.chain ? { textChain: text.chain } : {},
 		insetLeftPt,
 		insetRightPt,
 		insetTopPt,
 		insetBottomPt,
 		anchor: text?.anchor ?? "t",
+		...vertical ? { vertical } : {},
 		...shape.altText ? { altText: shape.altText } : {},
 		...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;
@@ -693,6 +1394,7 @@ function buildChartLayout(chart, widthPt, heightPt, font) {
 	};
 	const shapes = [];
 	if (scene.background) shapes.push(rectPrim(scene.background));
+	if (scene.plotBackground) shapes.push(rectPrim(scene.plotBackground));
 	for (const g of scene.gridlines ?? []) shapes.push(polylinePrim(g));
 	for (const pg of scene.polygons ?? []) shapes.push(polygonPrim(pg));
 	for (const r of scene.rects) shapes.push(rectPrim(r));
@@ -818,14 +1520,20 @@ function circlePath(cx, cy, r) {
 	const k = .5522847498307936 * r;
 	return new PathBuilder().moveTo(cx + r, cy).cubicTo(cx + r, cy + k, cx + k, cy + r, cx, cy + r).cubicTo(cx - k, cy + r, cx - r, cy + k, cx - r, cy).cubicTo(cx - r, cy - k, cx - k, cy - r, cx, cy - r).cubicTo(cx + k, cy - r, cx + r, cy - k, cx + r, cy).close().build();
 }
+function strokeOfRect(r) {
+	if (!r.strokeHex) return {};
+	const stroke = buildStroke({
+		colorHex: r.strokeHex,
+		width: pt(r.strokeWidthPt ?? 1),
+		...r.strokeDash ? { dash: r.strokeDash } : {}
+	});
+	return stroke ? { stroke } : {};
+}
 function rectPrim(r) {
 	return {
 		paths: [rectAtPath(r.x, r.y, r.w, r.h)],
 		...r.fillHex ? { fillColorHex: r.fillHex } : {},
-		...r.strokeHex ? { stroke: {
-			colorHex: r.strokeHex,
-			widthPt: r.strokeWidthPt ?? 1
-		} } : {}
+		...strokeOfRect(r)
 	};
 }
 function polylinePrim(p) {
@@ -915,10 +1623,16 @@ function collectImageResources(body, headersFooters, options) {
 			for (const run of el.paragraph.runs) if (run.inlineImage?.resource) seen.add(run.inlineImage.resource);
 		} else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
 		else if (el.kind === "shape") {
-			if (el.shape.text) visit(el.shape.text.content);
+			const shapeImages = (sh) => {
+				if (sh.fill.imageResource) seen.add(sh.fill.imageResource);
+				if (sh.text) visit(sh.text.content);
+				for (const child of sh.children ?? []) shapeImages(child.shape);
+			};
+			shapeImages(el.shape);
 		}
 	};
 	visit(body);
+	if (options.pageBackgroundFill?.imageResource !== void 0) seen.add(options.pageBackgroundFill.imageResource);
 	for (const hf of headersFooters.values()) visit(hf);
 	for (const note of options.footnotes?.values() ?? []) visit(note);
 	for (const note of options.endnotes?.values() ?? []) visit(note);
@@ -928,6 +1642,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 });
@@ -942,12 +1665,296 @@ function collectImageResources(body, headersFooters, options) {
 	}
 	return out;
 }
-function drawBlocksSequentially(blocks, startX, startY, pageHeight, structId) {
+function chartPageItems(laid, x, bottomYUp, pageHeight, structId) {
+	const fig = structId !== void 0 ? { structId } : {};
+	const out = [];
+	for (const sh of laid.layout.shapes) out.push({
+		type: "shape",
+		shape: {
+			paths: sh.paths,
+			...sh.fillColorHex ? { fillColorHex: sh.fillColorHex } : {},
+			...sh.stroke ? { stroke: sh.stroke } : {},
+			transform: flipTransform([
+				1,
+				0,
+				0,
+				1,
+				x,
+				bottomYUp
+			], pageHeight)
+		},
+		...fig
+	});
+	for (const t of laid.layout.texts) out.push({
+		type: "line",
+		line: t.line,
+		originX: pt(x + t.x),
+		baselineY: pt(pageHeight - (bottomYUp + t.y)),
+		...t.rotationDeg ? { rotationDeg: t.rotationDeg } : {},
+		...fig
+	});
+	return out;
+}
+function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
+	if (sh.textLines.length === 0) return;
+	if (sh.vertical) {
+		const up = sh.vertical === "vert270";
+		const innerHeight = Math.max(1, sh.heightPt - sh.insetTopPt - sh.insetBottomPt);
+		let across = sh.anchor === "b" ? sh.widthPt - sh.insetRightPt - sh.textHeightPt : sh.anchor === "ctr" ? (sh.widthPt - sh.textHeightPt) / 2 : sh.insetLeftPt;
+		for (const line of sh.textLines) {
+			const h = computeLineHeight(line, line.resolved);
+			const lineOffset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, innerHeight);
+			const off = lineBaselineOffset(line, line.resolved);
+			const baselineAcross = up ? across + h - off : across + off;
+			sink.push({
+				type: "line",
+				line,
+				originX: pt(up ? x + baselineAcross : x + sh.widthPt - baselineAcross),
+				baselineY: pt(pageHeight - (up ? bottomYUp + sh.insetBottomPt + lineOffset : bottomYUp + sh.heightPt - sh.insetTopPt - lineOffset)),
+				rotationDeg: up ? 90 : -90,
+				...figId !== void 0 ? { structId: figId } : {}
+			});
+			across += h;
+		}
+		return;
+	}
+	const shapeTop = bottomYUp + sh.heightPt;
+	const innerWidth = Math.max(1, sh.widthPt - sh.insetLeftPt - sh.insetRightPt);
+	let textY;
+	if (sh.anchor === "b") textY = bottomYUp + sh.insetBottomPt + sh.textHeightPt;
+	else if (sh.anchor === "ctr") textY = bottomYUp + (sh.heightPt + sh.textHeightPt) / 2;
+	else textY = shapeTop - sh.insetTopPt;
+	sh.textLines.forEach((line, i) => {
+		textY -= computeLineHeight(line, line.resolved);
+		const lineOffset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, innerWidth);
+		const nested = sh.textCharts?.get(i);
+		if (nested) {
+			sink.push(...chartPageItems(nested, x + sh.insetLeftPt + lineOffset, textY, pageHeight, figId));
+			return;
+		}
+		const drawing = sh.textShapes?.get(i);
+		if (drawing) {
+			emitShapeItems(drawing, x + sh.insetLeftPt + lineOffset, textY, sink, pageHeight, figId);
+			return;
+		}
+		const table = sh.textTables?.get(i);
+		if (table) {
+			let rowY = textY + table.heightPt;
+			for (const row of table.rows) {
+				emitRowChunk(sink, row, x + sh.insetLeftPt + lineOffset + table.xOffsetPt, rowY, pageHeight, table.colCount);
+				rowY -= row.heightPt;
+			}
+			return;
+		}
+		sink.push({
+			type: "line",
+			line,
+			originX: pt(x + sh.insetLeftPt + lineOffset),
+			baselineY: pt(pageHeight - (textY + lineBaselineOffset(line, line.resolved))),
+			...figId !== void 0 ? { structId: 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: {
+			paths: sh.paths,
+			transform: flipTransform(buildShapeTransform(x, bottomYUp, sh.widthPt, sh.heightPt, sh.rotation60k, sh.flipH, sh.flipV), pageHeight)
+		},
+		...figId !== void 0 ? { structId: figId } : {}
+	});
+	if (sh.markerPaths && sh.stroke) sink.push({
+		type: "shape",
+		shape: {
+			paths: sh.markerPaths,
+			fillColorHex: sh.stroke.colorHex,
+			transform: flipTransform(buildShapeTransform(x, bottomYUp, sh.widthPt, sh.heightPt, sh.rotation60k, sh.flipH, sh.flipV), pageHeight)
+		},
+		...figId !== void 0 ? { structId: figId } : {}
+	});
+	if (sh.paths.some((path) => path.segments.length > 0)) sink.push({
+		type: "shape",
+		shape: {
+			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)
+		},
+		...figId !== void 0 ? { structId: figId } : {}
+	});
+	for (const child of sh.children ?? []) emitShapeItems(child.laid, x + child.xPt, bottomYUp + sh.heightPt - child.yPt - child.laid.heightPt, sink, pageHeight, figId);
+	emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId);
+}
+/**
+* §20.1.2.2.24 — the four rules of a picture's own frame, around the box the
+* picture is drawn in. Borders paint after images and before shapes, so the
+* frame lands on top of the picture the way Word draws it.
+*
+* @param outline  The picture's frame.
+* @param x        Left edge of the picture box.
+* @param topY     Distance from the page TOP down to the box's top edge.
+* @param widthPt  Box width.
+* @param heightPt Box height.
+* @param structId Tagged-PDF structure node the picture belongs to.
+* @returns One {@link BorderItem} per side.
+*/
+function pictureOutlineItems(outline, x, topY, widthPt, heightPt, structId) {
+	return [
+		"top",
+		"bottom",
+		"left",
+		"right"
+	].map((side) => ({
+		type: "border",
+		side,
+		x: pt(x),
+		y: pt(topY),
+		width: pt(widthPt),
+		height: pt(heightPt),
+		borderSizePt: outline.widthPt,
+		borderColorHex: outline.colorHex,
+		...structId !== void 0 ? { structId } : {}
+	}));
+}
+function bandAnchor(float, widthPt, contentWidth, bandLeftPt = 0) {
+	if (!float) return void 0;
+	const align = float.posH?.align;
+	if (align === "right") return contentWidth - widthPt;
+	if (align === "center") return (contentWidth - widthPt) / 2;
+	if (align === "left") return 0;
+	const offset = float.posH?.offsetPt ?? 0;
+	return float.posH?.relativeFrom === "page" ? offset - bandLeftPt : offset;
+}
+/**
+* §20.4.2.3 — how far DOWN the page a band's anchored drawing starts, in the
+* band emitter's y-UP frame. A `page`-relative anchor is measured from the
+* paper's own top edge, whatever the band's cursor has reached: n773061.docx
+* hangs its header text box 92pt down the page and, measured from the header's
+* first paragraph, it landed 60pt lower than Word and LibreOffice put it.
+*
+* @param float      The anchor.
+* @param cursorY    The band's cursor (y-up), where a paragraph-relative
+*                   anchor is measured from.
+* @param pageHeight The page height.
+* @returns The drawing's top edge, y-up.
+*/
+function bandAnchorTop(float, cursorY, pageHeight, heightPt = 0, margins) {
+	const align = float.posV?.align;
+	if (align !== void 0) {
+		const page = float.posV?.relativeFrom === "page" || !margins;
+		const topYUp = page ? pageHeight : pageHeight - margins.top;
+		const bottomYUp = page ? 0 : margins.bottom;
+		if (align === "top") return topYUp;
+		if (align === "bottom") return bottomYUp + heightPt;
+		return bottomYUp + (topYUp - bottomYUp + heightPt) / 2;
+	}
+	const offset = float.posV?.offsetPt ?? 0;
+	return float.posV?.relativeFrom === "page" ? pageHeight - offset : cursorY - offset;
+}
+function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth, structId, bandMargins) {
 	const out = [];
 	let cursorY = startY;
-	for (const block of blocks) {
-		if (block.kind !== "paragraph") continue;
+	const isBehind = (b) => "float" in b && b.float?.behind === true;
+	const ordered = blocks.some(isBehind) ? [...blocks.filter(isBehind), ...blocks.filter((b) => !isBehind(b))] : blocks;
+	for (const block of ordered) {
+		if (block.kind === "table") {
+			const tableX = startX + block.xOffsetPt;
+			for (const row of block.rows) {
+				emitRowChunk(out, row, tableX, cursorY, pageHeight, block.colCount);
+				cursorY -= row.heightPt;
+			}
+			continue;
+		}
+		if (block.kind === "chart") {
+			cursorY -= block.spacingBeforePt + block.heightPt;
+			const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, contentWidth);
+			out.push(...chartPageItems(block, startX + offset, cursorY, pageHeight, structId));
+			cursorY -= block.spacingAfterPt;
+			continue;
+		}
+		if (block.kind === "image") {
+			cursorY -= block.spacingBeforePt;
+			const anchored = bandAnchor(block.float, block.widthPt, contentWidth, startX);
+			const offset = anchored ?? alignmentOffset(block.resolvedAlignment, block.widthPt, contentWidth);
+			const top = anchored === void 0 || !block.float ? cursorY : bandAnchorTop(block.float, cursorY, pageHeight, block.heightPt, bandMargins);
+			out.push({
+				type: "image",
+				x: pt(startX + offset),
+				y: pt(pageHeight - top),
+				width: pt(block.widthPt),
+				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 } : {}
+			});
+			if (block.outline) out.push(...pictureOutlineItems(block.outline, startX + offset, pageHeight - top, block.widthPt, block.heightPt, structId));
+			if (anchored === void 0) cursorY -= block.heightPt;
+			cursorY -= block.spacingAfterPt;
+			continue;
+		}
+		if (block.kind === "shape") {
+			cursorY -= block.spacingBeforePt;
+			const anchored = bandAnchor(block.float, block.widthPt, contentWidth, startX);
+			const offset = anchored ?? alignmentOffset(block.resolvedAlignment, block.widthPt, contentWidth);
+			const top = anchored === void 0 || !block.float ? cursorY : bandAnchorTop(block.float, cursorY, pageHeight, block.heightPt, bandMargins);
+			emitShapeItems(block, startX + offset, top - block.heightPt, out, pageHeight, structId);
+			if (anchored === void 0) cursorY -= block.heightPt;
+			cursorY -= block.spacingAfterPt;
+			continue;
+		}
 		cursorY -= block.spacingBeforePt;
+		const bandTopY = cursorY;
 		for (const line of block.lines) {
 			const h = computeLineHeight(line, block.resolved);
 			cursorY -= h;
@@ -957,14 +1964,60 @@ function drawBlocksSequentially(blocks, startX, startY, pageHeight, structId) {
 				type: "line",
 				line,
 				originX: pt(startX + indentLeft + offset),
-				baselineY: pt(pageHeight - (cursorY + lineDescent(line))),
+				baselineY: pt(pageHeight - (cursorY + lineBaselineOffset(line, block.resolved))),
 				...structId !== void 0 ? { structId } : {}
 			});
 		}
+		out.push(...paragraphDecoration(block.resolved, startX + block.resolved.indentLeft, startX + contentWidth - block.resolved.indentRight, bandTopY, cursorY, pageHeight));
 		cursorY -= block.spacingAfterPt;
 	}
 	return out;
 }
+/**
+* §17.3.1.31 `w:shd` and §17.3.1.24 `w:pBdr` — the band behind a paragraph and
+* the rules around it, for a paragraph occupying `topY`…`bottomY` (both in the
+* y-up page frame) between `x0` and `x1`.
+*
+* @returns The fill and border items, in paint order.
+*/
+function paragraphDecoration(resolved, x0, x1, topY, bottomY, pageHeight) {
+	const out = [];
+	const width = Math.max(0, x1 - x0);
+	if (resolved.shading) out.push({
+		type: "fill",
+		x: pt(x0),
+		y: pt(pageHeight - topY),
+		width: pt(width),
+		height: pt(Math.max(0, topY - bottomY)),
+		fillColorHex: resolved.shading.colorHex
+	});
+	const borders = resolved.borders;
+	if (!borders) return out;
+	for (const side of [
+		"top",
+		"bottom",
+		"left",
+		"right"
+	]) {
+		const edge = borders[side];
+		if (!edge || edge.style === "none") continue;
+		const gap = edge.spacePt ?? 0;
+		const top = topY + gap;
+		const bottom = bottomY - gap;
+		out.push({
+			type: "border",
+			side,
+			x: pt(x0),
+			y: pt(pageHeight - top),
+			width: pt(width),
+			height: pt(Math.max(0, top - bottom)),
+			borderSizePt: edge.width ?? DEFAULT_BORDER_SIZE_EIGHTH * EIGHTH_PT,
+			borderColorHex: edge.colorHex ?? "000000",
+			...edge.style !== "single" ? { borderStyle: edge.style } : {}
+		});
+	}
+	return out;
+}
 function runFontKeyAndParsed(options, ascii, bold, italic) {
 	if (ascii && options.embeddedFonts) {
 		const name = ascii.trim().toLowerCase();
@@ -1000,7 +2053,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);
@@ -1015,6 +2068,10 @@ function collectFontResources(body, headersFooters, options) {
 		}
 		const shaped = shapeText(run.text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
 		for (const g of shaped.gids) bucket.gids.add(g);
+		if (run.text.includes("	")) for (const stop of resolveParagraphProperties(para.properties, options.styles).tabs) {
+			const ch = stop.leader === void 0 ? void 0 : TAB_LEADER_CHARS.get(stop.leader);
+			if (ch !== void 0) bucket.gids.add(parsed.glyphForCodepoint(ch.codePointAt(0)));
+		}
 	};
 	const addMath = (node) => {
 		for (const seg of mathGlyphSegments(node)) {
@@ -1031,30 +2088,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 el.paragraph.runs) {
-			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({
@@ -1065,8 +2140,13 @@ function collectFontResources(body, headersFooters, options) {
 			visit(cell.content);
 		}
 		else if (el.kind === "shape") {
-			if (el.shape.text) visit(el.shape.text.content);
-		} else if (el.kind === "chart") {
+			const shapeText = (sh) => {
+				if (sh.text) visit(sh.text.content);
+				for (const child of sh.children ?? []) shapeText(child.shape);
+			};
+			shapeText(el.shape);
+		} 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);
@@ -1093,6 +2173,16 @@ function collectFontResources(body, headersFooters, options) {
 		}
 	};
 	visit(body);
+	if ((options.sections ?? []).some((sec) => sec.properties.lineNumbering)) visit([{
+		kind: "paragraph",
+		paragraph: {
+			properties: {},
+			runs: [{
+				text: "0123456789",
+				properties: {}
+			}]
+		}
+	}]);
 	for (const hf of headersFooters.values()) visit(hf);
 	for (const note of options.footnotes?.values() ?? []) visit(note);
 	for (const note of options.endnotes?.values() ?? []) visit(note);
@@ -1135,17 +2225,83 @@ function collectFontResources(body, headersFooters, options) {
 	}
 	return out;
 }
+/**
+* The one line an empty paragraph still occupies — no tokens, but as tall as
+* the paragraph mark's own font (§17.3.1.31 `w:rPr` on the `w:pPr`, which is
+* exactly the run properties Word keeps for a paragraph that holds no runs).
+*/
+function emptyLine(paragraph, options, resolved, availableWidthPt, fontResources) {
+	const mark = resolveRunProperties(paragraph.properties.runProperties ?? {}, paragraph.properties, options.styles);
+	const fontSizePt = mark.fontSizePt;
+	const profile = options.layoutProfile ?? "ream";
+	const { variant } = options.registry.resolveByStyle(mark.bold, mark.italic);
+	const parsed = fontResources.get(variant)?.parsed;
+	const metric = profile !== "ream" && parsed ? fontLeadingPt(parsed, fontSizePt, profile) : void 0;
+	return {
+		tokens: [],
+		contentWidthPt: 0,
+		maxFontSizePt: fontSizePt,
+		availableWidthPt,
+		firstLine: true,
+		resolved,
+		isLastInParagraph: true,
+		...metric && metric.ascentPt + metric.descentPt > 0 ? {
+			metricHeightPt: metric.ascentPt + metric.descentPt + metric.lineGapPt,
+			metricDescentPt: metric.descentPt
+		} : {}
+	};
+}
 function layoutParagraphBlock(paragraph, options, fontResources, imageResources, contentWidth, lineWidths) {
-	const baseResolved = resolveParagraphProperties(paragraph.properties, options.styles);
+	const cascaded = resolveParagraphProperties(paragraph.properties, options.styles);
+	const baseResolved = options.gridLinePitchPt !== void 0 && cascaded.snapToGrid !== false ? {
+		...cascaded,
+		gridLinePitchPt: options.gridLinePitchPt
+	} : cascaded;
+	if (paragraph.properties.sectionBreak === true && paragraph.runs.length === 0) return {
+		kind: "paragraph",
+		resolved: baseResolved,
+		lines: [],
+		heightPt: 0,
+		spacingBeforePt: 0,
+		spacingAfterPt: 0
+	};
 	const baseDir = paragraphBaseDirection(paragraph, baseResolved);
-	const resolved = baseDir === "rtl" && baseResolved.alignment === "left" ? {
+	const swapAlign = (a) => a === "left" ? "right" : a === "right" ? "left" : a;
+	const resolved = baseResolved.bidi === true ? {
+		...baseResolved,
+		alignment: swapAlign(baseResolved.alignment),
+		indentLeft: baseResolved.indentRight,
+		indentRight: baseResolved.indentLeft
+	} : baseDir === "rtl" && baseResolved.alignment === "left" ? {
 		...baseResolved,
 		alignment: "right"
 	} : baseResolved;
-	const lines = wrap(tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir), paragraphMaxWidth(resolved, contentWidth, true), paragraphMaxWidth(resolved, contentWidth, false), resolved, options.hyphenator, options.layoutProfile ?? "ream", lineWidths);
+	const tokens = tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir);
+	const firstLineWidth = paragraphMaxWidth(resolved, contentWidth, true);
+	const otherWidth = paragraphMaxWidth(resolved, contentWidth, false);
+	const runWrap = (part, firstWidth, widths) => wrap(part, firstWidth, otherWidth, resolved, options.hyphenator, options.layoutProfile ?? "ream", options.doNotExpandShiftReturn === true, widths);
+	const parts = splitAtColumnBreaks(tokens);
+	const columnBreakLines = /* @__PURE__ */ new Set();
+	let wrapped;
+	if (parts.length === 1) wrapped = runWrap(tokens, firstLineWidth, lineWidths);
+	else {
+		wrapped = [];
+		for (const [i, part] of parts.entries()) {
+			const lines = runWrap(part, i === 0 ? firstLineWidth : otherWidth, lineWidths?.slice(wrapped.length));
+			if (i > 0 && lines.length > 0) columnBreakLines.add(wrapped.length);
+			wrapped.push(...i === 0 ? lines : lines.map((l) => ({
+				...l,
+				firstLine: false
+			})));
+		}
+	}
+	const lines = wrapped.length > 0 ? wrapped : [emptyLine(paragraph, options, resolved, Math.max(firstLineWidth, 0), fontResources)];
 	let heightPt = 0;
 	for (const line of lines) heightPt += computeLineHeight(line, resolved);
 	const numbering = paragraph.properties.numbering;
+	const breakIdx = paragraph.runs.findIndex((r) => r.pageBreak === true);
+	const leadingPageBreak = breakIdx >= 0 && paragraph.runs.slice(0, breakIdx + 1).every((r) => r.text === "" && r.inlineImage === void 0);
+	const trailingPageBreak = paragraph.runs.some((r, i) => r.pageBreak === true && (!leadingPageBreak || i > breakIdx));
 	return {
 		kind: "paragraph",
 		resolved,
@@ -1157,7 +2313,9 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 			numId: numbering.numId,
 			level: numbering.ilvl
 		} } : {},
-		...paragraph.runs.some((r) => r.pageBreak) ? { pageBreakAfter: true } : {},
+		...leadingPageBreak ? { pageBreakBefore: true } : {},
+		...trailingPageBreak ? { pageBreakAfter: true } : {},
+		...columnBreakLines.size > 0 ? { columnBreakLines } : {},
 		...paragraph.bookmarks && paragraph.bookmarks.length > 0 ? { bookmarks: paragraph.bookmarks } : {},
 		source: paragraph
 	};
@@ -1197,13 +2355,76 @@ function resolveMathItems(items, fontFor) {
 		};
 	});
 }
+/**
+* §17.3.2.5 `w:caps` / §17.3.2.33 `w:smallCaps` — the paragraph's runs as they
+* are DISPLAYED. A capitals run is upper-cased; a small-capitals run is too,
+* and the letters that were lower case are split out to be set smaller.
+*
+* @param paragraph The paragraph.
+* @param options   The render options (for the style cascade).
+* @returns The runs to lay out — the same array when none asks for capitals.
+*/
+function displayCapsRuns(paragraph, options) {
+	let any = false;
+	const out = [];
+	for (const raw of paragraph.runs) {
+		const run = raw.text.includes(SOFT_HYPHEN) ? (any = true, {
+			...raw,
+			text: raw.text.replaceAll(SOFT_HYPHEN, "")
+		}) : raw;
+		const resolved = run.text.length > 0 ? resolveRunProperties(run.properties, paragraph.properties, options.styles) : void 0;
+		if (!resolved || !resolved.caps && !resolved.smallCaps) {
+			out.push(run);
+			continue;
+		}
+		any = true;
+		if (resolved.caps) {
+			out.push({
+				...run,
+				text: run.text.toUpperCase()
+			});
+			continue;
+		}
+		let start = 0;
+		const wasLower = (i) => {
+			const ch = run.text[i];
+			return ch.toLowerCase() === ch && ch.toUpperCase() !== ch;
+		};
+		for (let i = 1; i <= run.text.length; i++) {
+			if (i < run.text.length && wasLower(i) === wasLower(start)) continue;
+			const segment = run.text.slice(start, i).toUpperCase();
+			out.push(wasLower(start) ? {
+				...run,
+				text: segment,
+				properties: {
+					...run.properties,
+					fontSizePt: pt(resolved.fontSizePt * .8)
+				}
+			} : {
+				...run,
+				text: segment
+			});
+			start = i;
+		}
+	}
+	return any ? out : paragraph.runs;
+}
 function tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir) {
-	const plans = paragraph.runs.map((run) => {
+	const plans = displayCapsRuns(paragraph, options).map((run) => {
 		if (run.inlineImage) {
-			const naturalW = run.inlineImage.width;
+			const eff = run.inlineImage.effectExtent;
+			const padW = (eff?.leftPt ?? 0) + (eff?.rightPt ?? 0);
+			const padH = (eff?.topPt ?? 0) + (eff?.bottomPt ?? 0);
+			const naturalW = run.inlineImage.width + padW;
 			const widthPt = Math.min(naturalW, contentWidth);
 			const scale = naturalW > 0 ? widthPt / naturalW : 1;
-			const heightPt = run.inlineImage.height * scale;
+			const heightPt = (run.inlineImage.height + padH) * scale;
+			const drawBox = eff ? {
+				dxPt: eff.leftPt * scale,
+				dyPt: eff.bottomPt * scale,
+				widthPt: run.inlineImage.width * scale,
+				heightPt: run.inlineImage.height * scale
+			} : void 0;
 			const res = run.inlineImage.resource ? imageResources?.get(run.inlineImage.resource) : void 0;
 			const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
 			const { fontKey } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
@@ -1215,7 +2436,16 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 				isImage: true,
 				imageWidthPt: widthPt,
 				imageHeightPt: heightPt,
-				imageResourceName: res?.resourceName ?? ""
+				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 } : {},
+				...run.inlineImage.flipV ? { imageFlipV: true } : {},
+				...drawBox ? { imageDrawBox: drawBox } : {}
 			};
 		}
 		if (run.math) {
@@ -1270,6 +2500,19 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 		...plan.resolvedRun.rtl ? { rtl: true } : {}
 	})), baseDir));
 }
+/**
+* Split a paragraph's tokens at every §17.3.3.1 column break, dropping the
+* break token itself (its line ends there anyway). One part ⇒ no break.
+*
+* @param tokens The paragraph's tokens in order.
+* @returns The parts, in order; always at least one.
+*/
+function splitAtColumnBreaks(tokens) {
+	const parts = [[]];
+	for (const t of tokens) if (t.kind === "text" && t.columnBreak) parts.push([]);
+	else parts[parts.length - 1].push(t);
+	return parts.filter((p, i) => i === 0 || p.length > 0);
+}
 function tokenizePlansLtr(plans) {
 	const tokens = [];
 	for (const plan of plans) {
@@ -1279,6 +2522,15 @@ function tokenizePlansLtr(plans) {
 				imageResourceName: plan.imageResourceName,
 				widthPt: plan.imageWidthPt,
 				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 } : {},
+				...plan.imageFlipV ? { flipV: true } : {},
+				...plan.imageDrawBox ? { drawBox: plan.imageDrawBox } : {},
 				isSpace: false,
 				bidiLevel: 0
 			});
@@ -1301,21 +2553,37 @@ function tokenizePlansLtr(plans) {
 			kind: "text",
 			text: t.text,
 			isSpace: t.isSpace,
+			...t.tab ? { tab: true } : {},
 			...plan.run.href !== void 0 ? { href: plan.run.href } : {},
 			...plan.run.footnoteRef !== void 0 ? { footnoteRef: plan.run.footnoteRef } : {},
 			...plan.run.anchor !== void 0 ? { anchor: plan.run.anchor } : {},
 			...plan.run.listMarker ? { listMarker: true } : {},
+			...plan.run.columnBreak ? { columnBreak: true } : {},
 			...highlight ? { highlight: true } : {},
 			resolvedRun: plan.resolvedRun,
 			font: plan.font,
 			fontSizePt: plan.fontSizePt,
 			...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
-			widthPt: plan.font.measure.textWidthPt(t.text, plan.fontSizePt),
+			widthPt: measureRunText(plan, t.text),
 			bidiLevel: 0
 		});
 	}
 	return tokens;
 }
+/**
+* §17.3.2.35 — a run's text measured with the space it puts between its
+* characters. PDF adds the same amount per glyph through `Tc`, so the width the
+* line is broken at and the width the page draws agree.
+*
+* @param plan The run being tokenized.
+* @param text The token's text.
+* @returns The advance width in points.
+*/
+function measureRunText(plan, text) {
+	const base = plan.font.measure.textWidthPt(text, plan.fontSizePt);
+	const extra = plan.resolvedRun.letterSpacingPt;
+	return extra === void 0 || extra === 0 ? base : base + extra * [...text].length;
+}
 function tokenizePlansBidi(plans, realLevels) {
 	const tokens = [];
 	let realIdx = 0;
@@ -1327,6 +2595,15 @@ function tokenizePlansBidi(plans, realLevels) {
 				imageResourceName: plan.imageResourceName,
 				widthPt: plan.imageWidthPt,
 				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 } : {},
+				...plan.imageFlipV ? { flipV: true } : {},
+				...plan.imageDrawBox ? { drawBox: plan.imageDrawBox } : {},
 				isSpace: false,
 				bidiLevel: realLevels[realIdx] ?? 0
 			});
@@ -1361,12 +2638,13 @@ function tokenizePlansBidi(plans, realLevels) {
 				...plan.run.footnoteRef !== void 0 ? { footnoteRef: plan.run.footnoteRef } : {},
 				...plan.run.anchor !== void 0 ? { anchor: plan.run.anchor } : {},
 				...plan.run.listMarker ? { listMarker: true } : {},
+				...plan.run.columnBreak ? { columnBreak: true } : {},
 				...(plan.run.commentRangeRefs?.length ?? 0) > 0 ? { highlight: true } : {},
 				resolvedRun: plan.resolvedRun,
 				font: plan.font,
 				fontSizePt: plan.fontSizePt,
 				...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
-				widthPt: plan.font.measure.textWidthPt(text, plan.fontSizePt),
+				widthPt: measureRunText(plan, text),
 				bidiLevel: curLevel
 			});
 		};
@@ -1393,6 +2671,7 @@ function paragraphBaseDirection(paragraph, resolved) {
 	if (resolved.bidi) return "rtl";
 	let text = "";
 	for (const run of paragraph.runs) {
+		if (run.listMarker === true) continue;
 		if (!run.inlineImage) text += run.text;
 		if (text.length > 64) break;
 	}
@@ -1405,16 +2684,29 @@ function paragraphMaxWidth(p, contentWidth, firstLine) {
 	const firstLineExtra = firstLine ? p.indentFirstLine : 0;
 	return Math.max(1, contentWidth - indentLeft - indentRight - firstLineExtra);
 }
+var HYPHENS = new Set([
+	45,
+	8208,
+	8211,
+	8212
+]);
+/** §17.3.3.29 — the optional hyphen, printed only where a line breaks on it. */
+var SOFT_HYPHEN = "­";
 function tokenizeText(text) {
 	const out = [];
 	if (text.length === 0) return out;
-	const re = /(\s+)|(\S+)/g;
+	const re = /(\t)|(\s+)|(\S+)/g;
 	let m;
 	while ((m = re.exec(text)) !== null) if (m[1] !== void 0) out.push({
-		text: m[1],
+		text: "",
+		isSpace: true,
+		tab: true
+	});
+	else if (m[2] !== void 0) out.push({
+		text: m[2],
 		isSpace: true
 	});
-	else if (m[2] !== void 0) for (const piece of splitCjkSegment(m[2])) out.push({
+	else if (m[3] !== void 0) for (const piece of splitCjkSegment(m[3])) out.push({
 		text: piece,
 		isSpace: false
 	});
@@ -1428,14 +2720,51 @@ function lastCodePoint(s) {
 function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 	const entries = [];
 	let prevBoxEndCp = null;
+	let prevWasImage = false;
 	for (const tok of tokens) {
+		const breaks = tok.isSpace ? tok.text.match(/\r\n|[\r\n]/gu)?.length ?? 0 : 0;
+		if (breaks > 0) {
+			for (let i = 0; i < breaks; i++) {
+				entries.push({
+					item: {
+						type: "glue",
+						width: 0,
+						stretch: 1e6,
+						shrink: 0
+					},
+					token: null
+				});
+				entries.push({
+					item: {
+						type: "penalty",
+						width: 0,
+						penalty: FORCED_BREAK,
+						flagged: false
+					},
+					token: null,
+					softBreak: true
+				});
+			}
+			prevBoxEndCp = null;
+			continue;
+		}
 		if (tok.isSpace || tok.kind === "image" || tok.kind === "math") {
+			if (tok.kind === "image" && (prevWasImage || prevBoxEndCp !== null)) entries.push({
+				item: {
+					type: "penalty",
+					width: 0,
+					penalty: 0,
+					flagged: false
+				},
+				token: null
+			});
+			prevWasImage = tok.kind === "image";
 			entries.push({
 				item: tok.isSpace ? {
 					type: "glue",
 					width: tok.widthPt,
 					stretch: tok.widthPt * .6,
-					shrink: tok.widthPt * .3
+					shrink: tok.widthPt * GLUE_SHRINK_RATIO
 				} : {
 					type: "box",
 					width: tok.widthPt
@@ -1446,7 +2775,7 @@ function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 			continue;
 		}
 		const startCp = tok.text.codePointAt(0) ?? 0;
-		if (prevBoxEndCp !== null && cjkBreakBetween(prevBoxEndCp, startCp)) entries.push({
+		if (prevWasImage || prevBoxEndCp !== null && cjkBreakBetween(prevBoxEndCp, startCp)) entries.push({
 			item: {
 				type: "penalty",
 				width: 0,
@@ -1455,10 +2784,12 @@ function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 			},
 			token: null
 		});
+		prevWasImage = false;
 		prevBoxEndCp = lastCodePoint(tok.text);
 		const positions = hyphenator ? hyphenator.hyphenate(tok.text) : [];
 		if (positions.length === 0) {
-			const chunks = maxLineWidthPt !== void 0 && maxLineWidthPt > 0 && tok.widthPt > maxLineWidthPt * 1.1 ? splitToWidth(tok, maxLineWidthPt) : void 0;
+			const tooWide = maxLineWidthPt !== void 0 && maxLineWidthPt > 0;
+			const chunks = (tooWide && tok.widthPt > maxLineWidthPt ? splitAtHyphens(tok) : void 0) ?? (tooWide && tok.widthPt > maxLineWidthPt * 1.1 ? splitToWidth(tok, maxLineWidthPt) : void 0);
 			if (chunks) {
 				chunks.forEach((chunk, ci) => {
 					if (ci > 0) entries.push({
@@ -1545,6 +2876,94 @@ function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 	});
 	return entries;
 }
+/** Word's own default when a document names none (§17.15.1.25): half an inch. */
+var DEFAULT_TAB_STOP_PT = 36;
+var TAB_LEADER_CHARS = new Map([
+	["dot", "."],
+	["hyphen", "-"],
+	["underscore", "_"],
+	["middleDot", "·"]
+]);
+/**
+* Give each tab on a line the width that carries it to its stop, and the
+* leader that fills the way there.
+*
+* §17.3.1.37 — a tab advances to a POSITION, not by a fixed amount, and where
+* that position is depends on how far the line has already run. Measured as
+* ordinary whitespace it collapsed to a space: the page numbers of
+* FDO77715.docx's index sat against their titles with no dot leader between,
+* and its header ran its left and right halves together on one line.
+*
+* A `right`, `center` or `decimal` stop positions the text AFTER the tab, so
+* each is resolved against the segment that follows it.
+*
+* @param tokens   The line's tokens, replaced in place.
+* @param resolved The paragraph's resolved properties: the stops and indents.
+* @param isFirst  Whether this is the paragraph's first line.
+*/
+function resolveTabs(tokens, resolved, isFirst, availableWidthPt) {
+	const stops = resolved.tabs;
+	let x = resolved.indentLeft + (isFirst ? resolved.indentFirstLine : 0);
+	for (let i = 0; i < tokens.length; i++) {
+		const tok = tokens[i];
+		if (!tok) continue;
+		if (!(tok.kind === "text" && tok.tab === true)) {
+			x += tok.widthPt;
+			continue;
+		}
+		let segment = 0;
+		let decimalAt = 0;
+		let seenDecimal = false;
+		for (let j = i + 1; j < tokens.length; j++) {
+			const next = tokens[j];
+			if (next.kind === "text" && next.tab === true) break;
+			if (!seenDecimal && next.kind === "text") {
+				const dot = next.text.indexOf(".");
+				if (dot >= 0) {
+					decimalAt = segment + next.font.measure.textWidthPt(next.text.slice(0, dot), next.fontSizePt);
+					seenDecimal = true;
+				}
+			}
+			segment += next.widthPt;
+		}
+		const stopAt = (sp) => sp.relativeTo === "center" ? availableWidthPt / 2 : sp.relativeTo === "right" ? availableWidthPt : sp.positionPt;
+		const stop = stops.find((sp) => stopAt(sp) > x + .01);
+		const hangingStop = isFirst && resolved.indentFirstLine < 0 && resolved.indentLeft > x + .01 ? resolved.indentLeft : void 0;
+		const explicitAt = stop ? stopAt(stop) : void 0;
+		const position = explicitAt !== void 0 && (hangingStop === void 0 || explicitAt <= hangingStop) ? explicitAt : hangingStop ?? (Math.floor(x / DEFAULT_TAB_STOP_PT) + 1) * DEFAULT_TAB_STOP_PT;
+		const alignment = stop?.alignment ?? "left";
+		if (segment === 0 && alignment !== "left") {
+			const after = tokens[i + 1];
+			if (after?.kind === "text" && after.tab === true) {
+				tokens[i] = {
+					...tok,
+					widthPt: 0,
+					text: ""
+				};
+				continue;
+			}
+		}
+		let target = position;
+		if (alignment === "right") target = position - segment;
+		else if (alignment === "center") target = position - segment / 2;
+		else if (alignment === "decimal") target = position - (seenDecimal ? decimalAt : segment);
+		const width = Math.max(0, target - x);
+		const leaderChar = stop?.leader === void 0 ? void 0 : TAB_LEADER_CHARS.get(stop.leader);
+		const text = leaderChar === void 0 ? "" : fillLeader(tok, leaderChar, width);
+		tokens[i] = {
+			...tok,
+			widthPt: width,
+			text
+		};
+		x += width;
+	}
+}
+/** As many leader characters as fit the gap, measured in the tab's own font. */
+function fillLeader(tab, leader, widthPt) {
+	const unit = tab.font.measure.textWidthPt(leader, tab.fontSizePt);
+	if (!(unit > 0)) return "";
+	return leader.repeat(Math.max(0, Math.floor(widthPt / unit)));
+}
 /**
 * Cut an unbreakable word into the widest pieces that fit `widthPt`, measured
 * with the token's own font. Each piece keeps the run's formatting, so the line
@@ -1555,6 +2974,24 @@ function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 * @returns The pieces in order, or undefined when even one character overruns
 *          (nothing can be gained by splitting then).
 */
+function splitAtHyphens(tok) {
+	if (tok.kind !== "text") return void 0;
+	const parts = [];
+	let start = 0;
+	for (let i = 0; i < tok.text.length; i++) {
+		if (!HYPHENS.has(tok.text.codePointAt(i) ?? 0)) continue;
+		if (i === start || i === tok.text.length - 1) continue;
+		parts.push(tok.text.slice(start, i + 1));
+		start = i + 1;
+	}
+	if (parts.length === 0) return void 0;
+	parts.push(tok.text.slice(start));
+	return parts.map((text) => ({
+		...tok,
+		text,
+		widthPt: tok.font.measure.textWidthPt(text, tok.fontSizePt)
+	}));
+}
 function splitToWidth(tok, widthPt) {
 	if (tok.kind !== "text") return void 0;
 	const chars = [...tok.text];
@@ -1585,18 +3022,19 @@ function splitToWidth(tok, widthPt) {
 }
 /** The fewest characters a mid-word break may leave on a line. */
 var MIN_SPLIT_CHARS = 6;
-function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, profile) {
+function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, profile, allowEmpty = false) {
 	let st = start;
 	let et = breakIdx;
 	while (st < et && (entries[st].token === null || !isFirst && entries[st].token?.isSpace === true)) st++;
 	const paints = (t) => t !== null && t !== void 0 && t.kind === "text" && (t.resolvedRun.underline !== "none" || t.resolvedRun.strike);
 	while (et > st && (entries[et - 1].token === null || entries[et - 1].token?.isSpace === true && !paints(entries[et - 1].token))) et--;
-	if (st >= et) return null;
+	if (st >= et && !allowEmpty) return null;
 	const lineTokens = [];
 	for (let i = st; i < et; i++) {
 		const ft = entries[i].token;
 		if (ft) lineTokens.push(ft);
 	}
+	resolveTabs(lineTokens, resolved, isFirst, availableWidthPt);
 	const hyphenWidth = entries[breakIdx]?.hyphenWidthPt;
 	if (hyphenWidth !== void 0) {
 		const lastIdx = lineTokens.length - 1;
@@ -1616,8 +3054,10 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 	let metricAscent = 0;
 	let metricDescent = 0;
 	let metricLineGap = 0;
+	const prints = lineTokens.some((t) => !t.isSpace);
 	for (const t of lineTokens) {
 		contentWidth += t.widthPt;
+		if (prints && t.isSpace) continue;
 		const sz = tokenLineSize(t);
 		if (sz > maxSize) maxSize = sz;
 		if (t.kind === "math") {
@@ -1647,10 +3087,26 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 		} : {}
 	};
 }
-function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, lineWidths) {
+function withLeadingTabWidths(tokens, resolved, firstLineWidth) {
+	const first = tokens[0];
+	if (!(first?.kind === "text" && first.tab === true)) return tokens;
+	const probe = tokens.map((t) => ({ ...t }));
+	resolveTabs(probe, resolved, true, firstLineWidth);
+	const out = tokens.slice();
+	for (let i = 0; i < out.length; i++) {
+		const tok = out[i];
+		if (!(tok.kind === "text" && tok.tab === true)) break;
+		out[i] = {
+			...tok,
+			widthPt: probe[i].widthPt
+		};
+	}
+	return out;
+}
+function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, noExpandShiftReturn, lineWidths) {
 	if (tokens.length === 0) return [];
 	const widths = lineWidths ?? [firstLineWidth, otherWidth];
-	const entries = paragraphItemStream(tokens, hyphenator, Math.max(0, ...widths));
+	const entries = paragraphItemStream(withLeadingTabWidths(tokens, resolved, widths[0] ?? firstLineWidth), hyphenator, Math.max(0, ...widths));
 	const items = entries.map((e) => e.item);
 	const breaks = profile === "ream" ? breakLines(items, widths).breaks : greedyBreakLines(items, widths);
 	const buildLines = (at) => {
@@ -1658,10 +3114,13 @@ function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile,
 		let start = 0;
 		let isFirst = true;
 		let lineIdx = 0;
-		for (const breakIdx of at) {
+		for (const [i, breakIdx] of at.entries()) {
 			const width = lineIdx < widths.length ? widths[lineIdx] : widths[widths.length - 1];
-			const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, profile);
-			if (line) out.push(line);
+			const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, profile, i < at.length - 1);
+			if (line) out.push(noExpandShiftReturn && entries[breakIdx]?.softBreak ? {
+				...line,
+				noJustify: true
+			} : line);
 			start = breakIdx + 1;
 			isFirst = false;
 			lineIdx++;
@@ -1695,11 +3154,17 @@ function fontLeadingPt(parsed, sizePt, profile) {
 	};
 }
 function computeLineHeight(line, p) {
+	const natural = naturalLineHeight(line, p);
+	const pitch = p.gridLinePitchPt;
+	if (pitch !== void 0 && pitch > 0) return Math.ceil(natural / pitch - 1e-6) * pitch;
+	return natural;
+}
+function naturalLineHeight(line, p) {
 	const fontSize = line.maxFontSizePt || 12;
 	const natural = line.metricHeightPt ?? fontSize * 1.2;
 	const mathH = (line.mathAscentPt ?? 0) + (line.mathDescentPt ?? 0);
 	const mathNeed = mathH > 0 ? mathH * 1.05 : 0;
-	if (p.spacingLineRule === "exact" && p.spacingLine > 0) return Math.max(p.spacingLine, mathNeed);
+	if (p.spacingLineRule === "exact" && p.spacingLine >= 0) return Math.max(p.spacingLine, mathNeed);
 	if (p.spacingLineRule === "atLeast" && p.spacingLine > 0) return Math.max(natural, p.spacingLine, mathNeed);
 	const lineTwips = Math.round(p.spacingLine * 20);
 	const multiple = lineTwips > 0 ? lineTwips / 240 : 1;
@@ -1710,6 +3175,37 @@ function lineDescent(line) {
 	const base = line.metricDescentPt ?? fs * .2;
 	return Math.max(base, line.mathDescentPt ?? 0);
 }
+/**
+* §17.3.1.33 — how far the baseline stands above the BOTTOM of the line box,
+* which is what says where the extra height of a spaced-out line goes.
+*
+* A line given a fixed height (`exact`, `atLeast`) hangs from the bottom of its
+* box: the space a taller `w:line` asks for opens ABOVE the text, which is what
+* makes "at least 24pt" push a heading down its own line.
+*
+* `auto` — Word's "Multiple", the 1.15 every modern template sets — scales the
+* line instead, and the space it gains falls BELOW: the first line of a spaced
+* paragraph starts exactly where a single-spaced one does. Read the other way
+* round, fdo80800.docx's 1.5-line cells sat 6.6pt under the plain cell beside
+* them, where Word and LibreOffice write all three on one baseline.
+*
+* §17.6.5 — the extra a document GRID adds is not the paragraph's at all, and
+* is split evenly: the line is centred on its grid row.
+*
+* @param line The laid-out line.
+* @param p    The owning paragraph's resolved properties.
+* @returns The distance from the line box's bottom edge up to the baseline.
+*/
+function lineBaselineOffset(line, p) {
+	const descent = lineDescent(line);
+	const natural = naturalLineHeight(line, p);
+	const singled = naturalLineHeight(line, {
+		...p,
+		spacingLineRule: "auto",
+		spacingLine: pt(0)
+	});
+	return descent + (p.spacingLineRule === "auto" ? Math.max(0, natural - singled) : 0) + (computeLineHeight(line, p) - natural) / 2;
+}
 function alignmentOffset(alignment, lineWidth, available) {
 	if (alignment === "right") return Math.max(0, available - lineWidth);
 	if (alignment === "center") return Math.max(0, (available - lineWidth) / 2);
@@ -1724,7 +3220,7 @@ function layoutTableBlock(table, options, fontResources, imageResources, content
 	for (let r = 0; r < table.rows.length; r++) {
 		const rl = layoutTableRow(table.rows[r], r, table.rows.length, colCount, table.properties, columnWidthsPt, options, fontResources, imageResources, mergeRoles[r] ?? [], aboveBordersByCol);
 		const nextAbove = [];
-		let ci = 0;
+		let ci = table.rows[r].properties.gridBefore ?? 0;
 		for (const cell of table.rows[r].cells) {
 			const span = Math.max(1, cell.properties.colSpan ?? 1);
 			for (let k = 0; k < span; k++) nextAbove[ci + k] = cell.properties.borders;
@@ -1738,17 +3234,46 @@ function layoutTableBlock(table, options, fontResources, imageResources, content
 			...rp.pageBreakBefore ? { breakBefore: true } : {}
 		} : rl);
 	}
+	growRowsForMerges(rows);
 	const heightPt = rows.reduce((s, r) => s + r.heightPt, 0);
 	const totalWidthPt = columnWidthsPt.reduce((s, w) => s + w, 0);
+	const xOffsetPt = (table.properties.indentPt ?? 0) + tableXOffset(table.properties.alignment, contentWidth, totalWidthPt);
 	return {
 		kind: "table",
+		...table.properties.float ? { float: table.properties.float } : {},
 		rows,
 		heightPt,
 		totalWidthPt,
 		colCount,
-		xOffsetPt: tableXOffset(table.properties.alignment, contentWidth, totalWidthPt)
+		xOffsetPt
 	};
 }
+/**
+* §17.4.85 `w:vMerge` — make every vertical merge fit. Each row is already as
+* tall as its own (unmerged) cells; a merge that needs more than its rows add
+* up to grows the LAST row of the run, which is where Word puts the slack.
+*
+* @param rows The table's laid-out rows, adjusted in place.
+*/
+function growRowsForMerges(rows) {
+	for (let r = 0; r < rows.length; r++) for (const cell of rows[r].cells) {
+		if (cell.mergeRole !== "start") continue;
+		let last = r;
+		for (let k = r + 1; k < rows.length; k++) {
+			const below = rows[k].cells.find((c) => c.colStart === cell.colStart);
+			if (!below || below.mergeRole !== "middle" && below.mergeRole !== "end") break;
+			last = k;
+			if (below.mergeRole === "end") break;
+		}
+		let have = 0;
+		for (let k = r; k <= last; k++) have += rows[k].heightPt;
+		const deficit = cell.totalHeightPt - have;
+		if (deficit > .01) rows[last] = {
+			...rows[last],
+			heightPt: rows[last].heightPt + deficit
+		};
+	}
+}
 function tableXOffset(alignment, contentWidth, totalWidthPt) {
 	const slack = contentWidth - totalWidthPt;
 	if (slack <= 0 || !alignment || alignment === "left") return 0;
@@ -1757,15 +3282,18 @@ function tableXOffset(alignment, contentWidth, totalWidthPt) {
 function computeColumnWidths(table, options, fontResources, contentWidth) {
 	let colCount = table.grid.length;
 	for (const row of table.rows) {
-		let rowCols = 0;
+		let rowCols = row.properties.gridBefore ?? 0;
 		for (const cell of row.cells) rowCols += Math.max(1, cell.properties.colSpan ?? 1);
 		if (rowCols > colCount) colCount = rowCols;
 	}
 	if (colCount === 0) return [];
-	if (table.properties.layout === "fixed") return gridWidthsScaled(table, contentWidth, colCount);
+	const gridShort = gridColTwips(table).length < colCount;
+	const declared = declaredColumnWidths(table, colCount, contentWidth, gridShort);
+	if (declared) return declared;
+	if (gridColTwips(table).some((w) => w > 0)) return gridWidthsScaled(table, contentWidth, colCount);
 	const colNaturalWidths = new Array(colCount).fill(0);
 	for (const row of table.rows) {
-		let colIdx = 0;
+		let colIdx = row.properties.gridBefore ?? 0;
 		for (let i = 0; i < row.cells.length; i++) {
 			const cell = row.cells[i];
 			const span = Math.max(1, cell.properties.colSpan ?? 1);
@@ -1798,6 +3326,81 @@ function computeColumnWidths(table, options, fontResources, contentWidth) {
 function gridColTwips(table) {
 	return table.grid.map((w) => Math.round(w * 20));
 }
+/**
+* §17.4.53 — column widths taken from the cells' own `w:tcW` for a table laid
+* out `fixed`. Each cell shares its preferred width over the columns it spans
+* and the widest claim wins; a column nobody declares keeps its grid share.
+* Returns `undefined` (⇒ the grid decides) unless the table says `fixed` and
+* enough of it is declared to trust.
+*/
+function declaredColumnWidths(table, colCount, contentWidth, gridShort = false) {
+	if (table.properties.layout !== "fixed" && !gridShort) return void 0;
+	const target = totalTableTarget(table, contentWidth);
+	const declaredWidth = (cell) => {
+		const p = cell.properties;
+		if (p.widthFraction !== void 0) return p.widthFraction * target;
+		if (p.width !== void 0 && p.widthType !== "auto" && p.widthType !== "nil") return p.width;
+	};
+	const claimed = new Array(colCount).fill(0);
+	const spanning = [];
+	let anyDeclared = false;
+	let reach = 0;
+	for (const row of table.rows) {
+		if (row.cells.length < 2) continue;
+		let span = row.properties.gridBefore ?? 0;
+		for (const cell of row.cells) span += Math.max(1, cell.properties.colSpan ?? 1);
+		if (span > reach) reach = span;
+	}
+	const phantomFrom = reach > 0 && reach < colCount ? reach : colCount;
+	for (const row of table.rows) {
+		let colIdx = row.properties.gridBefore ?? 0;
+		for (const cell of row.cells) {
+			const span = Math.max(1, cell.properties.colSpan ?? 1);
+			const widthPt = declaredWidth(cell);
+			if (widthPt !== void 0 && widthPt > 0) {
+				anyDeclared = true;
+				if (span === 1) {
+					if (widthPt > claimed[colIdx]) claimed[colIdx] = widthPt;
+				} else spanning.push({
+					start: colIdx,
+					span,
+					widthPt
+				});
+			}
+			colIdx += span;
+		}
+	}
+	if (!anyDeclared) return void 0;
+	for (const s of spanning) {
+		const end = Math.min(s.start + s.span, phantomFrom);
+		let have = 0;
+		const blank = [];
+		for (let i = s.start; i < end; i++) {
+			have += claimed[i];
+			if (claimed[i] === 0) blank.push(i);
+		}
+		const deficit = s.widthPt - have;
+		if (deficit <= 0) continue;
+		if (blank.length > 0) {
+			const each = deficit / blank.length;
+			for (const i of blank) claimed[i] = each;
+		} else if (have > 0) for (let i = s.start; i < end; i++) claimed[i] = claimed[i] * (s.widthPt / have);
+	}
+	const gridTwips = gridColTwips(table);
+	const rest = [];
+	let claimedTotal = 0;
+	for (let i = 0; i < phantomFrom; i++) if (claimed[i] > 0) claimedTotal += claimed[i];
+	else rest.push(i);
+	if (rest.length > 0) {
+		const leftover = Math.max(0, target - claimedTotal);
+		const restGrid = rest.reduce((s, i) => s + (gridTwips[i] ?? 0), 0);
+		for (const i of rest) claimed[i] = restGrid > 0 ? (gridTwips[i] ?? 0) / restGrid * leftover : leftover / rest.length;
+	}
+	const total = claimed.reduce((s, w) => s + w, 0);
+	if (total <= 0) return void 0;
+	const scale = total > target ? target / total : 1;
+	return claimed.map((w) => w * scale);
+}
 function gridWidthsScaled(table, contentWidth, colCount) {
 	const gridTwips = gridColTwips(table);
 	const totalGridTwips = gridTwips.reduce((s, w) => s + w, 0);
@@ -1860,8 +3463,9 @@ function aboveOfSpan(aboveBordersByCol, colIdx, span) {
 function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidthsPt, options, fontResources, imageResources, rowMergeRoles, aboveBordersByCol) {
 	const cells = [];
 	const columnXOffsets = [];
-	let cursorX = 0;
-	let colIdx = 0;
+	const skip = Math.min(Math.max(0, row.properties.gridBefore ?? 0), columnWidthsPt.length);
+	let cursorX = columnWidthsPt.slice(0, skip).reduce((sum, w) => sum + w, 0);
+	let colIdx = skip;
 	for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
 		const cell = row.cells[cellIdx];
 		const span = Math.max(1, cell.properties.colSpan ?? 1);
@@ -1882,7 +3486,10 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		colIdx += span;
 	}
 	let heightPt = 0;
-	for (const c of cells) if (c.totalHeightPt > heightPt) heightPt = c.totalHeightPt;
+	for (const c of cells) {
+		if (c.mergeRole === "start") continue;
+		if (c.totalHeightPt > heightPt) heightPt = c.totalHeightPt;
+	}
 	if (row.properties.height && row.properties.heightRule === "exact") {
 		heightPt = row.properties.height;
 		return {
@@ -1890,7 +3497,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 {
@@ -1898,7 +3506,8 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		cells,
 		columnXOffsets,
 		rowIdx,
-		rowCount
+		rowCount,
+		...row.properties.cantSplit ? { cantSplit: true } : {}
 	};
 }
 /**
@@ -1930,6 +3539,31 @@ function clipCellToHeight(cell, heightPt) {
 		contentHeightPt: used
 	};
 }
+/**
+* The one run a picture BLOCK is made of, so a context that lays out paragraphs
+* (a table cell) can draw it without a block path of its own.
+*
+* @param image The image block.
+* @returns A run carrying it as an inline picture.
+*/
+function imageRun(image) {
+	return {
+		text: "",
+		properties: {},
+		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 } : {},
+			...image.rotation60k ? { rotation60k: image.rotation60k } : {},
+			...image.flipH ? { flipH: true } : {},
+			...image.flipV ? { flipV: true } : {},
+			...image.effectExtent ? { effectExtent: image.effectExtent } : {}
+		}
+	};
+}
 function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imageResources, rowIdx, colStart, colSpan, rowCount, colCount, mergeRole, leftNeighborBorders, aboveNeighborBorders) {
 	const cellMar = cell.properties.margins;
 	const tableMar = tableProps.defaultCellMargins;
@@ -1942,8 +3576,19 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	const innerWidth = Math.max(1, widthPt - padLeftPt - padRightPt);
 	const lines = [];
 	const nestedTables = [];
+	const cellShapes = [];
+	const cellFloats = [];
+	const lineGaps = /* @__PURE__ */ new Map();
 	let contentHeightPt = 0;
 	let clipped = false;
+	let pendingGapPt = 0;
+	const openParagraph = (spacingBeforePt) => {
+		const gap = pendingGapPt + spacingBeforePt;
+		pendingGapPt = 0;
+		if (gap <= 0) return;
+		lineGaps.set(lines.length, (lineGaps.get(lines.length) ?? 0) + gap);
+		contentHeightPt += gap;
+	};
 	if (mergeRole !== "middle" && mergeRole !== "end") {
 		for (const el of cell.content) if (el.kind === "paragraph") {
 			const noWrap = cell.properties.noWrap === true;
@@ -1951,16 +3596,50 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 			const cutAt = widthPt - padLeftPt;
 			if (noWrap && (block.lines[0]?.contentWidthPt ?? 0) > cutAt) clipped = true;
 			const keep = noWrap ? clipLineToWidth(block.lines, cutAt, cell.properties.hashOnOverflow === true) : block.lines;
+			const markOnly = cell.properties.hideMark === true && el.paragraph.runs.every((r) => r.text === "");
+			if (!markOnly) openParagraph(block.spacingBeforePt);
 			for (const line of keep) {
 				lines.push(line);
-				contentHeightPt += computeLineHeight(line, block.resolved);
+				if (!markOnly) contentHeightPt += computeLineHeight(line, block.resolved);
 			}
-			contentHeightPt += block.spacingAfterPt;
+			if (!markOnly) pendingGapPt = block.spacingAfterPt;
 		} else if (el.kind === "table") {
 			const nested = layoutTableBlock(el.table, options, fontResources, imageResources, innerWidth);
-			nestedTables.push(nested);
+			nestedTables.push({
+				block: nested,
+				afterLine: lines.length
+			});
 			contentHeightPt += nested.heightPt;
-		}
+		} else if (el.kind === "image" && !isOutOfFlowFloat(el.image.float)) {
+			const block = layoutParagraphBlock({
+				properties: el.image.paragraphProperties,
+				runs: [imageRun(el.image)]
+			}, options, fontResources, imageResources, innerWidth);
+			openParagraph(block.spacingBeforePt);
+			for (const line of block.lines) {
+				lines.push(line);
+				contentHeightPt += computeLineHeight(line, block.resolved);
+			}
+			contentHeightPt += block.spacingAfterPt;
+			pendingGapPt = block.spacingAfterPt;
+		} else if (el.kind === "shape" && !isOutOfFlowFloat(el.shape.float)) {
+			const block = layoutShapeBlock(el.shape, options, fontResources, imageResources, innerWidth);
+			openParagraph(block.spacingBeforePt);
+			cellShapes.push({
+				block,
+				afterLine: lines.length
+			});
+			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;
 	const borders = resolveCellBorders(cell.properties.borders, tableProps.borders, rowIdx, colStart, colEnd, rowCount, colCount, mergeRole, leftNeighborBorders, aboveNeighborBorders);
@@ -1977,7 +3656,10 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 		...cell.properties.icon ? { icon: cell.properties.icon } : {},
 		...cell.properties.sparkline ? { sparkline: cell.properties.sparkline } : {},
 		lines,
+		...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 } : {},
@@ -1992,6 +3674,7 @@ var BORDER_STYLE_RANK = {
 	thick: 4,
 	single: 3,
 	dashed: 2,
+	dashSmallGap: 2,
 	dashDot: 2,
 	dashDotDot: 2,
 	dotted: 1,
@@ -2099,7 +3782,7 @@ function listItemParagraphNode(builder, stack, list, wantLbl) {
 * Push order into `current`/`pages` IS the byte order of the emitted PDF, so the
 * bodies move unchanged.
 */
-var PageAssembler = class {
+var PageAssembler = class PageAssembler {
 	/**
 	* @param sectionCtxs      The per-section render contexts, in order; assembly
 	*                         starts on the first section's first page.
@@ -2109,20 +3792,29 @@ var PageAssembler = class {
 	*                         `undefined` when there are none.
 	* @param bookmarkPositions Out-param: bookmark name → its GoTo destination.
 	*/
-	constructor(sectionCtxs, builder, notes, bookmarkPositions) {
+	constructor(sectionCtxs, builder, notes, bookmarkPositions, backgroundImageName) {
 		this.sectionCtxs = sectionCtxs;
 		this.builder = builder;
 		this.notes = notes;
 		this.bookmarkPositions = bookmarkPositions;
+		this.backgroundImageName = backgroundImageName;
 		this.ctx = sectionCtxs[0];
+		this.pageStartCtx = this.ctx;
+		this.pageNumber = this.ctx.properties.pageNumberStart ?? 1;
 		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
 		this.colStartY = this.cursorY;
+		this.bandTopY = this.cursorY;
 	}
 	pages = [];
 	ctx;
 	secIdx = 0;
 	pageInSection = 0;
 	globalPageIdx = 0;
+	/**
+	* §17.6.12 — the number the NEXT page prints for a PAGE field. Counts up with
+	* the pages and restarts wherever a section names a `w:pgNumType w:start`.
+	*/
+	pageNumber = 1;
 	current = [];
 	pendingPageBreak = false;
 	cursorY;
@@ -2136,11 +3828,23 @@ var PageAssembler = class {
 	colStartLen = 0;
 	/** The cursor's y at the top of the current column — see {@link colHasContent}. */
 	colStartY;
+	/**
+	* Where this page's column band begins. The top margin on an ordinary page;
+	* further down when a §17.6.22 `continuous` section started mid-page, whose
+	* columns run beside each other from there, not from the paper's top.
+	*/
+	bandTopY;
 	/** The current column's left edge (`marginLeft` plus the column x-offset). */
 	colLeft = () => this.ctx.marginLeft + (this.ctx.columns?.[this.colIdx]?.xOffsetPt ?? 0);
 	/** 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
@@ -2167,15 +3871,118 @@ var PageAssembler = class {
 		if (this.ctx.columns && this.colIdx + 1 < this.ctx.columns.length) {
 			this.colIdx++;
 			this.colStartLen = this.current.length;
-			this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+			this.cursorY = this.bandTopY;
 			this.colStartY = this.cursorY;
+			const isLast = this.colIdx + 1 >= this.ctx.columns.length;
+			this.balanceBottomY = this.balanceHeightPt > 0 && !isLast ? this.cursorY - this.balanceHeightPt : void 0;
 		} else this.flushPage();
 	};
 	/**
+	* §17.6.8 — the running line count for the margin numbers. Reset by the
+	* section's own `w:restart` rule.
+	*/
+	lineNumber = 0;
+	/**
+	* §17.6.8 — the margin number for the body line just placed, if the section
+	* asks for one at this count. Pushed at the line's own baseline, right-
+	* aligned a quarter inch off the text.
+	*
+	* @param baselineY The line's baseline, in page (y-down) coordinates.
+	* @param line      The line being numbered — its font draws the digits.
+	*/
+	emitLineNumber = (baselineY, line) => {
+		const ln = this.ctx.properties.lineNumbering;
+		if (!ln) return;
+		this.lineNumber++;
+		const n = ln.start + this.lineNumber - 1;
+		if ((n - ln.start + 1) % ln.countBy !== 0) return;
+		const token = line.tokens.find((t) => t.kind === "text");
+		if (!token) return;
+		const text = String(n);
+		const sizePt = token.fontSizePt;
+		const widthPt = token.font.measure.textWidthPt(text, sizePt);
+		const digits = {
+			kind: "text",
+			text,
+			isSpace: false,
+			resolvedRun: token.resolvedRun,
+			font: token.font,
+			fontSizePt: sizePt,
+			widthPt,
+			bidiLevel: 0
+		};
+		const numbered = {
+			...line,
+			tokens: [digits],
+			contentWidthPt: widthPt
+		};
+		this.current.push({
+			type: "line",
+			line: numbered,
+			originX: pt(this.colLeft() - (ln.distancePt ?? LINE_NUMBER_GAP_PT) - widthPt),
+			baselineY: pt(baselineY)
+		});
+	};
+	/**
+	* §17.6.12 — a section that names its own first page number restarts the
+	* count there; one that names none carries on from the section before.
+	*
+	* @param next The section being entered.
+	*/
+	restartPageNumbers = (next) => {
+		const start = next.properties.pageNumberStart;
+		if (start !== void 0) this.pageNumber = start;
+		if ((next.properties.lineNumbering?.restart ?? "newPage") !== "continuous") this.lineNumber = 0;
+	};
+	/**
+	* §17.6.22 — start a `continuous` section on the page in hand: its columns
+	* begin where the section does, not at the top of the paper.
+	*
+	* @param next The section to continue into.
+	*/
+	startBandSection = (next, bandHeightPt) => {
+		this.secIdx++;
+		this.ctx = next;
+		this.restartPageNumbers(next);
+		this.colIdx = 0;
+		this.colStartLen = this.current.length;
+		this.cursorY = Math.min(this.cursorY, next.pageHeight - next.marginTop);
+		this.bandTopY = this.cursorY;
+		this.colStartY = this.cursorY;
+		this.beginBalancedBand(bandHeightPt);
+	};
+	/**
+	* §17.6.4 — even the columns of the band that starts at the cursor: each gets
+	* the same share of `bandHeightPt`. A band too tall for the page fills column
+	* after column as before; there is nothing to even out when it will spill
+	* anyway.
+	*
+	* @param bandHeightPt The height of everything the band holds.
+	*/
+	beginBalancedBand = (bandHeightPt) => {
+		const colCount = this.ctx.columns?.length ?? 1;
+		const room = this.cursorY - (this.ctx.marginBottom + this.noteReserve);
+		const share = colCount > 1 ? balancedColumnHeight(bandHeightPt, colCount, room) : 0;
+		this.balanceHeightPt = share;
+		this.balanceBottomY = share > 0 ? this.cursorY - share : void 0;
+	};
+	/**
 	* §20.4.2.3 out-of-flow drawings (wrap `'none'`): they render at their anchored
 	* position without moving the cursor. `behindDoc` sinks below the body text,
 	* everything else above it; both flush with the page.
 	*/
+	/**
+	* §20.4.2.3 — a float layer, drawn in `relativeHeight` order. A stable sort
+	* by z leaves the ones that state none where the document put them:
+	* dml-rectangle-relsize.docx writes its blue bar first and gives it the
+	* higher z, and drawn in document order the white rectangle covered it.
+	*/
+	/** A float layer that stamps each item it takes with the float's z-order. */
+	static zSink = (target, z) => z === void 0 ? target : { push: (...items) => target.push(...items.map((i) => ({
+		...i,
+		z
+	}))) };
+	static byZ = (items) => items.every((i) => i.z === void 0) ? [...items] : [...items].sort((a, b) => (a.z ?? 0) - (b.z ?? 0));
 	floatsBehind = [];
 	floatsFront = [];
 	/**
@@ -2183,27 +3990,42 @@ var PageAssembler = class {
 	* must flow around. Page-scoped, like the float graphics.
 	*/
 	exclusions = [];
-	/** 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 base = h.relativeFrom === "page" ? 0 : h.relativeFrom === "column" ? this.colLeft() : this.ctx.marginLeft;
-		const span = h.relativeFrom === "page" ? this.ctx.pageWidth : h.relativeFrom === "column" ? this.colWidth() : 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);
+	/**
+	* Claim the area a side-wrapping float keeps to itself: its own box grown by
+	* the §20.4.2.3 `distT/B/L/R` stand-off the anchor asks for.
+	*/
+	excludeFloat = (f, x, topYUp, w, h) => {
+		const d = f.wrapDist;
+		const wide = f.wrap === "notBeside";
+		this.exclusions.push({
+			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),
+			...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) => 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) => {
-		const v = f.posV;
-		if (!v) return this.cursorY;
-		if (v.relativeFrom === "page") return this.ctx.pageHeight - (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.
@@ -2219,7 +4041,21 @@ var PageAssembler = class {
 	noteReserve = 0;
 	placedNotes = /* @__PURE__ */ new Set();
 	/** The page's usable bottom: the margin plus whatever the notes band has claimed so far. */
-	bottomLimit = () => this.ctx.marginBottom + this.noteReserve;
+	/**
+	* §17.6.4 — where the current column must stop. Normally the page's bottom
+	* margin (plus any footnote reserve); inside a BALANCED band it is the line
+	* the band's share of the height reaches, so the columns come out even.
+	*/
+	bottomLimit = () => Math.max(this.ctx.marginBottom + this.noteReserve, this.balanceBottomY ?? Number.NEGATIVE_INFINITY);
+	/**
+	* §17.6.4 — a `continuous` section of several columns whose content fits the
+	* page is BALANCED: Word evens the columns out rather than filling the first
+	* to the bottom. Set while such a band is being laid out; the height each
+	* column is given is `balanceHeightPt`. IndexFieldFlagF.docx sets its index
+	* that way and we filled column one and left the rest empty.
+	*/
+	balanceBottomY;
+	balanceHeightPt = 0;
 	/**
 	* The first exclusion a line spanning `[yTop-h, yTop]` collides with in the
 	* current column (x-overlap with the column required).
@@ -2247,15 +4083,25 @@ var PageAssembler = class {
 		const cl = this.colLeft();
 		const leftRoom = e.x0 - FLOAT_TEXT_GAP - cl;
 		const rightRoom = cl + full - (e.x1 + FLOAT_TEXT_GAP);
-		if (rightRoom >= leftRoom) {
-			const w = Math.max(MIN_WRAP_WIDTH, rightRoom);
-			return {
-				width: w,
-				xOffset: full - w
-			};
-		}
+		if (Math.max(leftRoom, rightRoom) < MIN_WRAP_WIDTH) return {
+			width: full,
+			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
+		};
 		return {
-			width: Math.max(MIN_WRAP_WIDTH, leftRoom),
+			width: leftRoom,
 			xOffset: 0
 		};
 	};
@@ -2274,9 +4120,16 @@ var PageAssembler = class {
 		let y = startY;
 		for (let i = 0; i < 200; i++) {
 			const g = this.lineGeometryAt(y, h0);
+			if (g.blockedUntilYUp !== void 0) {
+				widths.push(this.colWidth());
+				y = g.blockedUntilYUp - h0;
+				if (y < this.bottomLimit()) break;
+				continue;
+			}
 			widths.push(g.width);
+			if (g.pair) widths.push(g.pair.width);
 			if (g.width < this.colWidth()) narrowed = true;
-			else if (i > 0) break;
+			else if (narrowed) break;
 			y -= h0;
 			if (y < this.bottomLimit()) break;
 		}
@@ -2328,7 +4181,7 @@ var PageAssembler = class {
 				const noteNode = this.builder.create("Note", this.builder.root);
 				structId = this.builder.create("P", noteNode).id;
 			}
-			out.push(...drawBlocksSequentially(note.blocks, this.ctx.marginLeft, cursor, this.ctx.pageHeight, structId));
+			out.push(...drawBlocksSequentially(note.blocks, this.ctx.marginLeft, cursor, this.ctx.pageHeight, this.ctx.contentWidth, structId));
 			cursor -= note.heightPt;
 		}
 		return out;
@@ -2353,22 +4206,25 @@ var PageAssembler = class {
 		const footer = pickBand(this.ctx.footerSet, band);
 		if (header.renderDynamic) this.dynBands.push({
 			pageIdx: this.pages.length,
-			pageNumber: this.globalPageIdx + 1,
+			pageNumber: this.pageNumber,
 			position: "header",
 			render: header.renderDynamic
 		});
 		if (footer.renderDynamic) this.dynBands.push({
 			pageIdx: this.pages.length,
-			pageNumber: this.globalPageIdx + 1,
+			pageNumber: this.pageNumber,
 			position: "footer",
 			render: footer.renderDynamic
 		});
 		this.pages.push({
 			commands: [
+				...this.pageBackgroundItems(),
+				...this.pageBorderItems(),
+				...this.columnSeparatorItems(),
 				...header.commands,
-				...this.floatsBehind,
+				...PageAssembler.byZ(this.floatsBehind),
 				...this.current,
-				...this.floatsFront,
+				...PageAssembler.byZ(this.floatsFront),
 				...this.renderNotesBand(),
 				...footer.commands
 			],
@@ -2385,35 +4241,214 @@ var PageAssembler = class {
 		this.colStartLen = 0;
 		this.pageInSection++;
 		this.globalPageIdx++;
+		this.pageNumber++;
+		if ((this.ctx.properties.lineNumbering?.restart ?? "newPage") === "newPage") this.lineNumber = 0;
+		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+		this.colStartY = this.cursorY;
+		this.bandTopY = this.cursorY;
+		this.balanceBottomY = void 0;
+		this.balanceHeightPt = 0;
+		this.pageStartCtx = this.ctx;
+	};
+	/**
+	* §17.6.4 `w:cols w:sep` — the rule down the middle of every gutter, run the
+	* height of the text area. multi-column-separator-with-line.docx asks for one
+	* and we drew its two columns with nothing between them.
+	*
+	* @returns One border item per gutter, or none when the section asks for no rule.
+	*/
+	columnSeparatorItems = () => {
+		const ctx = this.pageStartCtx;
+		const cols = ctx.columns;
+		if (!cols || cols.length < 2 || ctx.properties.columns?.separator !== true) return [];
+		let deepest = ctx.marginTop;
+		for (const item of this.current) {
+			const bottom = item.type === "line" ? item.baselineY : item.type === "shape" ? 0 : item.y + item.height;
+			if (bottom > deepest) deepest = bottom;
+		}
+		const height = Math.min(deepest, ctx.pageHeight - ctx.marginBottom) - ctx.marginTop;
+		if (height <= 0) return [];
+		const out = [];
+		for (let i = 1; i < cols.length; i++) {
+			const left = cols[i - 1];
+			const right = cols[i];
+			const x = ctx.marginLeft + (left.xOffsetPt + left.widthPt + right.xOffsetPt) / 2;
+			out.push({
+				type: "border",
+				side: "left",
+				x: pt(x),
+				y: pt(ctx.marginTop),
+				width: pt(0),
+				height: pt(height),
+				borderSizePt: COLUMN_SEPARATOR_PT,
+				borderColorHex: "000000"
+			});
+		}
+		return out;
+	};
+	/** The section context the CURRENT page began in (see {@link columnSeparatorItems}). */
+	pageStartCtx;
+	/**
+	* §17.6.10 `w:pgBorders` — the rules around the page. `@w:offsetFrom` says
+	* what each edge's space is measured from: the paper's own edge, or the text
+	* margin the rule stands outside of. a4andborders.docx frames every page and
+	* we drew nothing.
+	*
+	* @returns The border items for this page, in paint order.
+	*/
+	/**
+	* §17.2.1 — what the page is painted before anything is drawn on it: the
+	* `v:background`'s PICTURE or GRADIENT when it has one, else the flat
+	* `w:background @w:color`. Read as the colour alone, fill.docx's five-stop
+	* sweep came out the navy of its fallback and tdf126533_pageBitmap.docx's
+	* paper came out plain.
+	*
+	* @returns The background items for this page (at most one).
+	*/
+	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 === "gradient" && fill.gradient) return [{
+			type: "shape",
+			shape: {
+				paths: [rectAtPath(0, 0, w, h)],
+				fillColorHex: gradientToSolid(fill.gradient),
+				fillGradient: fill.gradient,
+				transform: flipTransform([
+					1,
+					0,
+					0,
+					1,
+					0,
+					0
+				], h)
+			}
+		}];
+		if (options?.pageBackgroundColorHex !== void 0) return [{
+			type: "fill",
+			x: pt(0),
+			y: pt(0),
+			width: pt(w),
+			height: pt(h),
+			fillColorHex: options.pageBackgroundColorHex
+		}];
+		return [];
+	};
+	pageBorderItems = () => {
+		const pg = this.ctx.properties.pageBorders;
+		if (!pg) return [];
+		const H = this.ctx.pageHeight;
+		const W = this.ctx.pageWidth;
+		const out = [];
+		for (const side of [
+			"top",
+			"bottom",
+			"left",
+			"right"
+		]) {
+			const edge = pg.borders[side];
+			if (!edge || edge.style === "none") continue;
+			const gap = edge.spacePt ?? 0;
+			const x0 = pg.offsetFrom === "page" ? gap : this.ctx.marginLeft - gap;
+			const x1 = pg.offsetFrom === "page" ? W - gap : W - this.ctx.marginLeft + gap;
+			const yTop = pg.offsetFrom === "page" ? gap : this.ctx.marginTop - gap;
+			const yBottom = pg.offsetFrom === "page" ? H - gap : H - this.ctx.marginBottom + gap;
+			out.push({
+				type: "border",
+				side,
+				x: pt(Math.max(0, x0)),
+				y: pt(Math.max(0, yTop)),
+				width: pt(Math.max(0, x1 - x0)),
+				height: pt(Math.max(0, yBottom - yTop)),
+				borderSizePt: edge.width ?? DEFAULT_BORDER_SIZE_EIGHTH * EIGHTH_PT,
+				borderColorHex: edge.colorHex ?? "000000",
+				...edge.style !== "single" ? { borderStyle: edge.style } : {}
+			});
+		}
+		return out;
+	};
+	/**
+	* Throw the in-progress page away and reset for the next one.
+	*
+	* A section boundary reached with a page that draws nothing is the one place
+	* this is wanted: {@link flushPage} keeps such a page whenever the cursor
+	* moved at all, which is right in the middle of a flow and wrong at a
+	* boundary, where the space consumed was the section break itself.
+	*/
+	dropPage = () => {
+		this.current = [];
+		this.floatsBehind = [];
+		this.floatsFront = [];
+		this.exclusions = [];
+		this.pageNotes = [];
+		this.noteReserve = 0;
+		this.colIdx = 0;
+		this.colStartLen = 0;
 		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
 		this.colStartY = this.cursorY;
+		this.bandTopY = this.cursorY;
+		this.balanceBottomY = void 0;
+		this.balanceHeightPt = 0;
 	};
 };
-function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", notes, bookmarkPositions, reflowParagraph) {
+function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", notes, bookmarkPositions, reflowParagraph, backgroundImageName) {
 	if (sectionCtxs.length === 0) return [];
-	const asm = new PageAssembler(sectionCtxs, builder, notes, bookmarkPositions);
+	const asm = new PageAssembler(sectionCtxs, builder, notes, bookmarkPositions, backgroundImageName);
+	const balanceIfEndsContinuous = (fromBlock) => {
+		const here = asm.ctx;
+		const next = sectionCtxs[asm.secIdx + 1];
+		if ((here.columns?.length ?? 1) < 2) return;
+		if (!next?.continuous) return;
+		if (next.pageWidth !== here.pageWidth || next.pageHeight !== here.pageHeight) return;
+		const end = Math.min(here.endIndex, blocks.length);
+		asm.beginBalancedBand(blocksHeight(blocks.slice(fromBlock, end)));
+	};
+	balanceIfEndsContinuous(0);
 	for (let blockIdx = 0; blockIdx < blocks.length; blockIdx++) {
 		while (asm.secIdx < sectionCtxs.length - 1 && blockIdx >= asm.ctx.endIndex) {
-			asm.flushPage();
+			const next = sectionCtxs[asm.secIdx + 1];
+			if (next.continuous && next.pageWidth === asm.ctx.pageWidth && next.pageHeight === asm.ctx.pageHeight) {
+				const end = Math.min(next.endIndex, blocks.length);
+				asm.startBandSection(next, blocksHeight(blocks.slice(blockIdx, end)));
+				continue;
+			}
+			if (asm.pageHasContent() || asm.pageInSection === 0) asm.flushPage(true);
+			else asm.dropPage();
 			asm.secIdx++;
 			asm.ctx = sectionCtxs[asm.secIdx];
+			asm.restartPageNumbers(asm.ctx);
 			asm.pageInSection = 0;
 			asm.cursorY = asm.ctx.pageHeight - asm.ctx.marginTop;
+			balanceIfEndsContinuous(blockIdx);
 		}
 		const block = blocks[blockIdx];
 		if (asm.pendingPageBreak) {
 			asm.pendingPageBreak = false;
-			if (asm.current.length > 0) asm.flushPage();
+			asm.flushPage(true);
 		}
 		if (builder && !(block.kind === "paragraph" && block.list)) asm.listStack.length = 0;
 		if (block.kind === "paragraph") {
-			if (block.resolved.pageBreakBefore && asm.pageHasContent()) asm.flushPage();
+			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;
 			let structId;
 			let markerLblId;
 			const firstLine = pb.lines[0];
@@ -2428,7 +4463,9 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				if (lang && lang !== defaultLang) builder.node(structId).lang = lang;
 			}
 			let firstLineOfBlock = true;
-			for (const line of pb.lines) {
+			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);
 				let newNotes = asm.lineFootnotes(line);
 				const addedReserve = (sub) => sub.reduce((sum, x) => sum + x.heightPt, 0) + (asm.pageNotes.length === 0 && sub.length > 0 ? FOOTNOTE_SEPARATOR_HEIGHT : 0);
@@ -2456,11 +4493,22 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 						});
 					}
 				}
-				asm.cursorY -= h;
+				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;
+				}
 				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 + lineDescent(line)));
-				const exclusionShift = asm.exclusions.length > 0 ? asm.lineGeometryAt(asm.cursorY + h, h).xOffset : 0;
+				const baselineY = pt(asm.ctx.pageHeight - (asm.cursorY + lineBaselineOffset(line, pb.resolved)));
+				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;
@@ -2499,87 +4547,54 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 					baselineY,
 					...structId !== void 0 ? { structId } : {}
 				});
+				asm.emitLineNumber(baselineY, line);
 			}
+			if (asm.pages.length === borderPage) asm.current.push(...paragraphDecoration(pb.resolved, asm.colLeft() + pb.resolved.indentLeft, asm.colLeft() + asm.colWidth() - pb.resolved.indentRight, borderTopY, asm.cursorY, asm.ctx.pageHeight));
 			asm.cursorY -= pb.spacingAfterPt;
 			if (pb.pageBreakAfter) asm.pendingPageBreak = true;
 		} else if (block.kind === "image") {
 			const figId = builder ? createFigure(builder, block.altText, "Image") : void 0;
 			const emitImageAt = (x, topYUp, sink) => {
+				const ins = block.drawInset;
 				sink.push({
 					type: "image",
-					x: pt(x),
-					y: pt(asm.ctx.pageHeight - topYUp),
-					width: pt(block.widthPt),
-					height: pt(block.heightPt),
+					x: pt(x + (ins?.dxPt ?? 0)),
+					y: pt(asm.ctx.pageHeight - (topYUp - (ins?.dyTopPt ?? 0))),
+					width: pt(ins?.widthPt ?? block.widthPt),
+					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 } : {},
+					...block.flipH ? { flipH: true } : {},
+					...block.flipV ? { flipV: true } : {},
 					...figId !== void 0 ? { structId: figId } : {}
 				});
+				if (block.outline) sink.push(...pictureOutlineItems(block.outline, x + (ins?.dxPt ?? 0), asm.ctx.pageHeight - (topYUp - (ins?.dyTopPt ?? 0)), ins?.widthPt ?? block.widthPt, ins?.heightPt ?? block.heightPt, figId));
 			};
 			if (isOutOfFlowFloat(block.float)) {
 				const fx = asm.floatX(block.float, block.widthPt);
-				const fy = asm.floatTopYUp(block.float);
-				emitImageAt(fx, fy, block.float.behind ? asm.floatsBehind : asm.floatsFront);
-				if (block.float.wrap !== "none") asm.exclusions.push({
-					x0: fx,
-					x1: fx + block.widthPt,
-					topYUp: fy,
-					bottomYUp: fy - block.heightPt
-				});
+				const fy = asm.floatTopYUp(block.float, block.heightPt);
+				emitImageAt(fx, fy, PageAssembler.zSink(block.float.behind ? asm.floatsBehind : asm.floatsFront, block.float.zOrder));
+				if (block.float.wrap !== "none") asm.excludeFloat(block.float, fx, fy, block.widthPt, block.heightPt);
 			} else {
 				asm.cursorY -= block.spacingBeforePt;
 				if (asm.cursorY - block.heightPt < asm.bottomLimit() && asm.colHasContent()) asm.advanceColumn();
 				asm.cursorY -= block.heightPt;
-				emitImageAt(asm.colLeft(), asm.cursorY + block.heightPt, asm.current);
+				const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, asm.colWidth());
+				emitImageAt(asm.colLeft() + offset, asm.cursorY + block.heightPt, asm.current);
 				asm.cursorY -= block.spacingAfterPt;
 			}
 		} else if (block.kind === "shape") {
 			const figId = builder ? createFigure(builder, block.altText, "Shape") : void 0;
-			const emitShapeAt = (x, bottomYUp, sink) => {
-				const transform = flipTransform(buildShapeTransform(x, bottomYUp, block.widthPt, block.heightPt, block.rotation60k, block.flipH, block.flipV), asm.ctx.pageHeight);
-				sink.push({
-					type: "shape",
-					shape: {
-						paths: block.paths,
-						...block.fillColorHex ? { fillColorHex: block.fillColorHex } : {},
-						...block.fillGradient ? { fillGradient: block.fillGradient } : {},
-						...block.stroke ? { stroke: block.stroke } : {},
-						...block.shadow ? { shadow: block.shadow } : {},
-						transform
-					},
-					...figId !== void 0 ? { structId: figId } : {}
-				});
-				if (block.textLines.length > 0) {
-					const shapeBottom = bottomYUp;
-					const shapeTop = bottomYUp + block.heightPt;
-					const innerWidth = Math.max(1, block.widthPt - block.insetLeftPt - block.insetRightPt);
-					let textY;
-					if (block.anchor === "b") textY = shapeBottom + block.insetBottomPt + block.textHeightPt;
-					else if (block.anchor === "ctr") textY = shapeBottom + (block.heightPt + block.textHeightPt) / 2;
-					else textY = shapeTop - block.insetTopPt;
-					for (const line of block.textLines) {
-						const h = computeLineHeight(line, line.resolved);
-						textY -= h;
-						const lineOffset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, innerWidth);
-						sink.push({
-							type: "line",
-							line,
-							originX: pt(x + block.insetLeftPt + lineOffset),
-							baselineY: pt(asm.ctx.pageHeight - (textY + lineDescent(line))),
-							...figId !== void 0 ? { structId: figId } : {}
-						});
-					}
-				}
-			};
+			const emitShapeAt = (x, bottomYUp, sink) => emitShapeItems(block, x, bottomYUp, sink, asm.ctx.pageHeight, figId);
 			if (isOutOfFlowFloat(block.float)) {
 				const fx = asm.floatX(block.float, block.widthPt);
-				const fy = asm.floatTopYUp(block.float);
-				emitShapeAt(fx, fy - block.heightPt, block.float.behind ? asm.floatsBehind : asm.floatsFront);
-				if (block.float.wrap !== "none") asm.exclusions.push({
-					x0: fx,
-					x1: fx + block.widthPt,
-					topYUp: fy,
-					bottomYUp: fy - block.heightPt
-				});
+				const fy = asm.floatTopYUp(block.float, block.heightPt);
+				emitShapeAt(fx, fy - block.heightPt, PageAssembler.zSink(block.float.behind ? asm.floatsBehind : asm.floatsFront, block.float.zOrder));
+				if (block.float.wrap !== "none") asm.excludeFloat(block.float, fx, fy, block.widthPt, block.heightPt);
 			} else {
 				asm.cursorY -= block.spacingBeforePt;
 				if (asm.cursorY - block.heightPt < asm.bottomLimit() && asm.colHasContent()) asm.advanceColumn();
@@ -2589,45 +4604,15 @@ 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 fig = figId !== void 0 ? { structId: figId } : {};
+			const figId = builder ? createFigure(builder, block.altText, block.figureRole ?? "Chart") : void 0;
 			const emitChartAt = (x, bottomYUp, sink) => {
-				for (const s of block.layout.shapes) sink.push({
-					type: "shape",
-					shape: {
-						paths: s.paths,
-						...s.fillColorHex ? { fillColorHex: s.fillColorHex } : {},
-						...s.stroke ? { stroke: s.stroke } : {},
-						transform: flipTransform([
-							1,
-							0,
-							0,
-							1,
-							x,
-							bottomYUp
-						], asm.ctx.pageHeight)
-					},
-					...fig
-				});
-				for (const t of block.layout.texts) sink.push({
-					type: "line",
-					line: t.line,
-					originX: pt(x + t.x),
-					baselineY: pt(asm.ctx.pageHeight - (bottomYUp + t.y)),
-					...t.rotationDeg ? { rotationDeg: t.rotationDeg } : {},
-					...fig
-				});
+				sink.push(...chartPageItems(block, x, bottomYUp, asm.ctx.pageHeight, figId));
 			};
 			if (isOutOfFlowFloat(block.float)) {
 				const fx = asm.floatX(block.float, block.widthPt);
-				const fy = asm.floatTopYUp(block.float);
-				emitChartAt(fx, fy - block.heightPt, block.float.behind ? asm.floatsBehind : asm.floatsFront);
-				if (block.float.wrap !== "none") asm.exclusions.push({
-					x0: fx,
-					x1: fx + block.widthPt,
-					topYUp: fy,
-					bottomYUp: fy - block.heightPt
-				});
+				const fy = asm.floatTopYUp(block.float, block.heightPt);
+				emitChartAt(fx, fy - block.heightPt, PageAssembler.zSink(block.float.behind ? asm.floatsBehind : asm.floatsFront, block.float.zOrder));
+				if (block.float.wrap !== "none") asm.excludeFloat(block.float, fx, fy, block.widthPt, block.heightPt);
 			} else {
 				asm.cursorY -= block.spacingBeforePt;
 				if (asm.cursorY - block.heightPt < asm.bottomLimit() && asm.colHasContent()) asm.advanceColumn();
@@ -2638,6 +4623,19 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			}
 		} else {
 			const colCount = block.rows.reduce((max, r) => Math.max(max, r.cells.reduce((s, c) => Math.max(s, c.colStart + c.colSpan), 0)), 0);
+			const anchorY = isOutOfFlowFloat(block.float) ? asm.floatTopYUp(block.float, block.heightPt) : 0;
+			if (isOutOfFlowFloat(block.float) && anchorY - block.heightPt >= asm.ctx.marginBottom) {
+				const fx = asm.floatX(block.float, block.totalWidthPt);
+				const fy = anchorY;
+				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, void 0, void 0, cellAnchorCtx(asm));
+					rowY -= row.heightPt;
+				}
+				if (block.float.wrap !== "none") asm.excludeFloat(block.float, fx, fy, block.totalWidthPt, block.heightPt);
+				continue;
+			}
 			const headerRows = [];
 			for (const r of block.rows) if (r.isHeader) headerRows.push(r);
 			else break;
@@ -2661,7 +4659,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;
@@ -2675,7 +4675,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];
@@ -2744,7 +4744,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;
 	{
@@ -2917,7 +4917,49 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 		const slack = cell.verticalAlign !== void 0 ? boxHeightPt - cell.padTopPt - cell.contentHeightPt - cell.padBottomPt : 0;
 		const vOffset = slack <= 0 ? 0 : cell.verticalAlign === "bottom" ? slack : cell.verticalAlign === "center" ? slack / 2 : 0;
 		let textY = rowTop - cell.padTopPt - vOffset;
-		for (const line of cell.lines) {
+		const nestedX = cellX + cell.padLeftPt;
+		const drawNestedBefore = (n) => {
+			for (const nt of cell.nestedTables ?? []) {
+				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, void 0, anchored);
+					textY -= nrow.heightPt;
+				}
+			}
+			for (const cs of cell.shapes ?? []) {
+				if (cs.afterLine !== n) continue;
+				const offset = alignmentOffset(cs.block.resolvedAlignment, cs.block.widthPt, cell.widthPt - cell.padLeftPt - cell.padRightPt);
+				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);
+			textY -= cell.lineGaps?.get(lineIdx) ?? 0;
 			const h = computeLineHeight(line, line.resolved);
 			textY -= h;
 			const offset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, cell.widthPt - cell.padLeftPt - cell.padRightPt);
@@ -2926,7 +4968,7 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 				type: "line",
 				line,
 				originX: pt(cellX + cell.padLeftPt + indentLeft + offset),
-				baselineY: pt(pageHeight - (textY + lineDescent(line))),
+				baselineY: pt(pageHeight - (textY + lineBaselineOffset(line, line.resolved))),
 				...cell.clipped ? { clip: {
 					x: pt(cellX),
 					y: pt(pageHeight - rowTop),
@@ -2936,20 +4978,16 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 				...structId !== void 0 ? { structId } : {}
 			});
 		}
-		if (cell.nestedTables) {
-			const nestedX = cellX + cell.padLeftPt;
-			for (const nt of cell.nestedTables) for (const nrow of nt.rows) {
-				const nestedIds = structId !== void 0 ? nrow.cells.map(() => structId) : void 0;
-				emitRowChunk(out, nrow, nestedX, textY, pageHeight, nt.colCount, nestedIds);
-				textY -= nrow.heightPt;
-			}
-		}
+		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);
@@ -2967,23 +5005,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
 			};
@@ -3022,7 +5068,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;
 	}
@@ -3147,4 +5194,4 @@ function emitRowBottomEdge(out, row, marginLeft, rowBottom, pageHeight) {
 	}
 }
 //#endregion
-export { layoutStyledDocument };
+export { GLUE_SHRINK_RATIO, layoutStyledDocument };