reamkit 1.15.4 → 1.17.0

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

@@ -10,17 +10,18 @@ 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 { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
+import "../core/numbering/index.js";
 import { PathBuilder, flipTransform } from "../core/vector.js";
 import { buildSparkline } from "../core/drawingml/sparkline-geometry.js";
 import { arcPoint, arcToBeziers } from "../core/arc-to-bezier.js";
-import { buildChartScene } from "../core/drawingml/chart-geometry.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 +34,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,6 +49,7 @@ 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) {
@@ -257,21 +267,48 @@ 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 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
+		};
+	}
 	const noteBlockCache = /* @__PURE__ */ new Map();
 	const notePlan = options.footnotes && noteAssigned.footnotes.size > 0 ? {
 		numbers: noteAssigned.footnotes,
@@ -286,7 +323,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 +351,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 +400,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 +421,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,27 +450,50 @@ 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 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,
 		properties: section.properties,
 		pageWidth: dims.pageWidth,
 		pageHeight: dims.pageHeight,
 		marginLeft: dims.marginLeft,
-		marginTop: dims.marginTop,
+		marginTop,
 		marginBottom: dims.marginBottom,
 		contentWidth,
-		pageContentHeight: dims.pageHeight - dims.marginTop - dims.marginBottom,
+		pageContentHeight: dims.pageHeight - marginTop - dims.marginBottom,
 		...columns ? { columns } : {},
 		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) {
@@ -449,20 +528,30 @@ 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: [] };
 		const content = headersFooters.get(ref.relationshipId);
 		if (!content) return { commands: [] };
+		let measured = 0;
 		const render = (c) => {
-			return markPagination(drawBlocksSequentially(laidOutBlocksFor(c, options, fontResources, contentWidth), marginLeft, pageHeight - headerOffsetPt, pageHeight));
+			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth, imageResources, relativeBox);
+			measured = blocksHeight(blocks);
+			return markPagination(drawBlocksSequentially(blocks, marginLeft, pageHeight - headerOffsetPt, pageHeight, contentWidth, void 0, bandMargins));
 		};
-		if (contentHasPageFields(content)) return {
-			commands: [],
-			renderDynamic: (n, total) => render(substitutePageFields(content, n, total))
+		if (contentHasPageFields(content)) {
+			render(substitutePageFields(content, 1, 1));
+			return {
+				commands: [],
+				heightPt: measured,
+				renderDynamic: (n, total) => render(substitutePageFields(content, n, total))
+			};
+		}
+		return {
+			commands: render(content),
+			heightPt: measured
 		};
-		return { commands: render(content) };
 	};
 	return {
 		default: band("default"),
@@ -470,15 +559,37 @@ function layoutHeaderSet(section, headersFooters, options, fontResources, conten
 		even: band("even")
 	};
 }
-function layoutFooterSet(section, headersFooters, options, fontResources, contentWidth, marginLeft, pageHeight, footerOffsetPt) {
+/**
+* §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) => {
+		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, 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: [],
@@ -514,7 +625,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;
 }
@@ -523,24 +634,236 @@ 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. */
+function frameFloat(frame) {
+	const wrap = frame.wrap === "none" ? "none" : frame.wrap === "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;
+}
+/** 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 layoutBodyElement(el, options, fontResources, imageResources, contentWidth, maxHeight) {
+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") return 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 {
@@ -549,27 +872,33 @@ function layoutImageBlock(image, imageResources, contentWidth) {
 		heightPt,
 		resolvedAlignment,
 		resourceName: res?.resourceName ?? "",
+		...image.outline ? { outline: image.outline } : {},
+		...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;
@@ -580,27 +909,154 @@ 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 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 } : {},
 		...stroke ? { stroke } : {},
+		...shape.shadow ? { shadow: shape.shadow } : {},
 		rotation60k: t?.rotation60k ?? 0,
 		flipH: t?.flipH ?? false,
 		flipV: t?.flipV ?? false,
@@ -608,12 +1064,17 @@ 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,
 		insetLeftPt,
 		insetRightPt,
 		insetTopPt,
 		insetBottomPt,
 		anchor: text?.anchor ?? "t",
+		...vertical ? { vertical } : {},
 		...shape.altText ? { altText: shape.altText } : {},
 		...shape.float ? { float: shape.float } : {}
 	};
@@ -666,6 +1127,9 @@ function buildChartLayout(chart, widthPt, heightPt, font) {
 		texts: []
 	};
 	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));
 	for (const p of scene.polylines) shapes.push(polylinePrim(p));
@@ -682,7 +1146,6 @@ var CF_ICON_SIZE_PT = 9;
 var CF_ICON_GUTTER_PT = 12;
 var CF_ICON_EMPTY_HEX = "BFBFBF";
 var DROPDOWN_BUTTON_PT = 11;
-var DROPDOWN_GUTTER_PT = 13;
 var DROPDOWN_FILL_HEX = "F0F0F0";
 var DROPDOWN_BORDER_HEX = "B0B0B0";
 var DROPDOWN_ARROW_HEX = "595959";
@@ -791,14 +1254,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) {
@@ -839,9 +1308,16 @@ function wedgePrim(w) {
 function labelPrim(l, font) {
 	const line = makeChartLabelLine(l.text, font, l.sizePt, l.colorHex);
 	const w = line.contentWidthPt;
+	const shift = l.align === "center" ? -w / 2 : l.align === "right" ? -w : 0;
+	if (l.rotationDeg) return {
+		line,
+		x: l.x,
+		y: l.y + shift,
+		rotationDeg: l.rotationDeg
+	};
 	return {
 		line,
-		x: l.align === "center" ? l.x - w / 2 : l.align === "right" ? l.x - w : l.x,
+		x: l.x + shift,
 		y: l.y
 	};
 }
@@ -881,10 +1357,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);
@@ -908,12 +1390,257 @@ 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;
+	});
+}
+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.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.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;
@@ -923,14 +1650,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();
@@ -981,6 +1754,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)) {
@@ -998,7 +1775,7 @@ function collectFontResources(body, headersFooters, options) {
 		}
 	};
 	const visit = (elements) => {
-		for (const el of elements) if (el.kind === "paragraph") for (const run of el.paragraph.runs) {
+		for (const el of elements) if (el.kind === "paragraph") for (const run of displayCapsRuns(el.paragraph, options)) {
 			if (run.math) {
 				addMath(run.math);
 				continue;
@@ -1020,9 +1797,22 @@ function collectFontResources(body, headersFooters, options) {
 			}
 			addRun(run, el.paragraph);
 		}
-		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 === "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({
+					text: "#",
+					properties: run.properties
+				}, inner.paragraph);
+			}
+			visit(cell.content);
+		}
 		else if (el.kind === "shape") {
-			if (el.shape.text) visit(el.shape.text.content);
+			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 === "chart") {
 			const chart = options.charts?.get(el.chart.chartRelId);
 			if (chart) {
@@ -1040,21 +1830,52 @@ function collectFontResources(body, headersFooters, options) {
 				};
 				if (chart.title) add(chart.title);
 				for (const c of chart.categories) add(c);
-				for (const sr of chart.series) if (sr.name) add(sr.name);
+				chart.series.forEach((sr, i) => add(legendSeriesName(sr, i)));
+				if (chart.catAxisTitle) add(chart.catAxisTitle);
+				if (chart.valAxisTitle) add(chart.valAxisTitle);
+				for (const sr of chart.series) for (const label of sr.pointLabels ?? []) add(label.text);
 				add("0123456789.,-%() ");
+				if (chart.numberFormat) add(chart.numberFormat);
 			}
 		}
 	};
 	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);
-	for (const comment of options.comments?.values() ?? []) visit(comment.content);
+	for (const comment of options.comments?.values() ?? []) {
+		visit(comment.content);
+		visit(commentTailBlocks(comment, 1, {
+			parentN: 1,
+			depth: 1,
+			done: true
+		}));
+		visit([{
+			kind: "paragraph",
+			paragraph: {
+				properties: {},
+				runs: [{
+					text: "0123456789",
+					properties: {}
+				}]
+			}
+		}]);
+	}
 	if (used.size === 0) {
 		const regular = options.registry.resolveByStyle(false, false);
 		used.set(regular.variant, {
 			parsed: regular.parsed,
-			gids: new Set([0])
+			gids: /* @__PURE__ */ new Set()
 		});
 	}
 	const out = /* @__PURE__ */ new Map();
@@ -1071,17 +1892,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,
@@ -1093,11 +1980,23 @@ 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
 	};
 }
+/**
+* Word and Excel both draw a super/subscript at about two thirds of the base
+* size, raised a third of it or dropped a sixth. The base line height does not
+* change: a superscript inside a line of body text must not open the leading.
+*/
+var SCRIPT_SCALE = .66;
+var SCRIPT_OFFSET = {
+	superscript: 1 / 3,
+	subscript: -1 / 6
+};
 function resolveMathItems(items, fontFor) {
 	return items.map((it) => {
 		if (it.kind === "glyph") return {
@@ -1123,13 +2022,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);
@@ -1141,7 +2103,14 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 				isImage: true,
 				imageWidthPt: widthPt,
 				imageHeightPt: heightPt,
-				imageResourceName: res?.resourceName ?? ""
+				imageResourceName: res?.resourceName ?? "",
+				...run.inlineImage.outline ? { imageOutline: run.inlineImage.outline } : {},
+				...run.inlineImage.shadow ? { imageShadow: run.inlineImage.shadow } : {},
+				...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) {
@@ -1174,11 +2143,13 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 		}
 		const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
 		const { fontKey } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
+		const script = SCRIPT_OFFSET[resolvedRun.verticalAlign] ?? 0;
 		return {
 			run,
 			resolvedRun,
 			font: lookupFont(fontResources, fontKey),
-			fontSizePt: resolvedRun.fontSizePt,
+			fontSizePt: script === 0 ? resolvedRun.fontSizePt : resolvedRun.fontSizePt * SCRIPT_SCALE,
+			...script === 0 ? {} : { risePt: resolvedRun.fontSizePt * script },
 			isImage: false,
 			imageWidthPt: 0,
 			imageHeightPt: 0,
@@ -1194,6 +2165,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) {
@@ -1203,6 +2187,13 @@ function tokenizePlansLtr(plans) {
 				imageResourceName: plan.imageResourceName,
 				widthPt: plan.imageWidthPt,
 				heightPt: plan.imageHeightPt,
+				...plan.imageOutline ? { outline: plan.imageOutline } : {},
+				...plan.imageShadow ? { shadow: plan.imageShadow } : {},
+				...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
 			});
@@ -1225,20 +2216,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,
-			widthPt: plan.font.measure.textWidthPt(t.text, plan.fontSizePt),
+			...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
+			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;
@@ -1250,6 +2258,13 @@ function tokenizePlansBidi(plans, realLevels) {
 				imageResourceName: plan.imageResourceName,
 				widthPt: plan.imageWidthPt,
 				heightPt: plan.imageHeightPt,
+				...plan.imageOutline ? { outline: plan.imageOutline } : {},
+				...plan.imageShadow ? { shadow: plan.imageShadow } : {},
+				...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
 			});
@@ -1284,11 +2299,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,
-				widthPt: plan.font.measure.textWidthPt(text, plan.fontSizePt),
+				...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
+				widthPt: measureRunText(plan, text),
 				bidiLevel: curLevel
 			});
 		};
@@ -1315,6 +2332,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;
 	}
@@ -1327,16 +2345,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
 	});
@@ -1347,17 +2378,54 @@ function lastCodePoint(s) {
 	const chars = [...s];
 	return chars.length > 0 ? chars[chars.length - 1].codePointAt(0) : 0;
 }
-function paragraphItemStream(tokens, hyphenator) {
+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
@@ -1368,7 +2436,7 @@ function paragraphItemStream(tokens, hyphenator) {
 			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,
@@ -1377,9 +2445,33 @@ function paragraphItemStream(tokens, hyphenator) {
 			},
 			token: null
 		});
+		prevWasImage = false;
 		prevBoxEndCp = lastCodePoint(tok.text);
 		const positions = hyphenator ? hyphenator.hyphenate(tok.text) : [];
 		if (positions.length === 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({
+						item: {
+							type: "penalty",
+							width: 0,
+							penalty: 0,
+							flagged: false
+						},
+						token: null
+					});
+					entries.push({
+						item: {
+							type: "box",
+							width: chunk.widthPt
+						},
+						token: chunk
+					});
+				});
+				continue;
+			}
 			entries.push({
 				item: {
 					type: "box",
@@ -1445,17 +2537,165 @@ function paragraphItemStream(tokens, hyphenator) {
 	});
 	return entries;
 }
-function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, profile) {
-	let st = start;
-	let et = breakIdx;
-	while (st < et && (entries[st].token === null || entries[st].token?.isSpace)) st++;
-	while (et > st && (entries[et - 1].token === null || entries[et - 1].token?.isSpace)) et--;
-	if (st >= et) return null;
-	const lineTokens = [];
-	for (let i = st; i < et; i++) {
-		const ft = entries[i].token;
+/** 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
+* builder reassembles them exactly as it does hyphenation fragments.
+*
+* @param tok     The text token.
+* @param widthPt The line width to fit each piece into.
+* @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];
+	if (tok.font.measure.textWidthPt(chars.slice(0, MIN_SPLIT_CHARS).join(""), tok.fontSizePt) > widthPt) return;
+	const out = [];
+	let start = 0;
+	while (start < chars.length) {
+		let end = start + 1;
+		let text = chars[start];
+		let width = tok.font.measure.textWidthPt(text, tok.fontSizePt);
+		if (width > widthPt && start === 0 && chars.length === 1) return void 0;
+		while (end < chars.length) {
+			const next = text + chars[end];
+			const nextWidth = tok.font.measure.textWidthPt(next, tok.fontSizePt);
+			if (nextWidth > widthPt) break;
+			text = next;
+			width = nextWidth;
+			end++;
+		}
+		out.push({
+			...tok,
+			text,
+			widthPt: width
+		});
+		start = end;
+	}
+	return out.length > 1 ? out : void 0;
+}
+/** 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, 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 && !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;
@@ -1475,8 +2715,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") {
@@ -1506,23 +2748,51 @@ 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);
+	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 lines = [];
-	let start = 0;
-	let isFirst = true;
-	let lineIdx = 0;
-	for (const breakIdx of breaks) {
-		const width = lineIdx < widths.length ? widths[lineIdx] : widths[widths.length - 1];
-		const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, profile);
-		if (line) lines.push(line);
-		start = breakIdx + 1;
-		isFirst = false;
-		lineIdx++;
+	const buildLines = (at) => {
+		const out = [];
+		let start = 0;
+		let isFirst = true;
+		let lineIdx = 0;
+		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, i < at.length - 1);
+			if (line) out.push(noExpandShiftReturn && entries[breakIdx]?.softBreak ? {
+				...line,
+				noJustify: true
+			} : line);
+			start = breakIdx + 1;
+			isFirst = false;
+			lineIdx++;
+		}
+		return out;
+	};
+	let lines = buildLines(breaks);
+	const spill = (ls) => Math.max(0, ...ls.map((l) => l.contentWidthPt - l.availableWidthPt));
+	if (profile === "ream" && lines.length === 1 && spill(lines) > .01) {
+		const greedy = buildLines(greedyBreakLines(items, widths));
+		if (greedy.length > 1 && spill(greedy) < spill(lines) - .01) lines = greedy;
 	}
 	if (lines.length > 0) lines[lines.length - 1].isLastInParagraph = true;
 	return lines;
@@ -1545,11 +2815,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;
@@ -1560,6 +2836,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);
@@ -1574,7 +2881,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;
@@ -1588,17 +2895,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;
@@ -1607,15 +2943,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);
@@ -1648,6 +2987,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);
@@ -1683,28 +3097,70 @@ function measureSingleLine(paragraph, options, fontResources) {
 	}
 	return total;
 }
+/**
+* The above-neighbour a cell resolves its top edge against.
+*
+* A spanning cell covers several columns and paints ONE top across all of them,
+* so taking the first column's neighbour throws away any rule the others
+* declare. tdf100034.xlsx rules the bottom of its two header cells, and a label
+* overflowing from two columns to their left spanned over both and wiped that
+* rule off the page. Take the heaviest bottom under the span instead — it is
+* the one edge the span can draw, so it should be the strongest claim on it.
+*/
+function aboveOfSpan(aboveBordersByCol, colIdx, span) {
+	const first = aboveBordersByCol[colIdx];
+	if (span <= 1) return first;
+	let bottom = first?.bottom;
+	for (let k = 1; k < span; k++) {
+		const b = aboveBordersByCol[colIdx + k]?.bottom;
+		if (heavierBorder(bottom, b) === b) bottom = b;
+	}
+	if (bottom === first?.bottom) return first;
+	return {
+		...first,
+		...bottom ? { bottom } : {}
+	};
+}
 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);
 		let widthPt = 0;
 		for (let k = 0; k < span && colIdx + k < columnWidthsPt.length; k++) widthPt += columnWidthsPt[colIdx + k];
+		const paintSpan = Math.min(span, Math.max(1, cell.properties.paintColumns ?? span));
+		let paintWidthPt = 0;
+		for (let k = 0; k < paintSpan && colIdx + k < columnWidthsPt.length; k++) paintWidthPt += columnWidthsPt[colIdx + k];
 		columnXOffsets.push(cursorX);
 		const mergeRole = rowMergeRoles[cellIdx] ?? "standalone";
 		const leftNeighbor = cellIdx > 0 ? row.cells[cellIdx - 1].properties.borders : void 0;
-		const cellLayout = layoutTableCell(cell, tableProps, widthPt, options, fontResources, imageResources, rowIdx, colIdx, span, rowCount, colCount, mergeRole, leftNeighbor, aboveBordersByCol[colIdx]);
-		cells.push(cellLayout);
+		const cellLayout = layoutTableCell(cell, tableProps, widthPt, options, fontResources, imageResources, rowIdx, colIdx, span, rowCount, colCount, mergeRole, leftNeighbor, aboveOfSpan(aboveBordersByCol, colIdx, span));
+		cells.push(paintWidthPt < widthPt ? {
+			...cellLayout,
+			paintWidthPt
+		} : cellLayout);
 		cursorX += widthPt;
 		colIdx += span;
 	}
 	let heightPt = 0;
-	for (const c of cells) if (c.totalHeightPt > heightPt) heightPt = c.totalHeightPt;
-	if (row.properties.height && row.properties.heightRule === "exact") heightPt = row.properties.height;
-	else if (row.properties.height && row.properties.heightRule === "atLeast") heightPt = Math.max(heightPt, row.properties.height);
+	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 {
+			heightPt,
+			cells: cells.map((c) => clipCellToHeight(c, heightPt)),
+			columnXOffsets,
+			rowIdx,
+			rowCount
+		};
+	} else if (row.properties.height && row.properties.heightRule === "atLeast") heightPt = Math.max(heightPt, row.properties.height);
 	return {
 		heightPt,
 		cells,
@@ -1713,6 +3169,59 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		rowCount
 	};
 }
+/**
+* A cell with only the lines that fit inside `heightPt`.
+*
+* Whole lines only: half a line of text reads as a rendering fault, where a
+* missing one reads as the clipping it is. A cell that already fits, or whose
+* first line does not, is returned untouched — the first line always draws, as
+* it does in Excel.
+*
+* @param cell     The laid-out cell.
+* @param heightPt The row's pinned height.
+* @returns The cell, clipped.
+*/
+function clipCellToHeight(cell, heightPt) {
+	const room = heightPt - cell.padTopPt - cell.padBottomPt;
+	if (cell.lines.length <= 1 || cell.contentHeightPt <= room) return cell;
+	const kept = [];
+	let used = 0;
+	for (const line of cell.lines) {
+		const h = computeLineHeight(line, line.resolved);
+		if (kept.length > 0 && used + h > room) break;
+		kept.push(line);
+		used += h;
+	}
+	return {
+		...cell,
+		lines: kept,
+		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 } : {},
+			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;
@@ -1721,24 +3230,66 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	const padLeftBase = cellMar?.left ?? tableMar?.left ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
 	const padRightBase = cellMar?.right ?? tableMar?.right ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
 	const padLeftPt = padLeftBase + (cell.properties.icon ? CF_ICON_GUTTER_PT : 0);
-	const padRightPt = padRightBase + (cell.properties.dropdown ? DROPDOWN_GUTTER_PT : 0);
+	const padRightPt = padRightBase;
 	const innerWidth = Math.max(1, widthPt - padLeftPt - padRightPt);
 	const lines = [];
 	const nestedTables = [];
+	const cellShapes = [];
+	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 block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, innerWidth);
-			for (const line of block.lines) {
+			const noWrap = cell.properties.noWrap === true;
+			const block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, noWrap ? NO_WRAP_MEASURE_WIDTH : innerWidth);
+			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;
 		}
+		contentHeightPt += pendingGapPt;
 	}
 	const colEnd = colStart + colSpan - 1;
 	const borders = resolveCellBorders(cell.properties.borders, tableProps.borders, rowIdx, colStart, colEnd, rowCount, colCount, mergeRole, leftNeighborBorders, aboveNeighborBorders);
@@ -1754,14 +3305,17 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 		...cell.properties.dataBar ? { dataBar: cell.properties.dataBar } : {},
 		...cell.properties.icon ? { icon: cell.properties.icon } : {},
 		...cell.properties.sparkline ? { sparkline: cell.properties.sparkline } : {},
-		...cell.properties.dropdown ? { dropdown: true } : {},
 		lines,
+		...lineGaps.size > 0 ? { lineGaps } : {},
 		...nestedTables.length > 0 ? { nestedTables } : {},
+		...cellShapes.length > 0 ? { shapes: cellShapes } : {},
 		contentHeightPt,
 		totalHeightPt,
+		...cell.properties.verticalAlign ? { verticalAlign: cell.properties.verticalAlign } : {},
 		colStart,
 		colSpan,
-		mergeRole
+		mergeRole,
+		...clipped ? { clipped: true } : {}
 	};
 }
 var BORDER_STYLE_RANK = {
@@ -1769,6 +3323,9 @@ var BORDER_STYLE_RANK = {
 	thick: 4,
 	single: 3,
 	dashed: 2,
+	dashSmallGap: 2,
+	dashDot: 2,
+	dashDotDot: 2,
 	dotted: 1,
 	none: 0
 };
@@ -1874,7 +3431,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.
@@ -1884,20 +3441,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;
@@ -1911,6 +3477,12 @@ 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). */
@@ -1929,20 +3501,131 @@ var PageAssembler = class {
 	* Consumed space counts as use, whether or not any ink went with it.
 	*/
 	colHasContent = () => this.current.length > this.colStartLen || this.cursorY < this.colStartY;
+	/**
+	* Whether this page has ANYTHING on it — including drawings, which is the
+	* whole point: a page carrying only floats has an empty `current`, so a page
+	* break asked for after it was silently dropped and the next band's drawings
+	* landed on top of the first's. tdf111980_radioButtons.xlsx has no cells at
+	* all and eleven controls wider than its page.
+	*/
+	pageHasContent = () => this.current.length > 0 || this.floatsBehind.length > 0 || this.floatsFront.length > 0;
 	/** Overflow step: next column on this page, or a fresh page after the last. */
 	advanceColumn = () => {
 		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 = [];
 	/**
@@ -1950,12 +3633,26 @@ var PageAssembler = class {
 	* must flow around. Page-scoped, like the float graphics.
 	*/
 	exclusions = [];
+	/**
+	* 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;
+		this.exclusions.push({
+			x0: x - (d?.leftPt ?? 0),
+			x1: x + w + (d?.rightPt ?? 0),
+			topYUp: topYUp + (d?.topPt ?? 0),
+			bottomYUp: topYUp - h - (d?.bottomPt ?? 0)
+		});
+	};
 	/** 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;
+		const textRight = this.ctx.marginLeft + this.ctx.contentWidth;
+		const base = h.relativeFrom === "page" || h.relativeFrom === "leftMargin" ? 0 : h.relativeFrom === "column" ? this.colLeft() : h.relativeFrom === "rightMargin" ? textRight : this.ctx.marginLeft;
+		const span = h.relativeFrom === "page" ? this.ctx.pageWidth : h.relativeFrom === "column" ? this.colWidth() : h.relativeFrom === "leftMargin" ? this.ctx.marginLeft : h.relativeFrom === "rightMargin" ? this.ctx.pageWidth - textRight : this.ctx.contentWidth;
 		if (h.align === "center") return base + (span - widthPt) / 2;
 		if (h.align === "right") return base + span - widthPt;
 		return base + (h.offsetPt ?? 0);
@@ -1964,10 +3661,19 @@ var PageAssembler = class {
 	* The drawing's TOP in the y-up cursor frame. Paragraph/line-relative offsets
 	* hang off the anchoring paragraph's current position.
 	*/
-	floatTopYUp = (f) => {
+	floatTopYUp = (f, heightPt = 0) => {
 		const v = f.posV;
 		if (!v) return this.cursorY;
-		if (v.relativeFrom === "page") return this.ctx.pageHeight - (v.offsetPt ?? 0);
+		if (v.align !== void 0) {
+			const page = v.relativeFrom === "page";
+			const topYUp = page ? this.ctx.pageHeight : this.ctx.pageHeight - this.ctx.marginTop;
+			const bottomYUp = page ? 0 : this.ctx.marginBottom;
+			if (v.align === "top") return topYUp;
+			if (v.align === "bottom") return bottomYUp + heightPt;
+			return bottomYUp + (topYUp - bottomYUp + heightPt) / 2;
+		}
+		if (v.relativeFrom === "page" || v.relativeFrom === "topMargin") return this.ctx.pageHeight - (v.offsetPt ?? 0);
+		if (v.relativeFrom === "bottomMargin") return this.ctx.marginBottom - (v.offsetPt ?? 0);
 		if (v.relativeFrom === "margin") return this.ctx.pageHeight - this.ctx.marginTop - (v.offsetPt ?? 0);
 		return this.cursorY - (v.offsetPt ?? 0);
 	};
@@ -1986,7 +3692,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).
@@ -2014,15 +3734,17 @@ 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 (rightRoom >= leftRoom) return {
+			width: rightRoom,
+			xOffset: full - rightRoom
+		};
 		return {
-			width: Math.max(MIN_WRAP_WIDTH, leftRoom),
+			width: leftRoom,
 			xOffset: 0
 		};
 	};
@@ -2041,9 +3763,15 @@ 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.width < this.colWidth()) narrowed = true;
-			else if (i > 0) break;
+			else if (narrowed) break;
 			y -= h0;
 			if (y < this.bottomLimit()) break;
 		}
@@ -2095,7 +3823,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;
@@ -2114,28 +3842,31 @@ var PageAssembler = class {
 	*              guarantee one page for a header/footer-only document).
 	*/
 	flushPage = (force = false) => {
-		if (this.current.length === 0 && this.cursorY >= this.colStartY && !force) return;
+		if (!this.pageHasContent() && this.cursorY >= this.colStartY && !force) return;
 		const band = bandForPage(this.pageInSection, this.globalPageIdx, this.ctx.titlePg, this.ctx.evenAndOddHeaders);
 		const header = pickBand(this.ctx.headerSet, band);
 		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
 			],
@@ -2152,35 +3883,212 @@ 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.current.length > 0) asm.flushPage();
+			if ((block.resolved.pageBreakBefore || block.pageBreakBefore) && asm.pageHasContent()) asm.flushPage();
 			asm.cursorY -= block.spacingBeforePt;
 			let pb = block;
 			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 borderTopY = asm.cursorY;
+			const borderPage = asm.pages.length;
 			let structId;
 			let markerLblId;
 			const firstLine = pb.lines[0];
@@ -2195,7 +4103,8 @@ 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) {
+			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);
@@ -2223,10 +4132,15 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 						});
 					}
 				}
+				for (let guard = 0; guard < 8 && asm.exclusions.length > 0; guard++) {
+					const blocked = asm.lineGeometryAt(asm.cursorY, h).blockedUntilYUp;
+					if (blocked === void 0 || blocked >= asm.cursorY) break;
+					asm.cursorY = blocked;
+				}
 				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 baselineY = pt(asm.ctx.pageHeight - (asm.cursorY + lineBaselineOffset(line, pb.resolved)));
 				const exclusionShift = asm.exclusions.length > 0 ? asm.lineGeometryAt(asm.cursorY + h, h).xOffset : 0;
 				const originX = asm.colLeft() + indentLeft + offset + exclusionShift;
 				if (markerLblId !== void 0 && line === firstLine) {
@@ -2266,86 +4180,53 @@ 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.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 } : {},
-						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();
@@ -2356,43 +4237,14 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			}
 		} else if (block.kind === "chart") {
 			const figId = builder ? createFigure(builder, block.altText, "Chart") : void 0;
-			const fig = figId !== void 0 ? { structId: figId } : {};
 			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)),
-					...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();
@@ -2403,6 +4255,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);
+					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;
@@ -2439,8 +4304,16 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 							asm.cursorY -= hr.heightPt;
 						}
 					}
-					emitRowChunk(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight, colCount, cellStructIds);
+					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);
 					asm.cursorY -= chunk.heightPt;
+					if (ci === chunks.length - 1 && ri < block.rows.length - 1) {
+						const next = block.rows[ri + 1];
+						const nextHeight = Math.min(next.heightPt, asm.ctx.pageContentHeight);
+						const nextForced = next.breakBefore && ri + 1 >= headerRows.length && asm.current.length > 0;
+						const nextOverflow = asm.cursorY - nextHeight < asm.bottomLimit() && asm.colHasContent();
+						if (nextForced || nextOverflow) emitRowBottomEdge(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight);
+					}
 				}
 			}
 		}
@@ -2453,8 +4326,44 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 		if (d.position === "header") page.commands.unshift(...cmds);
 		else page.commands.push(...cmds);
 	}
+	for (const page of asm.pages) coalesceVerticalFills(page.commands);
 	return asm.pages;
 }
+function coalesceVerticalFills(commands) {
+	const touching = (a, b) => Math.abs(a.x - b.x) < .01 && Math.abs(a.width - b.width) < .01 && a.fillColorHex === b.fillColorHex && Math.min(a.y + a.height, b.y + b.height) >= Math.max(a.y, b.y) - .01;
+	const open = /* @__PURE__ */ new Map();
+	const dead = /* @__PURE__ */ new Set();
+	for (const item of commands) {
+		if (item.type !== "fill") continue;
+		const fill = item;
+		const k = `${fill.x.toFixed(2)}|${fill.width.toFixed(2)}|${fill.fillColorHex}`;
+		const prev = open.get(k);
+		if (prev && touching(prev, fill)) {
+			const top = Math.max(prev.y + prev.height, fill.y + fill.height);
+			const bottom = Math.min(prev.y, fill.y);
+			prev.y = pt(bottom);
+			prev.height = pt(top - bottom);
+			dead.add(item);
+			continue;
+		}
+		open.set(k, fill);
+	}
+	if (dead.size === 0) return;
+	const kept = commands.filter((c) => !dead.has(c));
+	commands.length = 0;
+	commands.push(...kept);
+}
+function mergedBoxHeightPt(rows, startRowIdx, colStart, availablePt) {
+	let height = rows[startRowIdx].heightPt;
+	for (let r = startRowIdx + 1; r < rows.length; r++) {
+		const cont = rows[r].cells.find((c) => c.colStart === colStart && (c.mergeRole === "middle" || c.mergeRole === "end"));
+		if (!cont) break;
+		if (height + rows[r].heightPt > availablePt) break;
+		height += rows[r].heightPt;
+		if (cont.mergeRole === "end") break;
+	}
+	return height;
+}
 function tableCellRowSpan(rows, startRowIdx, colStart) {
 	let span = 1;
 	for (let r = startRowIdx + 1; r < rows.length; r++) {
@@ -2465,32 +4374,74 @@ function tableCellRowSpan(rows, startRowIdx, colStart) {
 	}
 	return span;
 }
-function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds) {
+function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds, mergedHeights) {
 	const rowTop = cursorY;
 	const rowBottom = cursorY - row.heightPt;
+	{
+		let i = 0;
+		while (i < row.cells.length) {
+			const cell = row.cells[i];
+			if (!cell.shadingColorHex) {
+				i++;
+				continue;
+			}
+			let width = cell.paintWidthPt ?? cell.widthPt;
+			let j = i + 1;
+			while (j < row.cells.length && cell.paintWidthPt === void 0) {
+				const next = row.cells[j];
+				if (next.mergeRole === "middle" || next.mergeRole === "end") break;
+				if (next.shadingColorHex !== cell.shadingColorHex) break;
+				width += next.paintWidthPt ?? next.widthPt;
+				j++;
+			}
+			out.push({
+				type: "fill",
+				x: pt(marginLeft + (row.columnXOffsets[i] ?? 0)),
+				y: pt(pageHeight - rowBottom - row.heightPt - FILL_SEAM_PT),
+				width: pt(width),
+				height: pt(row.heightPt + FILL_SEAM_PT),
+				fillColorHex: cell.shadingColorHex
+			});
+			i = j;
+		}
+	}
 	for (let i = 0; i < row.cells.length; i++) {
 		const cell = row.cells[i];
 		const cellX = marginLeft + (row.columnXOffsets[i] ?? 0);
 		const structId = cellStructIds?.[i];
-		if (cell.shadingColorHex && cell.mergeRole !== "middle" && cell.mergeRole !== "end") out.push({
-			type: "fill",
-			x: pt(cellX),
-			y: pt(pageHeight - rowBottom - row.heightPt),
-			width: pt(cell.widthPt),
-			height: pt(row.heightPt),
-			fillColorHex: cell.shadingColorHex
-		});
 		if (cell.dataBar && cell.mergeRole !== "middle" && cell.mergeRole !== "end") {
 			const start = Math.max(0, Math.min(1, cell.dataBar.startFraction ?? 0));
 			const barWidth = cell.widthPt * Math.max(0, Math.min(1, cell.dataBar.fraction));
-			if (barWidth > 0) out.push({
-				type: "fill",
-				x: pt(cellX + cell.widthPt * start),
-				y: pt(pageHeight - rowBottom - row.heightPt),
-				width: pt(barWidth),
-				height: pt(row.heightPt),
-				fillColorHex: cell.dataBar.colorHex
-			});
+			if (barWidth > 0) {
+				const barX = cellX + cell.widthPt * start;
+				const barBottomYUp = rowBottom;
+				out.push({
+					type: "shape",
+					shape: {
+						paths: [rectAtPath(0, 0, barWidth, row.heightPt)],
+						fillColorHex: cell.dataBar.colorHex,
+						fillGradient: {
+							kind: "linear",
+							angle: cell.dataBar.negative ? 180 : 0,
+							stops: [{
+								offset: 0,
+								colorHex: cell.dataBar.colorHex
+							}, {
+								offset: 1,
+								colorHex: "FFFFFF"
+							}]
+						},
+						transform: flipTransform([
+							1,
+							0,
+							0,
+							1,
+							barX,
+							barBottomYUp
+						], pageHeight)
+					}
+				});
+			}
 		}
 		if (cell.icon && cell.mergeRole !== "middle" && cell.mergeRole !== "end") {
 			const iconSize = Math.min(CF_ICON_SIZE_PT, Math.max(0, row.heightPt - 1));
@@ -2592,27 +4543,49 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 			if (diagUp) pushDiagonal(diagUp, 0, h);
 		}
 		if (cell.mergeRole === "middle" || cell.mergeRole === "end") continue;
-		let textY = rowTop - cell.padTopPt;
-		for (const line of cell.lines) {
+		const boxHeightPt = mergedHeights?.[i] ?? row.heightPt;
+		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;
+		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);
+					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 [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);
+			const indentLeft = line.resolved.indentLeft + (line.firstLine ? line.resolved.indentFirstLine : 0);
 			out.push({
 				type: "line",
 				line,
-				originX: pt(cellX + cell.padLeftPt + offset),
-				baselineY: pt(pageHeight - (textY + lineDescent(line))),
+				originX: pt(cellX + cell.padLeftPt + indentLeft + offset),
+				baselineY: pt(pageHeight - (textY + lineBaselineOffset(line, line.resolved))),
+				...cell.clipped ? { clip: {
+					x: pt(cellX),
+					y: pt(pageHeight - rowTop),
+					width: pt(cell.widthPt),
+					height: pt(boxHeightPt)
+				} } : {},
 				...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) {
@@ -2697,6 +4670,7 @@ function splitRowIntoChunks(row, capacity) {
 	}
 	return out.length > 0 ? out : [row];
 }
+var FILL_SEAM_PT = .07;
 function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx, rowCount, colCount) {
 	const pushSide = (side, border) => {
 		if (!border || border.style === "none") return;
@@ -2706,10 +4680,11 @@ function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx,
 			side,
 			x: pt(cellX),
 			y: pt(pageHeight - cellY - rowHeight),
-			width: pt(cell.widthPt),
+			width: pt(cell.paintWidthPt ?? cell.widthPt),
 			height: pt(rowHeight),
 			borderSizePt: sz,
-			borderColorHex: border.colorHex ?? "000000"
+			borderColorHex: border.colorHex ?? "000000",
+			...border.style !== "single" ? { borderStyle: border.style } : {}
 		});
 	};
 	pushSide("top", cell.borders.top);
@@ -2717,5 +4692,101 @@ function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx,
 	if (rowIdx === rowCount - 1) pushSide("bottom", cell.borders.bottom);
 	if (cell.colStart + cell.colSpan - 1 === colCount - 1) pushSide("right", cell.borders.right);
 }
+var NO_WRAP_MEASURE_WIDTH = 1e6;
+/**
+* One line, trimmed to the glyph that STRADDLES `widthPt` — what a non-wrapping
+* spreadsheet cell shows. Excel and LibreOffice paint that glyph and cut it
+* through the middle, and so do we now: the caller marks the cell and the
+* emitters clip the line to its box (TextLineItem.clip). Stopping at the last
+* glyph that wholly fits is what dropped a character off every cut cell.
+*/
+function clipLineToWidth(lines, widthPt, hashOnOverflow = false) {
+	const line = lines[0];
+	if (!line) return [];
+	if (line.contentWidthPt <= widthPt) return [line];
+	if (hashOnOverflow) return [hashFill(line, widthPt)];
+	const tokens = [];
+	let used = 0;
+	for (const token of line.tokens) {
+		const advance = token.widthPt;
+		if (used + advance <= widthPt) {
+			tokens.push(token);
+			used += advance;
+			continue;
+		}
+		if (token.kind === "text") {
+			const room = widthPt - used;
+			let text = "";
+			let textWidth = 0;
+			for (const ch of token.text) {
+				if (textWidth >= room) break;
+				text += ch;
+				textWidth = token.font.measure.textWidthPt(text, token.fontSizePt);
+			}
+			if (text.length > 0) {
+				tokens.push({
+					...token,
+					text,
+					widthPt: textWidth
+				});
+				used += textWidth;
+			}
+		}
+		break;
+	}
+	return [{
+		...line,
+		tokens,
+		contentWidthPt: used
+	}];
+}
+/**
+* The line as a row of `#` filling `widthPt` — what Excel and LibreOffice put in
+* a cell whose number does not fit. At least one, so the cell is never blank:
+* a column too narrow even for a single `#` still has to say something.
+*/
+function hashFill(line, widthPt) {
+	const first = line.tokens.find((t) => t.kind === "text");
+	if (!first) return line;
+	const one = first.font.measure.textWidthPt("#", first.fontSizePt);
+	const count = one > 0 ? Math.max(1, Math.floor(widthPt / one)) : 1;
+	const text = "#".repeat(count);
+	const token = {
+		...first,
+		text,
+		widthPt: first.font.measure.textWidthPt(text, first.fontSizePt)
+	};
+	return {
+		...line,
+		tokens: [token],
+		contentWidthPt: token.widthPt
+	};
+}
+/**
+* The bottom edge of a row that ends a page — the rule the row below it owed it
+* and drew on the next page instead. See the call site: a table that spills over
+* a break is closed on both sides of it, the way Excel and Word print one.
+*
+* A cell whose bottom is suppressed (a vertical merge continuing past the break)
+* stays open; inventing an edge there would cut the merge in half.
+*/
+function emitRowBottomEdge(out, row, marginLeft, rowBottom, pageHeight) {
+	for (let i = 0; i < row.cells.length; i++) {
+		const cell = row.cells[i];
+		const border = cell.borders.bottom;
+		if (!border || border.style === "none") continue;
+		out.push({
+			type: "border",
+			side: "bottom",
+			x: pt(marginLeft + (row.columnXOffsets[i] ?? 0)),
+			y: pt(pageHeight - rowBottom - row.heightPt),
+			width: pt(cell.widthPt),
+			height: pt(row.heightPt),
+			borderSizePt: border.width ?? DEFAULT_BORDER_SIZE_EIGHTH * EIGHTH_PT,
+			borderColorHex: border.colorHex ?? "000000",
+			...border.style !== "single" ? { borderStyle: border.style } : {}
+		});
+	}
+}
 //#endregion
-export { layoutStyledDocument };
+export { GLUE_SHRINK_RATIO, layoutStyledDocument };