reamkit 1.30.0 → 1.31.0

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

@@ -16,6 +16,7 @@ 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 { formatCounter } from "../core/numbering/state.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";
@@ -28,6 +29,7 @@ import { layoutMath, mathGlyphSegments, variantStyle } from "./math-layout.js";
 import { rectPath } from "../core/drawingml/preset-geometry.js";
 import { buildShapePaths, buildShapeTransform, buildStroke, gradientToSolid, lineEndPaths } from "../core/drawingml/shape-render.js";
 import { StructTreeBuilder } from "../pdf/struct-tree.js";
+import { floatIntoFrame, turnOntoSheet } from "./turned-section.js";
 //#region src/layout/styled-layout.ts
 function parsePdfAProfile(pdfA) {
 	const part = Number(pdfA.charAt(6));
@@ -39,6 +41,260 @@ function parsePdfAProfile(pdfA) {
 		version: part === 1 ? "1.4" : "1.7"
 	};
 }
+function leadingOf(options) {
+	const profile = options.layoutProfile ?? "ream";
+	if (profile !== "ream") return profile;
+	return options.typesetBy === "word" ? "word" : "flat";
+}
+var FLAT_LEADING = {
+	model: "flat",
+	markLinePt: 0
+};
+/**
+* The single line Word sets a family at, in 2048ths of the size: the ascent,
+* the gap it adds above it, and the descent. It is the face's `hhea` line (the
+* `OS/2` typo line where the face sets USE_TYPO_METRICS), not the `usWin` cell
+* — Book Antiqua stands 1.206 of its size in Word, its cell is 1.243. Measured
+* in Word for Mac on the families marked `*`; the rest read by the same rule
+* from the faces Office ships. The layout draws most of them with a twin or a
+* fallback whose own line differs (Caladea stands 1.15 of its size, Cambria
+* 1.172), so a run's height comes from here, by the family it names, and the
+* face in hand answers only for a family not listed.
+*/
+var WORD_LINE_METRICS = (() => {
+	const arial = [
+		1854,
+		67,
+		434
+	];
+	const times = [
+		1825,
+		87,
+		443
+	];
+	const courier = [
+		1705,
+		0,
+		615
+	];
+	const aptos = [
+		1923,
+		0,
+		577
+	];
+	const franklin = [
+		1877,
+		0,
+		445
+	];
+	const century = [
+		2019,
+		0,
+		443
+	];
+	const lucida = [
+		1980,
+		0,
+		432
+	];
+	return new Map([
+		["calibri", [
+			1950,
+			0,
+			550
+		]],
+		["calibri light", [
+			1950,
+			0,
+			550
+		]],
+		["carlito", [
+			1950,
+			0,
+			550
+		]],
+		["cambria", [
+			1946,
+			0,
+			455
+		]],
+		["arial", arial],
+		["helvetica", arial],
+		["liberation sans", arial],
+		["arimo", arial],
+		["arial narrow", [
+			1916,
+			0,
+			434
+		]],
+		["arial black", [
+			2254,
+			0,
+			634
+		]],
+		["times new roman", times],
+		["times", times],
+		["liberation serif", times],
+		["tinos", times],
+		["courier new", courier],
+		["courier", courier],
+		["liberation mono", courier],
+		["cousine", courier],
+		["aptos", aptos],
+		["aptos narrow", aptos],
+		["aptos light", aptos],
+		["aptos semibold", aptos],
+		["aptos extrabold", aptos],
+		["aptos black", aptos],
+		["georgia", [
+			1878,
+			0,
+			449
+		]],
+		["verdana", [
+			2059,
+			0,
+			430
+		]],
+		["tahoma", [
+			2049,
+			0,
+			423
+		]],
+		["trebuchet ms", [
+			1923,
+			0,
+			455
+		]],
+		["candara", [
+			1484,
+			452,
+			564
+		]],
+		["consolas", [
+			1521,
+			350,
+			527
+		]],
+		["constantia", [
+			1538,
+			452,
+			510
+		]],
+		["corbel", [
+			1523,
+			425,
+			525
+		]],
+		["century gothic", [
+			2060,
+			0,
+			451
+		]],
+		["century", century],
+		["century schoolbook", century],
+		["garamond", [
+			1765,
+			0,
+			539
+		]],
+		["book antiqua", [
+			1891,
+			0,
+			578
+		]],
+		["palatino linotype", [
+			2150,
+			0,
+			613
+		]],
+		["bookman old style", [
+			1929,
+			0,
+			475
+		]],
+		["rockwell", [
+			1937,
+			0,
+			468
+		]],
+		["franklin gothic book", franklin],
+		["franklin gothic medium", franklin],
+		["franklin gothic demi", franklin],
+		["gill sans mt", [
+			1903,
+			0,
+			472
+		]],
+		["tw cen mt", [
+			1753,
+			0,
+			477
+		]],
+		["lucida sans unicode", [
+			2246,
+			0,
+			901
+		]],
+		["lucida sans", lucida],
+		["lucida bright", lucida],
+		["lucida console", [
+			1616,
+			0,
+			432
+		]],
+		["comic sans ms", [
+			2257,
+			0,
+			597
+		]],
+		["impact", [
+			2066,
+			0,
+			432
+		]],
+		["goudy old style", [
+			1832,
+			140,
+			486
+		]],
+		["calisto mt", [
+			1894,
+			0,
+			470
+		]],
+		["perpetua", [
+			1679,
+			0,
+			668
+		]],
+		["symbol", [
+			2059,
+			0,
+			450
+		]],
+		["wingdings", [
+			1841,
+			0,
+			432
+		]],
+		["wingdings 2", [
+			1727,
+			0,
+			432
+		]],
+		["wingdings 3", [
+			1900,
+			0,
+			432
+		]],
+		["webdings", [
+			1638,
+			0,
+			410
+		]]
+	]);
+})();
 /** §17.6.4 — how heavy Word draws the rule between columns. */
 var COLUMN_SEPARATOR_PT = .5;
 /**
@@ -55,7 +311,6 @@ var FOOTNOTE_RULE_PT = .75;
 var FOOTNOTE_RULE_GAP_ABOVE = 4;
 var FOOTNOTE_SEPARATOR_HEIGHT = 10;
 var LINE_NUMBER_GAP_PT = 18;
-var FLOAT_TEXT_GAP = 6;
 var MIN_WRAP_WIDTH = 36;
 function isOutOfFlowFloat(f) {
 	return f !== void 0 && f.wrap !== "topAndBottom";
@@ -315,6 +570,7 @@ function layoutStyledDocument(body, options) {
 	const blocks = numberedBody.map((el, idx) => {
 		while (sectionIdx < sectionCtxs.length - 1 && idx >= sectionCtxs[sectionIdx].endIndex) sectionIdx++;
 		const ctx = sectionCtxs[sectionIdx];
+		const own = ctx.sheet ? floatIntoFrame(el, ctx.sheet) : el;
 		const width = ctx.columns ? ctx.columns[0].widthPt : ctx.contentWidth;
 		const box = {
 			pageWidthPt: ctx.pageWidth,
@@ -327,7 +583,7 @@ function layoutStyledDocument(body, options) {
 		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);
+		return layoutBodyElement(own, ctx.options ?? options, fontResources, imageResources, width, ctx.pageContentHeight, box);
 	});
 	for (let i = 0; i < blocks.length; i++) {
 		const here = blocks[i];
@@ -359,9 +615,15 @@ function layoutStyledDocument(body, options) {
 			let laid = void 0;
 			if (content && n !== void 0 && !noteAssigned.deferredFootnotes.includes(id)) {
 				const noteBlocks = substituteNoteNumber(content, n).map((el) => layoutBodyElement(el, sectionCtx.options ?? options, fontResources, imageResources, sectionCtx.contentWidth, sectionCtx.pageContentHeight));
+				const spacing = new SpacingStack(collapsesSpacing(sectionCtx.options ?? options));
 				laid = {
 					blocks: noteBlocks,
-					heightPt: noteBlocks.reduce((sum, b) => sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : 0), 0)
+					heightPt: noteBlocks.reduce((sum, b) => {
+						if (b.kind !== "paragraph") return sum;
+						const before = spacing.open(b.spacingBeforePt);
+						spacing.close(b.spacingAfterPt);
+						return sum + before + b.heightPt + b.spacingAfterPt;
+					}, 0)
 				};
 			}
 			byId.set(id, laid);
@@ -435,7 +697,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, backgroundImageOf(options, imageResources)),
+		pages: paginateSections(blocks, sectionCtxs, structBuilder, options.language ?? "en-US", notePlan, bookmarks, reflowParagraph, backgroundImageOf(options, imageResources), collapsesSpacing(options), options.compatibilityMode),
 		resources: options.resources ?? new ResourceStore(),
 		fontResources,
 		imageResources,
@@ -509,9 +771,52 @@ function buildSectionContext(section, options, headersFooters, fontResources, im
 		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);
+	const bodyMarginsFor = (band) => {
+		const header = pickBand(headerSet, band).heightPt ?? 0;
+		const footer = pickBand(footerSet, band).heightPt ?? 0;
+		return {
+			top: Math.max(dims.marginTop, header > 0 ? dims.headerOffsetPt + header : 0),
+			bottom: Math.max(dims.marginBottom, footer > 0 ? dims.footerOffsetPt + footer : 0)
+		};
+	};
+	const bandMargins = {
+		default: bodyMarginsFor("default"),
+		first: bodyMarginsFor("first"),
+		even: bodyMarginsFor("even")
+	};
+	const marginTop = bandMargins.default.top;
+	const marginBottom = bandMargins.default.bottom;
+	if (section.properties.textDirection !== void 0) {
+		const sheet = {
+			width: dims.pageWidth,
+			height: dims.pageHeight,
+			marginLeft: dims.marginLeft,
+			marginRight: dims.marginRight,
+			marginTop,
+			marginBottom
+		};
+		const across = sheet.height - sheet.marginTop - sheet.marginBottom;
+		const turnedColumns = buildColumnGeometry(section.properties.columns, across);
+		return {
+			endIndex: section.endIndex,
+			properties: section.properties,
+			pageWidth: sheet.height,
+			pageHeight: sheet.width,
+			marginLeft: sheet.marginTop,
+			marginTop: sheet.marginRight,
+			marginBottom: sheet.marginLeft,
+			contentWidth: across,
+			pageContentHeight: sheet.width - sheet.marginRight - sheet.marginLeft,
+			...turnedColumns ? { columns: turnedColumns } : {},
+			headerSet,
+			footerSet,
+			titlePg: section.properties.titlePg === true,
+			evenAndOddHeaders: section.properties.evenAndOddHeaders === true,
+			continuous: section.properties.sectionStart === "continuous",
+			options: secOptions,
+			sheet
+		};
+	}
 	return {
 		endIndex: section.endIndex,
 		properties: section.properties,
@@ -519,12 +824,13 @@ function buildSectionContext(section, options, headersFooters, fontResources, im
 		pageHeight: dims.pageHeight,
 		marginLeft: dims.marginLeft,
 		marginTop,
-		marginBottom: dims.marginBottom,
+		marginBottom,
 		contentWidth,
-		pageContentHeight: dims.pageHeight - marginTop - dims.marginBottom,
+		pageContentHeight: dims.pageHeight - marginTop - marginBottom,
 		...columns ? { columns } : {},
 		headerSet,
 		footerSet,
+		bandMargins,
 		titlePg: section.properties.titlePg === true,
 		evenAndOddHeaders: section.properties.evenAndOddHeaders === true,
 		continuous: section.properties.sectionStart === "continuous",
@@ -572,15 +878,15 @@ function layoutHeaderSet(section, headersFooters, options, fontResources, imageR
 		let measured = 0;
 		const render = (c) => {
 			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth, imageResources, relativeBox);
-			measured = blocksHeight(blocks);
-			return markPagination(drawBlocksSequentially(blocks, marginLeft, pageHeight - headerOffsetPt, pageHeight, contentWidth, void 0, bandMargins));
+			measured = blocksHeight(blocks, collapsesSpacing(options));
+			return markPagination(drawBlocksSequentially(blocks, marginLeft, pageHeight - headerOffsetPt, pageHeight, contentWidth, void 0, bandMargins, collapsesSpacing(options)));
 		};
 		if (contentHasPageFields(content)) {
-			render(substitutePageFields(content, 1, 1));
+			render(substitutePageFields(content, "1", 1));
 			return {
 				commands: [],
 				heightPt: measured,
-				renderDynamic: (n, total) => render(substitutePageFields(content, n, total))
+				renderDynamic: (page, total) => render(substitutePageFields(content, page, total))
 			};
 		}
 		return {
@@ -609,11 +915,61 @@ function balancedColumnHeight(bandHeightPt, colCount, roomPt) {
 	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) {
+/**
+* §17.3.1.33 — the space between paragraphs down one story (a page, a cell, a
+* band, a box). Where the document is set as Word sets it, two paragraphs
+* stand the LARGER of the first's space after and the second's space before
+* apart, not the two together. Measured in Word for Mac, in modes 14 and 15
+* alike: 10pt after and 10pt before stand 10pt apart; 10 and 24 stand 24,
+* whichever comes first; 6 and 12 stand 12 either way. An empty paragraph
+* between takes its share of both sides. Elsewhere the two add up.
+*/
+var SpacingStack = class {
+	/** The space after the last block, which a paragraph right below may share. */
+	shared = 0;
+	constructor(collapse) {
+		this.collapse = collapse;
+	}
+	/**
+	* @param beforePt A block's own space before.
+	* @returns The room to open above it.
+	*/
+	open(beforePt) {
+		const room = this.collapse ? Math.max(0, beforePt - this.shared) : beforePt;
+		this.shared = 0;
+		return room;
+	}
+	/** @param spacingPt The space a block just left below itself, as far as a paragraph may share it. */
+	close(spacingPt) {
+		this.shared = spacingPt;
+	}
+};
+/** Whether a layout stacks paragraph spacing as Word does (see {@link SpacingStack}). */
+function collapsesSpacing(options) {
+	return options.typesetBy === "word";
+}
+/** A block's space after, less the line a picture's spacing adds under it: the part a paragraph below shares. */
+function sharedAfter(block) {
+	return block.spacingAfterPt - (block.lineExtraPt ?? 0);
+}
+/**
+* Total laid-out height of a run of blocks, paragraph spacing included.
+*
+* @param blocks   The blocks, in order.
+* @param collapse Whether their spacing stacks as Word stacks it (see {@link SpacingStack}).
+* @returns The height in points.
+*/
+function blocksHeight(blocks, collapse = false) {
+	const spacing = new SpacingStack(collapse);
 	return blocks.reduce((sum, b) => {
 		if (b.kind !== "paragraph" && isOutOfFlowFloat(b.float)) return sum;
-		return sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : b.heightPt);
+		if (!("spacingBeforePt" in b)) {
+			spacing.close(0);
+			return sum + b.heightPt;
+		}
+		const before = spacing.open(b.spacingBeforePt);
+		spacing.close(sharedAfter(b));
+		return sum + before + b.heightPt + b.spacingAfterPt;
 	}, 0);
 }
 function layoutFooterSet(section, headersFooters, options, fontResources, imageResources, contentWidth, marginLeft, pageHeight, footerOffsetPt, bandMargins, relativeBox) {
@@ -622,15 +978,25 @@ function layoutFooterSet(section, headersFooters, options, fontResources, imageR
 		if (!ref) return { commands: [] };
 		const content = headersFooters.get(ref.relationshipId);
 		if (!content) return { commands: [] };
+		let measured = 0;
 		const render = (c) => {
 			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth, imageResources, relativeBox);
-			return markPagination(drawBlocksSequentially(blocks, marginLeft, footerOffsetPt + blocksHeight(blocks), pageHeight, contentWidth, void 0, bandMargins));
+			const totalHeight = blocksHeight(blocks, collapsesSpacing(options));
+			measured = totalHeight;
+			return markPagination(drawBlocksSequentially(blocks, marginLeft, footerOffsetPt + totalHeight, pageHeight, contentWidth, void 0, bandMargins, collapsesSpacing(options)));
 		};
-		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: (page, total) => render(substitutePageFields(content, page, total))
+			};
+		}
+		return {
+			commands: render(content),
+			heightPt: measured
 		};
-		return { commands: render(content) };
 	};
 	return {
 		default: band("default"),
@@ -642,7 +1008,20 @@ function contentHasPageFields(content) {
 	for (const el of content) if (el.kind === "paragraph" && el.paragraph.runs.some((r) => r.field !== void 0)) return true;
 	return false;
 }
-function substitutePageFields(content, pageNumber, totalPages) {
+/**
+* §17.6.12 — a page's number as its section prints it: in the numerals
+* `w:pgNumType w:fmt` names (§17.18.59), decimal where it names none. A format
+* that has no numeral for the number — a roman zero — prints it in digits.
+*
+* @param pageNumber The page's number in its section's count.
+* @param format     The section's page-number format.
+* @returns The text a PAGE field shows on that page.
+*/
+function pageNumberText(pageNumber, format) {
+	const text = format === void 0 ? "" : formatCounter(format, pageNumber);
+	return text !== "" ? text : String(pageNumber);
+}
+function substitutePageFields(content, pageText, totalPages) {
 	return content.map((el) => {
 		if (el.kind !== "paragraph") return el;
 		if (!el.paragraph.runs.some((r) => r.field !== void 0)) return el;
@@ -652,7 +1031,7 @@ function substitutePageFields(content, pageNumber, totalPages) {
 				...el.paragraph,
 				runs: el.paragraph.runs.map((r) => r.field === void 0 ? r : {
 					...r,
-					text: String(r.field === "PAGE" ? pageNumber : totalPages)
+					text: r.field === "PAGE" ? pageText : String(totalPages)
 				})
 			}
 		};
@@ -953,12 +1332,33 @@ function layoutBodyElement(el, options, fontResources, imageResources, contentWi
 	if (el.kind === "image") {
 		const res = el.image.resource ? imageResources?.get(el.image.resource) : void 0;
 		const meta = res?.metafile;
-		return meta ? layoutMetafileBlock(el.image, meta, res.metafileImages, options, fontResources, contentWidth, maxHeight, box) : layoutImageBlock(el.image, imageResources, contentWidth, maxHeight, box);
+		return meta ? layoutMetafileBlock(el.image, meta, res.metafileImages, options, fontResources, contentWidth, maxHeight, box) : layoutImageBlock(el.image, imageResources, contentWidth, maxHeight, box, options);
 	}
 	if (el.kind === "chart") return layoutChartBlock(el.chart, options, fontResources, contentWidth, maxHeight, imageResources);
 	return layoutShapeBlock(el.shape, options, fontResources, imageResources, contentWidth, maxHeight, box);
 }
-function layoutImageBlock(image, imageResources, contentWidth, maxHeight, box) {
+/**
+* §17.3.1.33 — what a paragraph's line spacing adds under a picture that
+* stands on a line of its own. Word sets that line as tall as the picture,
+* and a spacing of more than one line adds what the extra lines of the
+* paragraph mark's font would, not a share of the picture: in Word for Mac a
+* 100pt picture's next paragraph stands 100, 102.5 and 113 points down at
+* single, 1.15 and double spacing of an 11pt mark.
+*
+* @param pp      The paragraph the picture stands on, resolved.
+* @param options The render options its mark's font resolves against; absent
+*                for a picture out of the flow.
+* @returns The extra points, 0 where the spacing is not a multiple above one.
+*/
+function pictureLineExtra(pp, options) {
+	if (!options) return 0;
+	if (pp.spacingLine === void 0 || (pp.spacingLineRule ?? "auto") !== "auto") return 0;
+	const multiple = Math.round(pp.spacingLine * 20) / 240;
+	if (multiple <= 1) return 0;
+	if (leadingOf(options) !== "flat") return (multiple - 1) * paragraphLeading(pp, options).markLinePt;
+	return (multiple - 1) * resolveRunProperties({}, pp, options.styles).fontSizePt * 1.2;
+}
+function layoutImageBlock(image, imageResources, contentWidth, maxHeight, box, options) {
 	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) {
@@ -993,6 +1393,7 @@ function layoutImageBlock(image, imageResources, contentWidth, maxHeight, box) {
 		heightPt = reservedH;
 		drawInset = box;
 	}
+	const lineExtraPt = image.float ? 0 : pictureLineExtra(image.paragraphProperties, options);
 	const res = image.resource ? imageResources?.get(image.resource) : void 0;
 	const resolvedAlignment = image.paragraphProperties.alignment ?? "left";
 	return {
@@ -1010,7 +1411,8 @@ function layoutImageBlock(image, imageResources, contentWidth, maxHeight, box) {
 		...image.flipV ? { flipV: true } : {},
 		...drawInset ? { drawInset } : {},
 		spacingBeforePt: image.paragraphProperties.spacingBefore ?? 0,
-		spacingAfterPt: image.paragraphProperties.spacingAfter ?? 0,
+		spacingAfterPt: (image.paragraphProperties.spacingAfter ?? 0) + lineExtraPt,
+		...lineExtraPt > 0 ? { lineExtraPt } : {},
 		...image.altText ? { altText: image.altText } : {},
 		...image.float ? { float: image.float } : {}
 	};
@@ -1054,8 +1456,10 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 	const upright = text?.upright;
 	const warp = text?.warp;
 	if (text && text.content.length > 0) {
-		const innerWidth = warp ? Number.MAX_SAFE_INTEGER : vertical ? Math.max(1, heightPt - insetTopPt - insetBottomPt) : Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		const innerWidth = warp || text.noWrap === true ? Number.MAX_SAFE_INTEGER : vertical ? Math.max(1, heightPt - insetTopPt - insetBottomPt) : Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		const spacing = new SpacingStack(collapsesSpacing(options));
 		for (const el of text.content) {
+			if (el.kind !== "paragraph") spacing.close(0);
 			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));
@@ -1129,7 +1533,8 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 				continue;
 			}
 			const blk = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, innerWidth);
-			const before = textLines.length > 0 ? blk.spacingBeforePt : 0;
+			const opened = spacing.open(blk.spacingBeforePt);
+			const before = textLines.length > 0 ? opened : 0;
 			if (before > 0) {
 				const last = textLines.length - 1;
 				textLineGaps.set(last, (textLineGaps.get(last) ?? 0) + before);
@@ -1144,6 +1549,7 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 				textLineGaps.set(last, (textLineGaps.get(last) ?? 0) + blk.spacingAfterPt);
 			}
 			textHeightPt += blk.spacingAfterPt;
+			spacing.close(blk.spacingAfterPt);
 		}
 	}
 	if (text?.autoFit && !vertical && textLines.length > 0) heightPt = textHeightPt + insetTopPt + insetBottomPt;
@@ -1259,6 +1665,7 @@ function layoutMetafileBlock(image, pic, blitted, options, fontResources, conten
 	const heightPt = placed.heightPt;
 	const layout = rotateDrawing(metafileDrawing(pic, widthPt, heightPt, options, fontResources, image.colorChange, blitted), (image.rotation60k ?? 0) / 6e4, widthPt / 2, heightPt / 2);
 	const pp = image.paragraphProperties;
+	const lineExtraPt = image.float ? 0 : pictureLineExtra(pp, options);
 	return {
 		kind: "chart",
 		widthPt,
@@ -1266,7 +1673,8 @@ function layoutMetafileBlock(image, pic, blitted, options, fontResources, conten
 		layout,
 		resolvedAlignment: pp.alignment ?? "left",
 		spacingBeforePt: pp.spacingBefore ?? 0,
-		spacingAfterPt: pp.spacingAfter ?? 0,
+		spacingAfterPt: (pp.spacingAfter ?? 0) + lineExtraPt,
+		...lineExtraPt > 0 ? { lineExtraPt } : {},
 		figureRole: "Image",
 		...image.altText ? { altText: image.altText } : {},
 		...image.float ? { float: image.float } : {}
@@ -2231,9 +2639,10 @@ function bandAnchorTop(float, cursorY, pageHeight, heightPt = 0, margins) {
 	const offset = float.posV?.offsetPt ?? 0;
 	return float.posV?.relativeFrom === "page" ? pageHeight - offset : cursorY - offset;
 }
-function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth, structId, bandMargins) {
+function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth, structId, bandMargins, collapse = false) {
 	const out = [];
 	let cursorY = startY;
+	const spacing = new SpacingStack(collapse);
 	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) {
@@ -2252,18 +2661,20 @@ function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth
 				emitRowChunk(out, row, tableX, cursorY, pageHeight, block.colCount);
 				cursorY -= row.heightPt;
 			}
+			spacing.close(0);
 			continue;
 		}
 		if (block.kind === "chart") {
-			cursorY -= block.spacingBeforePt + block.heightPt;
+			cursorY -= spacing.open(block.spacingBeforePt) + block.heightPt;
 			const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, contentWidth);
 			out.push(...chartPageItems(block, startX + offset, cursorY, pageHeight, structId));
 			cursorY -= block.spacingAfterPt;
+			spacing.close(sharedAfter(block));
 			continue;
 		}
 		if (block.kind === "image") {
-			cursorY -= block.spacingBeforePt;
 			const anchored = bandAnchor(block.float, block.widthPt, contentWidth, startX);
+			cursorY -= anchored === void 0 ? spacing.open(block.spacingBeforePt) : block.spacingBeforePt;
 			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({
@@ -2283,19 +2694,21 @@ function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth
 			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;
+			if (anchored === void 0) spacing.close(sharedAfter(block));
 			continue;
 		}
 		if (block.kind === "shape") {
-			cursorY -= block.spacingBeforePt;
 			const anchored = bandAnchor(block.float, block.widthPt, contentWidth, startX);
+			cursorY -= anchored === void 0 ? spacing.open(block.spacingBeforePt) : block.spacingBeforePt;
 			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;
+			if (anchored === void 0) spacing.close(block.spacingAfterPt);
 			continue;
 		}
-		cursorY -= block.spacingBeforePt;
+		cursorY -= spacing.open(block.spacingBeforePt);
 		const bandTopY = cursorY;
 		for (const line of block.lines) {
 			const h = computeLineHeight(line, block.resolved);
@@ -2312,6 +2725,7 @@ function drawBlocksSequentially(blocks, startX, startY, pageHeight, contentWidth
 		}
 		out.push(...paragraphDecoration(block.resolved, startX + block.resolved.indentLeft, startX + contentWidth - block.resolved.indentRight, bandTopY, cursorY, pageHeight));
 		cursorY -= block.spacingAfterPt;
+		spacing.close(block.spacingAfterPt);
 	}
 	return out;
 }
@@ -2604,6 +3018,7 @@ function lookupFont(resources, fontKey) {
 }
 function collectFontResources(body, headersFooters, options, imageResources) {
 	const used = /* @__PURE__ */ new Map();
+	const numerals = [...new Set([options.section, ...(options.sections ?? []).map((sec) => sec.properties)].flatMap((p) => p?.pageNumberFormat !== void 0 ? [p.pageNumberFormat] : []))].map((fmt) => Array.from({ length: 200 }, (_, i) => formatCounter(fmt, i + 1)).join("")).join("");
 	const addRun = (run, para) => {
 		const resolved = resolveRunProperties(run.properties, para.properties, options.styles);
 		const { fontKey, parsed } = runFontKeyAndParsed(options, resolved.fontFamily.ascii, resolved.bold, resolved.italic);
@@ -2678,7 +3093,7 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 				if (run.inlineImage && !run.text) continue;
 				if (run.field !== void 0) {
 					addRun({
-						text: `${run.text}0123456789`,
+						text: `${run.text}0123456789${numerals}`,
 						properties: run.properties
 					}, el.paragraph);
 					continue;
@@ -2793,13 +3208,10 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 * 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;
+function emptyLine(paragraph, options, resolved, availableWidthPt) {
+	const fontSizePt = resolveRunProperties(paragraph.properties.runProperties ?? {}, paragraph.properties, options.styles).fontSizePt;
+	const model = leadingOf(options);
+	const metric = model === "flat" ? void 0 : markLine(paragraph.properties, options, model);
 	return {
 		tokens: [],
 		contentWidthPt: 0,
@@ -2810,10 +3222,37 @@ function emptyLine(paragraph, options, resolved, availableWidthPt, fontResources
 		isLastInParagraph: true,
 		...metric && metric.ascentPt + metric.descentPt > 0 ? {
 			metricHeightPt: metric.ascentPt + metric.descentPt + metric.lineGapPt,
-			metricDescentPt: metric.descentPt
+			metricDescentPt: metric.descentPt,
+			metricTextHeightPt: metric.ascentPt + metric.descentPt + metric.lineGapPt
 		} : {}
 	};
 }
+/**
+* The single line of a paragraph mark's font (§17.3.1.29 `w:rPr` on the
+* `w:pPr`) under a model that reads faces: what an empty paragraph stands, and
+* what a spacing of more lines adds to a line with no text on it.
+*
+* @param pp      The paragraph's properties.
+* @param options Render options (styles, fonts).
+* @param model   The line model.
+* @returns Its ascent, descent and gap, in points.
+*/
+function markLine(pp, options, model) {
+	const mark = resolveRunProperties(pp.runProperties ?? {}, pp, options.styles);
+	const family = mark.fontFamily.ascii;
+	const { parsed } = runFontKeyAndParsed(options, family, mark.bold, mark.italic);
+	return fontLeadingPt(parsed, mark.fontSizePt, model, family);
+}
+/** What a paragraph's lines are reckoned from, under the layout's model. */
+function paragraphLeading(pp, options) {
+	const model = leadingOf(options);
+	if (model === "flat") return FLAT_LEADING;
+	const m = markLine(pp, options, model);
+	return {
+		model,
+		markLinePt: m.ascentPt + m.descentPt + m.lineGapPt
+	};
+}
 function layoutParagraphBlock(paragraph, options, fontResources, imageResources, contentWidth, lineWidths) {
 	const cascaded = resolveParagraphProperties(paragraph.properties, options.styles);
 	const baseResolved = options.gridLinePitchPt !== void 0 && cascaded.snapToGrid !== false ? {
@@ -2842,7 +3281,8 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 	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 leading = paragraphLeading(paragraph.properties, options);
+	const runWrap = (part, firstWidth, widths) => wrap(part, firstWidth, otherWidth, resolved, options.hyphenator, options.layoutProfile ?? "ream", leading, options.doNotExpandShiftReturn === true, widths);
 	const parts = splitAtColumnBreaks(tokens);
 	const columnBreakLines = /* @__PURE__ */ new Set();
 	let wrapped;
@@ -2858,12 +3298,13 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 			})));
 		}
 	}
-	const lines = wrapped.length > 0 ? wrapped : [emptyLine(paragraph, options, resolved, Math.max(firstLineWidth, 0), fontResources)];
+	const lines = wrapped.length > 0 ? wrapped : [emptyLine(paragraph, options, resolved, Math.max(firstLineWidth, 0))];
 	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 holds = (r) => r.text !== "" || r.inlineImage !== void 0 || r.math !== void 0;
+	const leadingPageBreak = breakIdx >= 0 && paragraph.runs.slice(0, breakIdx + 1).every((r) => r.text === "" && r.inlineImage === void 0) && paragraph.runs.slice(breakIdx + 1).some(holds);
 	const trailingPageBreak = paragraph.runs.some((r, i) => r.pageBreak === true && (!leadingPageBreak || i > breakIdx));
 	return {
 		kind: "paragraph",
@@ -3186,7 +3627,7 @@ function measureRunText(plan, text, face) {
 		font: plan.font,
 		...plan.synthetic ? { synthetic: plan.synthetic } : {}
 	};
-	const base = drawn.font.measure.textWidthPt(text, plan.fontSizePt) * (drawn.synthetic?.widthScale ?? 1);
+	const base = drawn.font.measure.textWidthPt(text, plan.fontSizePt) * (drawn.synthetic?.widthScale ?? 1) * (plan.resolvedRun.widthScale ?? 1);
 	const extra = plan.resolvedRun.letterSpacingPt;
 	return extra === void 0 || extra === 0 ? base : base + extra * [...text].length;
 }
@@ -3634,7 +4075,7 @@ function splitToWidth(tok, widthPt) {
 }
 /** The fewest characters a mid-word break may leave on a line. */
 var MIN_SPLIT_CHARS = 6;
-function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, profile, allowEmpty = false) {
+function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, leading, allowEmpty = false) {
 	let st = start;
 	let et = breakIdx;
 	while (st < et && (entries[st].token === null || !isFirst && entries[st].token?.isSpace === true)) st++;
@@ -3662,10 +4103,12 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 	let maxSize = 0;
 	let mathAscent = 0;
 	let mathDescent = 0;
-	const useMetric = profile !== "ream";
-	let metricAscent = 0;
-	let metricDescent = 0;
-	let metricLineGap = 0;
+	const useMetric = leading.model !== "flat";
+	let textAscent = 0;
+	let textDescent = 0;
+	let markerAscent = 0;
+	let markerDescent = 0;
+	let pictureHeight = 0;
 	const prints = lineTokens.some((t) => !t.isSpace);
 	for (const t of lineTokens) {
 		contentWidth += t.widthPt;
@@ -3676,13 +4119,22 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 			mathAscent = Math.max(mathAscent, t.ascentPt);
 			mathDescent = Math.max(mathDescent, t.descentPt);
 		} else if (useMetric && t.kind === "text") {
-			const m = fontLeadingPt(t.font.parsed, t.fontSizePt, profile);
-			if (m.ascentPt > metricAscent) metricAscent = m.ascentPt;
-			if (m.descentPt > metricDescent) metricDescent = m.descentPt;
-			if (m.lineGapPt > metricLineGap) metricLineGap = m.lineGapPt;
-		}
+			const m = fontLeadingPt(t.font.parsed, t.fontSizePt, leading.model, wordFamilyOf(t));
+			const above = m.ascentPt + m.lineGapPt;
+			if (t.listMarker === true) {
+				markerAscent = Math.max(markerAscent, above);
+				markerDescent = Math.max(markerDescent, m.descentPt);
+			} else {
+				textAscent = Math.max(textAscent, above);
+				textDescent = Math.max(textDescent, m.descentPt);
+			}
+		} else if (useMetric && t.kind === "image") pictureHeight = Math.max(pictureHeight, t.heightPt);
 	}
-	const hasMetric = useMetric && metricAscent + metricDescent > 0;
+	const hasText = textAscent + textDescent > 0;
+	const ascent = Math.max(textAscent, markerAscent);
+	const descent = hasText ? textDescent : markerDescent;
+	const hasMetric = useMetric && ascent + descent + pictureHeight > 0;
+	const textLine = ascent + descent > 0 ? ascent + descent : leading.markLinePt;
 	return {
 		tokens: lineTokens,
 		contentWidthPt: contentWidth,
@@ -3694,8 +4146,9 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 		mathAscentPt: mathAscent,
 		mathDescentPt: mathDescent,
 		...hasMetric ? {
-			metricHeightPt: metricAscent + metricDescent + metricLineGap,
-			metricDescentPt: metricDescent
+			metricHeightPt: Math.max(ascent, pictureHeight) + descent,
+			metricDescentPt: descent,
+			metricTextHeightPt: textLine
 		} : {}
 	};
 }
@@ -3715,7 +4168,7 @@ function withLeadingTabWidths(tokens, resolved, firstLineWidth) {
 	}
 	return out;
 }
-function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, noExpandShiftReturn, lineWidths) {
+function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, leading, noExpandShiftReturn, lineWidths) {
 	if (tokens.length === 0) return [];
 	const widths = lineWidths ?? [firstLineWidth, otherWidth];
 	const entries = paragraphItemStream(withLeadingTabWidths(tokens, resolved, widths[0] ?? firstLineWidth), hyphenator, Math.max(0, ...widths));
@@ -3728,7 +4181,7 @@ function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile,
 		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);
+			const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, leading, i < at.length - 1);
 			if (line) out.push(noExpandShiftReturn && entries[breakIdx]?.softBreak ? {
 				...line,
 				noJustify: true
@@ -3748,14 +4201,55 @@ function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile,
 	if (lines.length > 0) lines[lines.length - 1].isLastInParagraph = true;
 	return lines;
 }
-function fontLeadingPt(parsed, sizePt, profile) {
+/**
+* §17.3.2.26 — the family Word sets a token's characters in: East Asian text
+* in the run's `eastAsia` font, complex-script text (and a `w:rtl` run) in its
+* `cs` one, the rest in `ascii` — `hAnsi` above ASCII. The layout draws a run
+* with its ascii face and hands what that face lacks to another, so the name
+* the run gives for THESE characters is the one Word's line is looked up by:
+* a Chinese sentence in a Calibri run does not stand on Calibri's line.
+*
+* @param t The text token.
+* @returns The family's name, when the run gives one for that slot.
+*/
+function wordFamilyOf(t) {
+	const fonts = t.resolvedRun.fontFamily;
+	if (t.resolvedRun.rtl) return fonts.cs;
+	let high = false;
+	for (const ch of t.text) {
+		const cp = ch.codePointAt(0) ?? 0;
+		if (cp <= 127) continue;
+		high = true;
+		const script = scriptForCodepoint(cp);
+		if (script === "hebrew" || script === "arabic" || script === "thai") return fonts.cs;
+		if (script === "kr" || script === "jp" || script === "sc") return fonts.eastAsia;
+	}
+	return high ? fonts.hAnsi ?? fonts.ascii : fonts.ascii;
+}
+/**
+* A face's single line at a size: its ascent, its descent, and the gap set
+* above the text. Under `'word'` a family Word's own line is known for (see
+* {@link WORD_LINE_METRICS}) takes that; otherwise the face in hand gives its
+* hhea line, or the OS/2 typo one when it sets USE_TYPO_METRICS.
+*
+* @param parsed The face the run is drawn with.
+* @param sizePt The run's size.
+* @param model  The line model (never `'flat'`, which asks no face).
+* @param family The family the run names, when it names one.
+* @returns The three, in points; the descent as a magnitude.
+*/
+function fontLeadingPt(parsed, sizePt, model, family) {
+	const known = model === "word" && family !== void 0 ? WORD_LINE_METRICS.get(family.trim().toLowerCase()) : void 0;
+	if (known) {
+		const k = sizePt / 2048;
+		return {
+			ascentPt: known[0] * k,
+			lineGapPt: known[1] * k,
+			descentPt: known[2] * k
+		};
+	}
 	const s = sizePt / parsed.unitsPerEm;
 	const vm = parsed.vmetrics;
-	if (profile === "word") return {
-		ascentPt: vm.winAscent * s,
-		descentPt: vm.winDescent * s,
-		lineGapPt: 0
-	};
 	const asc = vm.useTypoMetrics ? vm.typoAscent : parsed.ascender;
 	const desc = vm.useTypoMetrics ? vm.typoDescent : parsed.descender;
 	const gap = vm.useTypoMetrics ? vm.typoLineGap : parsed.lineGap;
@@ -3780,7 +4274,8 @@ function naturalLineHeight(line, p) {
 	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;
-	return Math.max(natural * multiple, mathNeed);
+	const scaled = line.metricTextHeightPt === void 0 ? natural * multiple : natural + (multiple - 1) * line.metricTextHeightPt;
+	return Math.max(scaled, mathNeed);
 }
 function lineDescent(line) {
 	const fs = line.maxFontSizePt || 12;
@@ -3931,7 +4426,7 @@ function layoutTableBlock(table, options, fontResources, imageResources, content
 	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);
+	const xOffsetPt = (table.properties.indentPt ?? 0) + tableXOffset(table.properties.alignment, contentWidth, totalWidthPt) - legacyTableOutdent(table, rows, options);
 	return {
 		kind: "table",
 		...table.properties.float ? { float: table.properties.float } : {},
@@ -3968,6 +4463,29 @@ function growRowsForMerges(rows) {
 		};
 	}
 }
+/**
+* [MS-DOCX] `compatibilityMode` — how far a table stands out past its indent
+* in a document laid out as Word 2010 and earlier lay it out. There the
+* indent places the first cell's TEXT, not the table's edge, so the table
+* stands out by that cell's left margin. Measured in Word for Mac: with
+* first-cell margins of 5.4, 15 and 20pt, the text stands at the margin in a
+* document of mode 14 and in one that states no mode, and 5.4, 15 and 20pt in
+* at mode 15. A 36pt `w:tblInd` puts the text 36pt in, not 41.4. A centred
+* table does not move. Only a Word document's table moves; a spreadsheet has
+* no such history.
+*
+* @param table   The table.
+* @param rows    Its laid-out rows, the first cell's margin resolved.
+* @param options Render options: whose document, and which mode.
+* @returns The points to move the table left by, 0 where it stays.
+*/
+function legacyTableOutdent(table, rows, options) {
+	if (options.typesetBy !== "word" || (options.compatibilityMode ?? 0) >= 15) return 0;
+	if ((table.properties.alignment ?? "left") !== "left" || table.properties.float) return 0;
+	const first = rows[0];
+	if (!first || first.columnXOffsets[0] !== 0) return 0;
+	return first.cells[0]?.padLeftPt ?? 0;
+}
 function tableXOffset(alignment, contentWidth, totalWidthPt) {
 	const slack = contentWidth - totalWidthPt;
 	if (slack <= 0 || !alignment || alignment === "left") return 0;
@@ -4126,7 +4644,7 @@ function measureSingleLine(paragraph, options, fontResources) {
 		const { fontKey, synthetic } = runFontKeyAndParsed(options, resolved.fontFamily.ascii, resolved.bold, resolved.italic);
 		const font = lookupFont(fontResources, fontKey);
 		const fontSizePt = resolved.fontSizePt;
-		total += font.measure.textWidthPt(run.text, fontSizePt) * (synthetic?.widthScale ?? 1);
+		total += font.measure.textWidthPt(run.text, fontSizePt) * (synthetic?.widthScale ?? 1) * (resolved.widthScale ?? 1);
 	}
 	return total;
 }
@@ -4179,6 +4697,13 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		cursorX += widthPt;
 		colIdx += span;
 	}
+	const bands = options.typesetBy === "word" ? withBorderBands(cells, rowIdx === rowCount - 1) : void 0;
+	const bandSpread = bands && (bands.topPt > 0 || bands.bottomPt > 0) ? bands : void 0;
+	if (bandSpread) cells.splice(0, cells.length, ...bandSpread.cells);
+	const borderBands = bandSpread ? { borderBands: {
+		topPt: bandSpread.topPt,
+		bottomPt: bandSpread.bottomPt
+	} } : {};
 	let heightPt = 0;
 	for (const c of cells) {
 		if (c.mergeRole === "start") continue;
@@ -4192,7 +4717,8 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 			columnXOffsets,
 			rowIdx,
 			rowCount,
-			...row.properties.cantSplit ? { cantSplit: true } : {}
+			...row.properties.cantSplit ? { cantSplit: true } : {},
+			...borderBands
 		};
 	} else if (row.properties.height && row.properties.heightRule === "atLeast") heightPt = Math.max(heightPt, row.properties.height);
 	return {
@@ -4201,7 +4727,42 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		columnXOffsets,
 		rowIdx,
 		rowCount,
-		...row.properties.cantSplit ? { cantSplit: true } : {}
+		...row.properties.cantSplit ? { cantSplit: true } : {},
+		...borderBands
+	};
+}
+/**
+* §17.4.38 — a table row as Word sets it: every horizontal border takes the
+* room it is wide, the edge above a row in that row and the table's bottom
+* edge in its last one, and the text stands clear of it. Measured in Word for
+* Mac, a row of 11pt Calibri with no cell margins stands 13.44pt apart from
+* the next with no borders, 13.92 under 0.5pt ones, 14.94 under 1.5pt and
+* 16.43 under 3pt; a one-row table between two paragraphs adds its top and
+* its bottom border whole, 3pt each at 3pt. LibreOffice does the same. The
+* room is the widest border along the edge, and it goes into the cells' top
+* and bottom padding, which is what places their text and sizes the row.
+*
+* @param cells   The row's laid-out cells, their borders resolved.
+* @param lastRow Whether the row is the table's last, whose bottom border is
+*                the table's own.
+* @returns The cells with the room in their padding, and the room taken.
+*/
+function withBorderBands(cells, lastRow) {
+	let topPt = 0;
+	let bottomPt = 0;
+	for (const c of cells) {
+		topPt = Math.max(topPt, borderWeight(c.borders.top));
+		if (lastRow) bottomPt = Math.max(bottomPt, borderWeight(c.borders.bottom));
+	}
+	return {
+		cells: cells.map((c) => ({
+			...c,
+			padTopPt: c.padTopPt + topPt,
+			padBottomPt: c.padBottomPt + bottomPt,
+			totalHeightPt: c.totalHeightPt + topPt + bottomPt
+		})),
+		topPt,
+		bottomPt
 	};
 }
 /**
@@ -4278,8 +4839,9 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	let contentHeightPt = 0;
 	let clipped = false;
 	let pendingGapPt = 0;
+	const collapse = collapsesSpacing(options);
 	const openParagraph = (spacingBeforePt) => {
-		const gap = pendingGapPt + spacingBeforePt;
+		const gap = collapse ? Math.max(pendingGapPt, spacingBeforePt) : pendingGapPt + spacingBeforePt;
 		pendingGapPt = 0;
 		if (gap <= 0) return;
 		lineGaps.set(lines.length, (lineGaps.get(lines.length) ?? 0) + gap);
@@ -4316,7 +4878,6 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 				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);
@@ -4492,7 +5053,7 @@ var PageAssembler = class PageAssembler {
 		this.ctx = sectionCtxs[0];
 		this.pageStartCtx = this.ctx;
 		this.pageNumber = this.ctx.properties.pageNumberStart ?? 1;
-		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+		this.cursorY = this.pageTopY();
 		this.colStartY = this.cursorY;
 		this.bandTopY = this.cursorY;
 	}
@@ -4509,6 +5070,56 @@ var PageAssembler = class PageAssembler {
 	current = [];
 	pendingPageBreak = false;
 	cursorY;
+	/** Whether paragraph spacing stacks as Word stacks it (see {@link SpacingStack}). */
+	collapseSpacing = false;
+	/**
+	* Where the last block's space after ended, on which page, and how much of
+	* it a paragraph right below may share — nothing once the cursor has moved
+	* on, to a new column or page or past a table.
+	*/
+	spacingMark = void 0;
+	/**
+	* Whether the next block opens a section on a page of its own (the
+	* document's first included), whose space before Word keeps at the top.
+	*/
+	sectionStart = true;
+	/**
+	* Whether a paragraph that breaks to a new page by its own
+	* `w:pageBreakBefore` keeps its space before there — Word 2010 and earlier
+	* (compatibilityMode below 15, or none) keep it; Word 2013 drops it.
+	*/
+	keepsBeforeAtOwnBreak = false;
+	/**
+	* §17.3.1.33 — the room to open above a block, where the spacing stacks as
+	* Word stacks it (see {@link SpacingStack}): the space after the block right
+	* above it shared, and nothing at all at the top of a page or column. Word
+	* for Mac drops a 24pt space before there whether the paragraph ran over
+	* onto the page, broke to it after a `w:br w:type="page"` or ran into the
+	* next column, in every mode; it keeps it for the first paragraph of the
+	* document and of a section, and — below mode 15 — for a paragraph that
+	* breaks to the page by its own `w:pageBreakBefore`.
+	*
+	* @param beforePt     A block's own space before.
+	* @param opensSection Whether the block is the first of a section on a page of its own.
+	* @param ownBreak     Whether the block broke to this page by its own `w:pageBreakBefore`.
+	* @returns The room to open above it.
+	*/
+	openBefore(beforePt, opensSection = false, ownBreak = false) {
+		const mark = this.spacingMark;
+		this.spacingMark = void 0;
+		if (!this.collapseSpacing) return beforePt;
+		if (!this.colHasContent()) return opensSection || ownBreak && this.keepsBeforeAtOwnBreak ? beforePt : 0;
+		if (!mark || mark.page !== this.current || mark.y !== this.cursorY) return beforePt;
+		return Math.max(0, beforePt - mark.shared);
+	}
+	/** @param sharedPt The space after the block just placed, as far as a paragraph below may share it. */
+	closeAfter(sharedPt) {
+		this.spacingMark = {
+			y: this.cursorY,
+			page: this.current,
+			shared: sharedPt
+		};
+	}
 	/**
 	* §17.6.4 multi-column flow: content fills column after column before the page
 	* flushes. `colStartLen` marks where the current column's items begin in
@@ -4557,6 +5168,16 @@ var PageAssembler = class PageAssembler {
 	* all and eleven controls wider than its page.
 	*/
 	pageHasContent = () => this.current.length > 0 || this.floatsBehind.length > 0 || this.floatsFront.length > 0;
+	/**
+	* §17.10 — the body's margins on the page being laid out: below the header
+	* band that page shows and above its footer band (see `bandMargins`).
+	*/
+	pageMargins = () => this.ctx.bandMargins?.[bandForPage(this.pageInSection, this.globalPageIdx, this.ctx.titlePg, this.ctx.evenAndOddHeaders)] ?? {
+		top: this.ctx.marginTop,
+		bottom: this.ctx.marginBottom
+	};
+	/** Where the body of the page being laid out begins, y-up. */
+	pageTopY = () => this.ctx.pageHeight - this.pageMargins().top;
 	/** 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) {
@@ -4652,7 +5273,7 @@ var PageAssembler = class PageAssembler {
 	*/
 	beginBalancedBand = (bandHeightPt) => {
 		const colCount = this.ctx.columns?.length ?? 1;
-		const room = this.cursorY - (this.ctx.marginBottom + this.noteReserve);
+		const room = this.cursorY - (this.pageMargins().bottom + this.noteReserve);
 		const share = colCount > 1 ? balancedColumnHeight(bandHeightPt, colCount, room) : 0;
 		this.balanceHeightPt = share;
 		this.balanceBottomY = share > 0 ? this.cursorY - share : void 0;
@@ -4737,7 +5358,7 @@ var PageAssembler = class PageAssembler {
 	* 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);
+	bottomLimit = () => Math.max(this.pageMargins().bottom + 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
@@ -4772,8 +5393,8 @@ var PageAssembler = class PageAssembler {
 			xOffset: 0
 		};
 		const cl = this.colLeft();
-		const leftRoom = e.x0 - FLOAT_TEXT_GAP - cl;
-		const rightRoom = cl + full - (e.x1 + FLOAT_TEXT_GAP);
+		const leftRoom = e.x0 - cl;
+		const rightRoom = cl + full - e.x1;
 		if (Math.max(leftRoom, rightRoom) < MIN_WRAP_WIDTH) return {
 			width: full,
 			xOffset: 0,
@@ -4806,19 +5427,22 @@ var PageAssembler = class PageAssembler {
 		if (this.exclusions.length === 0 || block.lines.length === 0) return void 0;
 		const h0 = computeLineHeight(block.lines[0], block.resolved);
 		if (h0 <= 0) return void 0;
+		const p = block.resolved;
+		const full = this.colWidth();
+		const hold = (width, xOffset, first) => Math.max(1, (xOffset > 0 ? width - p.indentRight : Math.min(width, full - p.indentRight)) - p.indentLeft - (first ? p.indentFirstLine : 0));
 		const widths = [];
 		let narrowed = false;
 		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());
+				widths.push(hold(full, 0, widths.length === 0));
 				y = g.blockedUntilYUp - h0;
 				if (y < this.bottomLimit()) break;
 				continue;
 			}
-			widths.push(g.width);
-			if (g.pair) widths.push(g.pair.width);
+			widths.push(hold(g.width, g.xOffset, widths.length === 0));
+			if (g.pair) widths.push(hold(g.pair.width, g.pair.xOffset, false));
 			if (g.width < this.colWidth()) narrowed = true;
 			else if (narrowed) break;
 			y -= h0;
@@ -4850,13 +5474,43 @@ var PageAssembler = class PageAssembler {
 		return out;
 	};
 	/**
+	* The first of a paragraph's lines, from `from` on, that the current column
+	* no longer holds: each line is counted with the notes it brings onto the
+	* page, the way the line loop places it, and an explicit column break ends
+	* the column where it stands.
+	*
+	* @param pb   The paragraph being placed.
+	* @param from The first line not yet placed.
+	* @returns The index of the first line that does not stay in this column;
+	*          `pb.lines.length` when every one does.
+	*/
+	firstLineOverflowing = (pb, from) => {
+		let y = this.cursorY;
+		let reserve = 0;
+		let notesOnPage = this.pageNotes.length > 0;
+		const counted = /* @__PURE__ */ new Set();
+		for (let i = from; i < pb.lines.length; i++) {
+			if (i > from && pb.columnBreakLines?.has(i)) return i;
+			const line = pb.lines[i];
+			const h = computeLineHeight(line, pb.resolved);
+			const notes = this.lineFootnotes(line).filter((x) => !counted.has(x.id));
+			const added = notes.reduce((sum, x) => sum + x.heightPt, 0) + (!notesOnPage && notes.length > 0 ? FOOTNOTE_SEPARATOR_HEIGHT : 0);
+			if (y - h < this.bottomLimit() + reserve + added) return i;
+			y -= h;
+			reserve += added;
+			if (notes.length > 0) notesOnPage = true;
+			for (const x of notes) counted.add(x.id);
+		}
+		return pb.lines.length;
+	};
+	/**
 	* The notes band for the flushing page: separator rule + each note's blocks
 	* stacked inside the reserved area. Tagged: each note is a Note→P element.
 	*/
 	renderNotesBand = () => {
 		if (this.pageNotes.length === 0) return [];
 		const out = [];
-		const top = this.ctx.marginBottom + this.noteReserve;
+		const top = this.pageMargins().bottom + this.noteReserve;
 		out.push({
 			type: "fill",
 			x: pt(this.ctx.marginLeft),
@@ -4872,7 +5526,7 @@ var PageAssembler = class PageAssembler {
 				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, this.ctx.contentWidth, structId));
+			out.push(...drawBlocksSequentially(note.blocks, this.ctx.marginLeft, cursor, this.ctx.pageHeight, this.ctx.contentWidth, structId, void 0, this.collapseSpacing));
 			cursor -= note.heightPt;
 		}
 		return out;
@@ -4895,35 +5549,38 @@ var PageAssembler = class PageAssembler {
 		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);
+		const pageText = pageNumberText(this.pageNumber, this.ctx.properties.pageNumberFormat);
 		if (header.renderDynamic) this.dynBands.push({
 			pageIdx: this.pages.length,
-			pageNumber: this.pageNumber,
+			pageText,
 			position: "header",
 			render: header.renderDynamic
 		});
 		if (footer.renderDynamic) this.dynBands.push({
 			pageIdx: this.pages.length,
-			pageNumber: this.pageNumber,
+			pageText,
 			position: "footer",
 			render: footer.renderDynamic
 		});
+		const sheet = this.ctx.sheet;
+		const onSheet = (items) => sheet ? items.map((item) => turnOntoSheet(item, sheet.width)) : items;
 		this.pages.push({
 			commands: [
-				...this.pageBackgroundItems(),
-				...this.pageBorderItems(),
-				...this.columnSeparatorItems(),
+				...onSheet(this.pageBackgroundItems()),
+				...onSheet(this.pageBorderItems()),
+				...onSheet(this.columnSeparatorItems()),
 				...header.commands,
-				...PageAssembler.byZ(this.floatsBehind).map((item) => ({
+				...onSheet(PageAssembler.byZ(this.floatsBehind).map((item) => ({
 					...item,
 					behind: true
-				})),
-				...this.current,
-				...PageAssembler.byZ(this.floatsFront),
-				...this.renderNotesBand(),
+				}))),
+				...onSheet(this.current),
+				...onSheet(PageAssembler.byZ(this.floatsFront)),
+				...onSheet(this.renderNotesBand()),
 				...footer.commands
 			],
-			width: pt(this.ctx.pageWidth),
-			height: pt(this.ctx.pageHeight)
+			width: pt(sheet?.width ?? this.ctx.pageWidth),
+			height: pt(sheet?.height ?? this.ctx.pageHeight)
 		});
 		this.current = [];
 		this.floatsBehind = [];
@@ -4937,7 +5594,7 @@ var PageAssembler = class PageAssembler {
 		this.globalPageIdx++;
 		this.pageNumber++;
 		if ((this.ctx.properties.lineNumbering?.restart ?? "newPage") === "newPage") this.lineNumber = 0;
-		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+		this.cursorY = this.pageTopY();
 		this.colStartY = this.cursorY;
 		this.bandTopY = this.cursorY;
 		this.balanceBottomY = void 0;
@@ -5126,32 +5783,80 @@ var PageAssembler = class PageAssembler {
 		this.noteReserve = 0;
 		this.colIdx = 0;
 		this.colStartLen = 0;
-		this.cursorY = this.ctx.pageHeight - this.ctx.marginTop;
+		this.cursorY = this.pageTopY();
 		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, backgroundImage) {
+/**
+* §17.3.1.14/15 — the height a paragraph needs in one column: all of its lines
+* where it keeps them together, and where it keeps with the next, the whole of
+* every paragraph in the chain it heads and as much of the block after as has
+* to stand beside it — a paragraph's first line, or its first two (all of a
+* short one) where its own widow control would not leave one alone; a table's
+* first row; a picture. The space between them counts, the chain's own space
+* before does not. A chain is decided at its head: one that follows a
+* paragraph kept with it moved with that paragraph or not at all, and asks
+* only whether its own lines stay together.
+*
+* @param blocks The section's blocks.
+* @param from   The paragraph asked about.
+* @param end    The section's end: nothing is kept with what lies past it.
+* @returns The height, or undefined where the paragraph asks for neither.
+*/
+function keptTogetherHeight(blocks, from, end, collapse = false) {
+	const first = blocks[from];
+	if (first?.kind !== "paragraph") return void 0;
+	const before = blocks[from - 1];
+	const inChain = before?.kind === "paragraph" && before.resolved.keepNext && !before.pageBreakAfter && !first.resolved.pageBreakBefore && !first.pageBreakBefore;
+	const keepsNext = first.resolved.keepNext && !inChain;
+	if (!keepsNext && !first.resolved.keepLines) return void 0;
+	let height = first.heightPt;
+	let current = first;
+	for (let i = from + 1; keepsNext && current.resolved.keepNext && !current.pageBreakAfter; i++) {
+		const next = i < end ? blocks[i] : void 0;
+		if (next?.kind === "paragraph") {
+			if (next.resolved.pageBreakBefore || next.pageBreakBefore) break;
+			height += collapse ? Math.max(current.spacingAfterPt, next.spacingBeforePt) : current.spacingAfterPt + next.spacingBeforePt;
+			if (next.resolved.keepNext) {
+				height += next.heightPt;
+				current = next;
+				continue;
+			}
+			const count = next.lines.length;
+			const stays = next.resolved.keepLines ? count : next.resolved.widowControl ? count <= 3 ? count : 2 : 1;
+			for (const line of next.lines.slice(0, stays)) height += computeLineHeight(line, next.resolved);
+		} else if (next?.kind === "table" && !next.float) height += current.spacingAfterPt + (next.rows[0]?.heightPt ?? 0);
+		else if (next?.kind === "image" && !next.float) height += current.spacingAfterPt + next.heightPt;
+		break;
+	}
+	return height;
+}
+function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", notes, bookmarkPositions, reflowParagraph, backgroundImage, typesetByWord = false, compatibilityMode) {
 	if (sectionCtxs.length === 0) return [];
 	const asm = new PageAssembler(sectionCtxs, builder, notes, bookmarkPositions, backgroundImage);
+	asm.collapseSpacing = typesetByWord;
+	asm.keepsBeforeAtOwnBreak = (compatibilityMode ?? 0) < 15;
 	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;
+		if (next.sheet === void 0 !== (here.sheet === void 0)) return;
 		const end = Math.min(here.endIndex, blocks.length);
-		asm.beginBalancedBand(blocksHeight(blocks.slice(fromBlock, end)));
+		asm.beginBalancedBand(blocksHeight(blocks.slice(fromBlock, end), typesetByWord));
 	};
 	balanceIfEndsContinuous(0);
+	let brokenFor;
 	for (let blockIdx = 0; blockIdx < blocks.length; blockIdx++) {
 		while (asm.secIdx < sectionCtxs.length - 1 && blockIdx >= asm.ctx.endIndex) {
 			const next = sectionCtxs[asm.secIdx + 1];
-			if (next.continuous && next.pageWidth === asm.ctx.pageWidth && next.pageHeight === asm.ctx.pageHeight) {
+			if (next.continuous && next.pageWidth === asm.ctx.pageWidth && next.pageHeight === asm.ctx.pageHeight && next.sheet === void 0 === (asm.ctx.sheet === void 0)) {
 				const end = Math.min(next.endIndex, blocks.length);
-				asm.startBandSection(next, blocksHeight(blocks.slice(blockIdx, end)));
+				asm.startBandSection(next, blocksHeight(blocks.slice(blockIdx, end), typesetByWord));
 				continue;
 			}
 			if (asm.pageHasContent() || asm.pageInSection === 0) asm.flushPage(true);
@@ -5160,7 +5865,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			const wants = opening?.sectionStart;
 			if (wants === "oddPage" || wants === "evenPage") {
 				if ((opening?.pageNumberStart ?? asm.pageNumber) % 2 === 1 !== (wants === "oddPage")) {
-					asm.cursorY = asm.ctx.pageHeight - asm.ctx.marginTop;
+					asm.cursorY = asm.pageTopY();
 					asm.flushPage(true);
 				}
 			}
@@ -5168,18 +5873,43 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			asm.ctx = sectionCtxs[asm.secIdx];
 			asm.restartPageNumbers(asm.ctx);
 			asm.pageInSection = 0;
-			asm.cursorY = asm.ctx.pageHeight - asm.ctx.marginTop;
+			asm.cursorY = asm.pageTopY();
+			asm.sectionStart = true;
 			balanceIfEndsContinuous(blockIdx);
 		}
 		const block = blocks[blockIdx];
+		const opensSection = asm.sectionStart;
+		const anchored = "float" in block && isOutOfFlowFloat(block.float);
+		if (!anchored) asm.sectionStart = false;
 		if (asm.pendingPageBreak) {
 			asm.pendingPageBreak = false;
 			asm.flushPage(true);
 		}
+		if (typesetByWord && anchored && asm.pageHasContent() && brokenFor === void 0) {
+			let owner = blockIdx + 1;
+			while (owner < blocks.length) {
+				const b = blocks[owner];
+				if (!("float" in b && isOutOfFlowFloat(b.float))) break;
+				owner++;
+			}
+			const para = blocks[owner];
+			if (para?.kind === "paragraph" && para.resolved.pageBreakBefore) {
+				asm.flushPage();
+				brokenFor = owner;
+			}
+		}
 		if (builder && !(block.kind === "paragraph" && block.list)) asm.listStack.length = 0;
 		if (block.kind === "paragraph") {
-			if ((block.resolved.pageBreakBefore || block.pageBreakBefore) && asm.pageHasContent()) asm.flushPage();
-			asm.cursorY -= block.spacingBeforePt;
+			const brokeAhead = brokenFor === blockIdx;
+			brokenFor = void 0;
+			const ownBreak = block.resolved.pageBreakBefore && (brokeAhead || asm.pageHasContent());
+			if (!brokeAhead && (block.resolved.pageBreakBefore || block.pageBreakBefore) && asm.pageHasContent()) asm.flushPage();
+			const columnInUse = asm.colHasContent();
+			const opensDocument = opensSection && asm.pages.length === 0 && asm.secIdx === 0;
+			const beforePt = asm.collapseSpacing && opensDocument && block.resolved.spacingBeforeAuto !== void 0 ? 0 : block.spacingBeforePt;
+			asm.cursorY -= asm.openBefore(beforePt, opensSection, ownBreak);
+			const kept = keptTogetherHeight(blocks, blockIdx, asm.ctx.endIndex, typesetByWord);
+			if (kept !== void 0 && columnInUse && asm.exclusions.length === 0 && kept > asm.cursorY - asm.bottomLimit()) asm.advanceColumn();
 			let pb = block;
 			const colW = asm.colWidth();
 			if (reflowParagraph && pb.source && Math.abs(colW - asm.builtWidth()) > .5) pb = reflowParagraph(pb.source, colW);
@@ -5187,8 +5917,26 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				const widths = asm.lineWidthsFor(pb, asm.cursorY);
 				if (widths) pb = reflowParagraph(pb.source, colW, widths);
 			}
-			const borderTopY = asm.cursorY;
-			const borderPage = asm.pages.length;
+			let borderTopY = asm.cursorY;
+			let borderPage = asm.pages.length;
+			const keptColumnEnd = (from) => {
+				const n = pb.lines.length;
+				if (!pb.resolved.widowControl || n < 2 || asm.exclusions.length > 0) return void 0;
+				let end = asm.firstLineOverflowing(pb, from);
+				if (end >= n) return void 0;
+				if (n - end === 1) end--;
+				if (from === 0 && end === 1) end = 0;
+				if (end <= from) return asm.colHasContent() ? from : from + 1;
+				return end;
+			};
+			const advanceBefore = (lineIdx) => {
+				asm.advanceColumn();
+				if (lineIdx === 0) {
+					borderTopY = asm.cursorY;
+					borderPage = asm.pages.length;
+				}
+			};
+			let columnEnd = keptColumnEnd(0);
 			let structId;
 			let markerLblId;
 			const firstLine = pb.lines[0];
@@ -5205,13 +5953,21 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			let firstLineOfBlock = true;
 			let pairPending;
 			for (const [lineIdx, line] of pb.lines.entries()) {
-				if (pb.columnBreakLines?.has(lineIdx) && asm.colHasContent()) asm.advanceColumn();
+				if (pb.columnBreakLines?.has(lineIdx) && asm.colHasContent()) {
+					advanceBefore(lineIdx);
+					columnEnd = keptColumnEnd(lineIdx);
+				}
+				if (lineIdx === columnEnd && asm.colHasContent()) {
+					advanceBefore(lineIdx);
+					columnEnd = keptColumnEnd(lineIdx);
+				}
 				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);
 				if (asm.cursorY - h < asm.bottomLimit() + addedReserve(newNotes) && asm.colHasContent()) {
-					asm.advanceColumn();
+					advanceBefore(lineIdx);
 					newNotes = asm.lineFootnotes(line);
+					columnEnd = keptColumnEnd(lineIdx);
 				}
 				if (newNotes.length > 0) {
 					asm.noteReserve += addedReserve(newNotes);
@@ -5291,6 +6047,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			}
 			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;
+			asm.closeAfter(pb.spacingAfterPt);
 			if (pb.pageBreakAfter) asm.pendingPageBreak = true;
 		} else if (block.kind === "image") {
 			const figId = builder ? createFigure(builder, block.altText, "Image") : void 0;
@@ -5321,12 +6078,13 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				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;
+				asm.cursorY -= asm.openBefore(block.spacingBeforePt, opensSection);
 				if (asm.cursorY - block.heightPt < asm.bottomLimit() && asm.colHasContent()) asm.advanceColumn();
 				asm.cursorY -= block.heightPt;
 				const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, asm.colWidth());
 				emitImageAt(asm.colLeft() + offset, asm.cursorY + block.heightPt, asm.current);
 				asm.cursorY -= block.spacingAfterPt;
+				asm.closeAfter(sharedAfter(block));
 			}
 		} else if (block.kind === "shape") {
 			const figId = builder ? createFigure(builder, block.altText, "Shape") : void 0;
@@ -5337,12 +6095,13 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				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;
+				asm.cursorY -= asm.openBefore(block.spacingBeforePt, opensSection);
 				if (asm.cursorY - block.heightPt < asm.bottomLimit() && asm.colHasContent()) asm.advanceColumn();
 				asm.cursorY -= block.heightPt;
 				const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, asm.colWidth());
 				emitShapeAt(asm.colLeft() + offset, asm.cursorY, asm.current);
 				asm.cursorY -= block.spacingAfterPt;
+				asm.closeAfter(block.spacingAfterPt);
 			}
 		} else if (block.kind === "chart") {
 			const figId = builder ? createFigure(builder, block.altText, block.figureRole ?? "Chart") : void 0;
@@ -5355,12 +6114,13 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				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;
+				asm.cursorY -= asm.openBefore(block.spacingBeforePt, opensSection);
 				if (asm.cursorY - block.heightPt < asm.bottomLimit() && asm.colHasContent()) asm.advanceColumn();
 				asm.cursorY -= block.heightPt;
 				const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, asm.colWidth());
 				emitChartAt(asm.colLeft() + offset, asm.cursorY, asm.current);
 				asm.cursorY -= block.spacingAfterPt;
+				asm.closeAfter(sharedAfter(block));
 			}
 		} 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);
@@ -5432,7 +6192,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 	asm.flushPage();
 	if (asm.pages.length === 0) asm.flushPage(true);
 	for (const d of asm.dynBands) {
-		const cmds = d.render(d.pageNumber, asm.pages.length);
+		const cmds = d.render(d.pageText, asm.pages.length);
 		const page = asm.pages[d.pageIdx];
 		if (d.position === "header") page.commands.unshift(...cmds);
 		else page.commands.push(...cmds);
@@ -5623,7 +6383,7 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 				});
 			}
 		}
-		emitCellBorders(out, cell, cellX, rowBottom, row.heightPt, pageHeight, row.rowIdx, row.rowCount, colCount);
+		emitCellBorders(out, cell, cellX, rowBottom, row.heightPt, pageHeight, row.rowIdx, row.rowCount, colCount, row.borderBands);
 		const diagDown = cell.borders.diagonalDown;
 		const diagUp = cell.borders.diagonalUp;
 		if ((diagDown || diagUp) && cell.mergeRole !== "middle" && cell.mergeRole !== "end") {
@@ -5840,17 +6600,19 @@ function splitRowIntoChunks(row, capacity, restCapacity = capacity) {
 	return out.length > 0 ? out : [row];
 }
 var FILL_SEAM_PT = .07;
-function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx, rowCount, colCount) {
+function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx, rowCount, colCount, bands) {
 	const pushSide = (side, border) => {
 		if (!border || border.style === "none") return;
 		const sz = border.width ?? DEFAULT_BORDER_SIZE_EIGHTH * EIGHTH_PT;
+		const lowered = side === "top" ? (bands?.topPt ?? 0) / 2 : 0;
+		const raised = side === "bottom" ? (bands?.bottomPt ?? 0) / 2 : 0;
 		out.push({
 			type: "border",
 			side,
 			x: pt(cellX),
-			y: pt(pageHeight - cellY - rowHeight),
+			y: pt(pageHeight - cellY - rowHeight + lowered),
 			width: pt(cell.paintWidthPt ?? cell.widthPt),
-			height: pt(rowHeight),
+			height: pt(rowHeight - lowered - raised),
 			borderSizePt: sz,
 			borderColorHex: border.colorHex ?? "000000",
 			...border.style !== "single" ? { borderStyle: border.style } : {}