reamkit 1.0.0 → 1.0.1

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

@@ -0,0 +1,1729 @@
+import { resolveFamilyKey } from "../core/fonts/remote-fonts.js";
+import { shapeText } from "../core/font/opentype-layout.js";
+import { createFontMeasure } from "../core/font/measure.js";
+import { halfPtToPt, pt } from "../core/ir/units.js";
+import { ResourceStore } from "../core/ir/resources.js";
+import { prepareImage } from "../core/images.js";
+import { segmentLevels } from "../core/bidi/segments.js";
+import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
+import { FORCED_BREAK, breakLines } from "../core/line-breaker/knuth-plass.js";
+import { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
+import { DEFAULT_RESOLVED_PARAGRAPH, DEFAULT_RESOLVED_RUN } from "../core/style-cascade/types.js";
+import { resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+import { PathBuilder } from "../core/vector.js";
+import { arcPoint, arcToBeziers } from "./arc-to-bezier.js";
+import { buildChartScene } from "./chart-geometry.js";
+import { layoutMath, mathGlyphSegments, variantStyle } from "./math-layout.js";
+import { customPaths, presetPaths, rectPath } from "./preset-geometry.js";
+import { StructTreeBuilder } from "../pdf/struct-tree.js";
+//#region src/layout/styled-layout.ts
+function parsePdfAProfile(pdfA) {
+	const part = Number(pdfA.charAt(6));
+	const level = pdfA.charAt(7);
+	return {
+		part,
+		level,
+		tagged: level === "a",
+		version: part === 1 ? "1.4" : "1.7"
+	};
+}
+var TWIP_TO_PT = 1 / 20;
+var EIGHTH_PT = 1 / 8;
+var DEFAULT_CELL_PADDING_TWIPS = 108;
+var DEFAULT_BORDER_SIZE_EIGHTH = 4;
+function layoutStyledDocument(body, options) {
+	const sectionList = resolveSectionList(body, options);
+	const numberedBody = applyNumbering(body, options.numbering);
+	const numberedHeadersFooters = applyNumberingToHeadersFooters(options.headersFooters, options.numbering);
+	const pdfaProfile = options.pdfA ? parsePdfAProfile(options.pdfA) : void 0;
+	const tagged = options.tagged === 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));
+	let sectionIdx = 0;
+	return {
+		pages: paginateSections(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.contentWidth, ctx.pageContentHeight);
+		}), sectionCtxs, structBuilder, options.language ?? "en-US"),
+		resources: options.resources ?? new ResourceStore(),
+		fontResources,
+		imageResources,
+		pdf: {
+			structBuilder,
+			sectionCtxs,
+			pdfaProfile,
+			tagged
+		}
+	};
+}
+function resolvePageDimensions(options, section) {
+	const sectionPageWidth = section?.pageSize !== void 0 ? section.pageSize.width : void 0;
+	const sectionPageHeight = section?.pageSize !== void 0 ? section.pageSize.height : void 0;
+	const sectionLeft = section?.margins?.left !== void 0 ? section.margins.left : void 0;
+	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 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,
+		marginRight: options.marginRight ?? sectionRight ?? 72,
+		marginTop: options.marginTop ?? sectionTop ?? 72,
+		marginBottom: options.marginBottom ?? sectionBottom ?? 72,
+		headerOffsetPt,
+		footerOffsetPt
+	};
+}
+function resolveSectionList(body, options) {
+	if (options.sections && options.sections.length > 0) return options.sections;
+	if (options.section) return [{
+		properties: options.section,
+		endIndex: body.length
+	}];
+	return [{
+		properties: {
+			headers: [],
+			footers: []
+		},
+		endIndex: body.length
+	}];
+}
+function buildSectionContext(section, options, headersFooters, fontResources) {
+	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);
+	return {
+		endIndex: section.endIndex,
+		properties: section.properties,
+		pageWidth: dims.pageWidth,
+		pageHeight: dims.pageHeight,
+		marginLeft: dims.marginLeft,
+		marginTop: dims.marginTop,
+		marginBottom: dims.marginBottom,
+		contentWidth,
+		pageContentHeight: dims.pageHeight - dims.marginTop - dims.marginBottom,
+		headerSet,
+		footerSet,
+		titlePg: section.properties.titlePg === true,
+		evenAndOddHeaders: section.properties.evenAndOddHeaders === true
+	};
+}
+function refByType(refs, type) {
+	if (!refs || refs.length === 0) return void 0;
+	return refs.find((r) => r.type === type);
+}
+function markPagination(cmds) {
+	return cmds.map((c) => ({
+		...c,
+		artifact: "pagination"
+	}));
+}
+function layoutHeaderSet(section, headersFooters, options, fontResources, contentWidth, marginLeft, pageHeight, headerOffsetPt) {
+	const band = (type) => {
+		const ref = refByType(section.headers, type);
+		if (!ref) return [];
+		const content = headersFooters.get(ref.relationshipId);
+		if (!content) return [];
+		return markPagination(drawBlocksSequentially(laidOutBlocksFor(content, options, fontResources, contentWidth), marginLeft, pageHeight - headerOffsetPt, pageHeight));
+	};
+	return {
+		default: band("default"),
+		first: band("first"),
+		even: band("even")
+	};
+}
+function layoutFooterSet(section, headersFooters, options, fontResources, contentWidth, marginLeft, pageHeight, footerOffsetPt) {
+	const band = (type) => {
+		const ref = refByType(section.footers, type);
+		if (!ref) return [];
+		const content = headersFooters.get(ref.relationshipId);
+		if (!content) return [];
+		const blocks = laidOutBlocksFor(content, 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));
+	};
+	return {
+		default: band("default"),
+		first: band("first"),
+		even: band("even")
+	};
+}
+function pickBand(set, band) {
+	if (band === "first") return set.first.length > 0 ? set.first : set.default;
+	if (band === "even") return set.even.length > 0 ? set.even : set.default;
+	return set.default;
+}
+function bandForPage(pageInSection, globalPageIdx, titlePg, evenAndOddHeaders) {
+	if (pageInSection === 0 && titlePg) return "first";
+	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));
+}
+function layoutBodyElement(el, options, fontResources, imageResources, contentWidth, maxHeight) {
+	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 === "chart") return layoutChartBlock(el.chart, options, fontResources, contentWidth, maxHeight);
+	return layoutShapeBlock(el.shape, options, fontResources, imageResources, contentWidth, maxHeight);
+}
+var EMU_PER_PT = 12700;
+function layoutImageBlock(image, imageResources, contentWidth) {
+	let widthPt = image.width;
+	let heightPt = image.height;
+	if (widthPt > contentWidth) {
+		const scale = contentWidth / widthPt;
+		widthPt = contentWidth;
+		heightPt = heightPt * scale;
+	}
+	const res = image.resource ? imageResources?.get(image.resource) : void 0;
+	const resolvedAlignment = image.paragraphProperties.alignment ?? "left";
+	return {
+		kind: "image",
+		widthPt,
+		heightPt,
+		resolvedAlignment,
+		resourceName: res?.resourceName ?? "",
+		spacingBeforePt: image.paragraphProperties.spacingBefore ?? 0,
+		spacingAfterPt: image.paragraphProperties.spacingAfter ?? 0,
+		...image.altText ? { altText: image.altText } : {}
+	};
+}
+var DEFAULT_LINE_WIDTH_EMU = 9525;
+var DEFAULT_INSET_LR_EMU = 91440;
+var DEFAULT_INSET_TB_EMU = 45720;
+function layoutShapeBlock(shape, options, fontResources, imageResources, contentWidth, maxHeight) {
+	let widthPt = shape.width;
+	let heightPt = shape.height;
+	if (widthPt > contentWidth && widthPt > 0) {
+		const scale = contentWidth / widthPt;
+		widthPt = contentWidth;
+		heightPt *= scale;
+	}
+	if (maxHeight !== void 0 && heightPt > maxHeight && heightPt > 0) {
+		const scale = maxHeight / heightPt;
+		widthPt *= scale;
+		heightPt = maxHeight;
+	}
+	const paths = buildShapePaths(shape.geometry, widthPt, heightPt);
+	const fillColorHex = shape.fill.kind === "solid" ? shape.fill.colorHex : void 0;
+	const stroke = buildStroke(shape.line);
+	const t = shape.transform;
+	const pp = shape.paragraphProperties;
+	const text = shape.text;
+	const insetLeftPt = text?.insetLeft ?? DEFAULT_INSET_LR_EMU / EMU_PER_PT;
+	const insetRightPt = text?.insetRight ?? DEFAULT_INSET_LR_EMU / EMU_PER_PT;
+	const insetTopPt = text?.insetTop ?? DEFAULT_INSET_TB_EMU / EMU_PER_PT;
+	const insetBottomPt = text?.insetBottom ?? DEFAULT_INSET_TB_EMU / EMU_PER_PT;
+	const textLines = [];
+	let textHeightPt = 0;
+	if (text && text.content.length > 0) {
+		const innerWidth = Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		for (const el of text.content) {
+			if (el.kind !== "paragraph") continue;
+			const blk = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, innerWidth);
+			for (const line of blk.lines) {
+				textLines.push(line);
+				textHeightPt += computeLineHeight(line, blk.resolved);
+			}
+			textHeightPt += blk.spacingAfterPt;
+		}
+	}
+	return {
+		kind: "shape",
+		widthPt,
+		heightPt,
+		paths,
+		...fillColorHex ? { fillColorHex } : {},
+		...stroke ? { stroke } : {},
+		rotation60k: t?.rotation60k ?? 0,
+		flipH: t?.flipH ?? false,
+		flipV: t?.flipV ?? false,
+		resolvedAlignment: pp.alignment ?? "left",
+		spacingBeforePt: pp.spacingBefore ?? 0,
+		spacingAfterPt: pp.spacingAfter ?? 0,
+		textLines,
+		textHeightPt,
+		insetLeftPt,
+		insetRightPt,
+		insetTopPt,
+		insetBottomPt,
+		anchor: text?.anchor ?? "t",
+		...shape.altText ? { altText: shape.altText } : {}
+	};
+}
+function buildShapePaths(geometry, widthPt, heightPt) {
+	if (geometry.kind === "preset") return presetPaths(geometry.preset ?? "rect", widthPt, heightPt, geometry.adjust ?? /* @__PURE__ */ new Map()) ?? [rectPath(widthPt, heightPt)];
+	if (geometry.custom) return customPaths(geometry.custom, widthPt, heightPt);
+	return [rectPath(widthPt, heightPt)];
+}
+function buildStroke(line) {
+	if (!line || line.fill === "none") return void 0;
+	const widthPt = line.width ?? DEFAULT_LINE_WIDTH_EMU / EMU_PER_PT;
+	const dash = line.dash && line.dash !== "solid" ? dashPattern(line.dash, widthPt) : void 0;
+	const cap = line.cap === "flat" ? "butt" : line.cap;
+	return {
+		colorHex: line.colorHex ?? "000000",
+		widthPt,
+		...dash ? { dash } : {},
+		...cap ? { cap } : {}
+	};
+}
+function dashPattern(dash, w) {
+	const u = Math.max(w, .1);
+	switch (dash) {
+		case "solid": return;
+		case "dot": return [u, 2 * u];
+		case "dash": return [4 * u, 3 * u];
+		case "dashDot": return [
+			4 * u,
+			3 * u,
+			u,
+			3 * u
+		];
+		case "lgDash": return [8 * u, 3 * u];
+		case "lgDashDot": return [
+			8 * u,
+			3 * u,
+			u,
+			3 * u
+		];
+		case "sysDash": return [3 * u, u];
+		case "sysDot": return [u, u];
+	}
+}
+function buildShapeTransform(pageX, pageY, widthPt, heightPt, rotation60k, flipH, flipV) {
+	const theta = -rotation60k / 6e4 * (Math.PI / 180);
+	const sx = flipH ? -1 : 1;
+	const sy = flipV ? -1 : 1;
+	const cos = Math.cos(theta);
+	const sin = Math.sin(theta);
+	const a = sx * cos;
+	const b = sx * sin;
+	const c = -sy * sin;
+	const d = sy * cos;
+	const cxL = widthPt / 2;
+	const cyL = heightPt / 2;
+	const centerX = pageX + cxL;
+	const centerY = pageY + cyL;
+	return [
+		a,
+		b,
+		c,
+		d,
+		centerX - (a * cxL + c * cyL),
+		centerY - (b * cxL + d * cyL)
+	];
+}
+function flipTransform(m, pageHeight) {
+	return [
+		m[0],
+		-m[1],
+		m[2],
+		-m[3],
+		m[4],
+		pageHeight - m[5]
+	];
+}
+function layoutChartBlock(block, options, fontResources, contentWidth, maxHeight) {
+	let widthPt = block.width;
+	let heightPt = block.height;
+	if (widthPt > contentWidth && widthPt > 0) {
+		const scale = contentWidth / widthPt;
+		widthPt = contentWidth;
+		heightPt *= scale;
+	}
+	if (maxHeight !== void 0 && heightPt > maxHeight && heightPt > 0) {
+		const scale = maxHeight / heightPt;
+		widthPt *= scale;
+		heightPt = maxHeight;
+	}
+	const chart = options.charts?.get(block.chartRelId);
+	const { variant } = options.registry.resolveByStyle(false, false);
+	const font = fontResources.get(variant);
+	const layout = chart && font ? buildChartLayout(chart, widthPt, heightPt, font) : {
+		shapes: [],
+		texts: []
+	};
+	const pp = block.paragraphProperties;
+	const altText = block.altText ?? chart?.title;
+	return {
+		kind: "chart",
+		widthPt,
+		heightPt,
+		layout,
+		resolvedAlignment: pp.alignment ?? "left",
+		spacingBeforePt: pp.spacingBefore ?? 0,
+		spacingAfterPt: pp.spacingAfter ?? 0,
+		...altText ? { altText } : {}
+	};
+}
+function buildChartLayout(chart, widthPt, heightPt, font) {
+	const measure = (text, sizePt) => font.measure.textWidthPt(text, sizePt);
+	const scene = buildChartScene(chart, widthPt, heightPt, measure);
+	if (!scene) return {
+		shapes: [{
+			paths: [rectPath(widthPt, heightPt)],
+			stroke: {
+				colorHex: "D9D9D9",
+				widthPt: 1
+			}
+		}],
+		texts: []
+	};
+	const shapes = [];
+	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));
+	for (const w of scene.wedges) shapes.push(wedgePrim(w));
+	return {
+		shapes,
+		texts: scene.labels.map((l) => labelPrim(l, font))
+	};
+}
+function rectAtPath(x, y, w, h) {
+	return new PathBuilder().moveTo(x, y).lineTo(x + w, y).lineTo(x + w, y + h).lineTo(x, y + h).close().build();
+}
+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
+		} } : {}
+	};
+}
+function polylinePrim(p) {
+	const b = new PathBuilder();
+	p.points.forEach(([x, y], i) => i === 0 ? b.moveTo(x, y) : b.lineTo(x, y));
+	return {
+		paths: [b.build()],
+		stroke: {
+			colorHex: p.strokeHex,
+			widthPt: p.widthPt
+		}
+	};
+}
+function polygonPrim(p) {
+	const b = new PathBuilder();
+	p.points.forEach(([x, y], i) => i === 0 ? b.moveTo(x, y) : b.lineTo(x, y));
+	b.close();
+	return {
+		paths: [b.build()],
+		fillColorHex: p.fillHex,
+		...p.strokeHex ? { stroke: {
+			colorHex: p.strokeHex,
+			widthPt: p.widthPt ?? 1
+		} } : {}
+	};
+}
+function wedgePrim(w) {
+	const start = arcPoint(w.cx, w.cy, w.r, w.r, w.startRad);
+	return {
+		paths: [new PathBuilder().moveTo(w.cx, w.cy).lineTo(start[0], start[1]).append(arcToBeziers(w.cx, w.cy, w.r, w.r, w.startRad, w.sweepRad)).close().build()],
+		fillColorHex: w.fillHex,
+		...w.strokeHex ? { stroke: {
+			colorHex: w.strokeHex,
+			widthPt: 1
+		} } : {}
+	};
+}
+function labelPrim(l, font) {
+	const line = makeChartLabelLine(l.text, font, l.sizePt, l.colorHex);
+	const w = line.contentWidthPt;
+	return {
+		line,
+		x: l.align === "center" ? l.x - w / 2 : l.align === "right" ? l.x - w : l.x,
+		y: l.y
+	};
+}
+function makeChartLabelLine(text, font, sizePt, colorHex) {
+	const widthPt = font.measure.textWidthPt(text, sizePt);
+	return {
+		tokens: [{
+			kind: "text",
+			text,
+			isSpace: false,
+			resolvedRun: {
+				...DEFAULT_RESOLVED_RUN,
+				colorHex,
+				fontSizePt: halfPtToPt(Math.round(sizePt * 2))
+			},
+			font,
+			fontSizePt: sizePt,
+			widthPt,
+			bidiLevel: 0
+		}],
+		contentWidthPt: widthPt,
+		maxFontSizePt: sizePt,
+		availableWidthPt: widthPt,
+		firstLine: true,
+		resolved: DEFAULT_RESOLVED_PARAGRAPH,
+		isLastInParagraph: true
+	};
+}
+function collectImageResources(body, headersFooters, options) {
+	const out = /* @__PURE__ */ new Map();
+	if (!options.resources || options.resources.size === 0) return out;
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (elements) => {
+		for (const el of elements) if (el.kind === "image") {
+			if (el.image.resource) seen.add(el.image.resource);
+		} else if (el.kind === "paragraph") {
+			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);
+		}
+	};
+	visit(body);
+	for (const hf of headersFooters.values()) visit(hf);
+	const flattenAlpha = options.pdfA ? parsePdfAProfile(options.pdfA).part === 1 : false;
+	let counter = 0;
+	for (const resourceId of seen) {
+		const bytes = options.resources.get(resourceId);
+		if (!bytes) continue;
+		let prepared;
+		try {
+			prepared = prepareImage(bytes, { flattenAlpha });
+		} catch {
+			continue;
+		}
+		counter++;
+		out.set(resourceId, {
+			resourceName: `Im${counter}`,
+			prepared
+		});
+	}
+	return out;
+}
+function drawBlocksSequentially(blocks, startX, startY, pageHeight) {
+	const out = [];
+	let cursorY = startY;
+	for (const block of blocks) {
+		if (block.kind !== "paragraph") continue;
+		cursorY -= block.spacingBeforePt;
+		for (const line of block.lines) {
+			const h = computeLineHeight(line, block.resolved);
+			cursorY -= h;
+			const indentLeft = block.resolved.indentLeft + (line.firstLine ? block.resolved.indentFirstLine : 0);
+			const offset = alignmentOffset(block.resolved.alignment, line.contentWidthPt, line.availableWidthPt);
+			out.push({
+				type: "line",
+				line,
+				originX: pt(startX + indentLeft + offset),
+				baselineY: pt(pageHeight - (cursorY + lineDescent(line)))
+			});
+		}
+		cursorY -= block.spacingAfterPt;
+	}
+	return out;
+}
+function runFontKeyAndParsed(options, ascii, bold, italic) {
+	if (ascii && options.embeddedFonts) {
+		const name = ascii.trim().toLowerCase();
+		const emb = options.embeddedFonts.get(name);
+		if (emb) {
+			const { variant, parsed } = emb.resolveByStyle(bold, italic);
+			return {
+				fontKey: `embed:${name}:${variant}`,
+				parsed
+			};
+		}
+	}
+	const byFamily = options.registriesByFamily;
+	if (byFamily && byFamily.size > 0) {
+		let key = resolveFamilyKey(ascii);
+		let reg = byFamily.get(key);
+		if (!reg) {
+			key = byFamily.keys().next().value;
+			reg = byFamily.get(key);
+		}
+		const { variant, parsed } = reg.resolveByStyle(bold, italic);
+		return {
+			fontKey: `${key}:${variant}`,
+			parsed
+		};
+	}
+	const { variant, parsed } = options.registry.resolveByStyle(bold, italic);
+	return {
+		fontKey: variant,
+		parsed
+	};
+}
+function lookupFont(resources, fontKey) {
+	return resources.get(fontKey) ?? resources.values().next().value;
+}
+function collectFontResources(body, headersFooters, options) {
+	const used = /* @__PURE__ */ new Map();
+	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);
+		let bucket = used.get(fontKey);
+		if (!bucket) {
+			bucket = {
+				parsed,
+				gids: /* @__PURE__ */ new Set()
+			};
+			used.set(fontKey, bucket);
+		}
+		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);
+	};
+	const addMath = (node) => {
+		for (const seg of mathGlyphSegments(node)) {
+			const { bold, italic } = variantStyle(seg.variant);
+			const { variant, parsed } = options.registry.resolveByStyle(bold, italic);
+			let bucket = used.get(variant);
+			if (!bucket) {
+				bucket = {
+					parsed,
+					gids: /* @__PURE__ */ new Set()
+				};
+				used.set(variant, bucket);
+			}
+			for (const ch of seg.text) bucket.gids.add(parsed.glyphForCodepoint(ch.codePointAt(0)));
+		}
+	};
+	const visit = (elements) => {
+		for (const el of elements) if (el.kind === "paragraph") for (const run of el.paragraph.runs) {
+			if (run.math) {
+				addMath(run.math);
+				continue;
+			}
+			if (run.inlineImage && !run.text) continue;
+			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 === "shape") {
+			if (el.shape.text) visit(el.shape.text.content);
+		} else if (el.kind === "chart") {
+			const chart = options.charts?.get(el.chart.chartRelId);
+			if (chart) {
+				const reg = options.registry.resolveByStyle(false, false);
+				let bucket = used.get(reg.variant);
+				if (!bucket) {
+					bucket = {
+						parsed: reg.parsed,
+						gids: /* @__PURE__ */ new Set()
+					};
+					used.set(reg.variant, bucket);
+				}
+				const add = (s) => {
+					for (const ch of s) bucket.gids.add(reg.parsed.glyphForCodepoint(ch.codePointAt(0)));
+				};
+				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);
+				add("0123456789.,-%() ");
+			}
+		}
+	};
+	visit(body);
+	for (const hf of headersFooters.values()) visit(hf);
+	if (used.size === 0) {
+		const regular = options.registry.resolveByStyle(false, false);
+		used.set(regular.variant, {
+			parsed: regular.parsed,
+			gids: new Set([0])
+		});
+	}
+	const out = /* @__PURE__ */ new Map();
+	let counter = 0;
+	for (const [variant, info] of used) {
+		counter++;
+		const resourceName = `F${counter}`;
+		out.set(variant, {
+			resourceName,
+			parsed: info.parsed,
+			measure: createFontMeasure(info.parsed),
+			gids: info.gids
+		});
+	}
+	return out;
+}
+function layoutParagraphBlock(paragraph, options, fontResources, imageResources, contentWidth) {
+	const baseResolved = resolveParagraphProperties(paragraph.properties, options.styles);
+	const baseDir = paragraphBaseDirection(paragraph, baseResolved);
+	const resolved = 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);
+	let heightPt = 0;
+	for (const line of lines) heightPt += computeLineHeight(line, resolved);
+	const numbering = paragraph.properties.numbering;
+	return {
+		kind: "paragraph",
+		resolved,
+		lines,
+		heightPt,
+		spacingBeforePt: resolved.spacingBefore,
+		spacingAfterPt: resolved.spacingAfter,
+		...numbering ? { list: {
+			numId: numbering.numId,
+			level: numbering.ilvl
+		} } : {},
+		...paragraph.runs.some((r) => r.pageBreak) ? { pageBreakAfter: true } : {}
+	};
+}
+function resolveMathItems(items, fontFor) {
+	return items.map((it) => {
+		if (it.kind === "glyph") return {
+			kind: "glyph",
+			x: it.x,
+			y: it.y,
+			text: it.text,
+			font: fontFor(it.variant),
+			sizePt: it.sizePt
+		};
+		if (it.kind === "rule") return {
+			kind: "rule",
+			x: it.x,
+			y: it.y,
+			w: it.w,
+			h: it.h
+		};
+		return {
+			kind: "path",
+			segments: it.segments,
+			...it.strokeWidthPt !== void 0 ? { strokeWidthPt: it.strokeWidthPt } : {},
+			...it.fill ? { fill: true } : {}
+		};
+	});
+}
+function tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir) {
+	const plans = paragraph.runs.map((run) => {
+		if (run.inlineImage) {
+			const naturalW = run.inlineImage.width;
+			const widthPt = Math.min(naturalW, contentWidth);
+			const scale = naturalW > 0 ? widthPt / naturalW : 1;
+			const heightPt = run.inlineImage.height * scale;
+			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);
+			return {
+				run,
+				resolvedRun,
+				font: lookupFont(fontResources, fontKey),
+				fontSizePt: resolvedRun.fontSizePt,
+				isImage: true,
+				imageWidthPt: widthPt,
+				imageHeightPt: heightPt,
+				imageResourceName: res?.resourceName ?? ""
+			};
+		}
+		if (run.math) {
+			const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
+			const sizePt = resolvedRun.fontSizePt;
+			const fontFor = (v) => {
+				const { bold, italic } = variantStyle(v);
+				const r = options.registry.resolveByStyle(bold, italic);
+				return fontResources.get(r.variant) ?? fontResources.get(options.registry.resolveByStyle(false, false).variant);
+			};
+			const measure = (text, sz, v) => fontFor(v).measure.textWidthPt(text, sz);
+			const box = layoutMath(run.math, { sizePt }, measure);
+			const { variant } = options.registry.resolveByStyle(resolvedRun.bold, resolvedRun.italic);
+			return {
+				run,
+				resolvedRun,
+				font: lookupFont(fontResources, variant),
+				fontSizePt: sizePt,
+				isImage: false,
+				imageWidthPt: 0,
+				imageHeightPt: 0,
+				imageResourceName: "",
+				math: {
+					items: resolveMathItems(box.items, fontFor),
+					widthPt: box.width,
+					ascentPt: box.ascent,
+					descentPt: box.descent
+				}
+			};
+		}
+		const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
+		const { fontKey } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
+		return {
+			run,
+			resolvedRun,
+			font: lookupFont(fontResources, fontKey),
+			fontSizePt: resolvedRun.fontSizePt,
+			isImage: false,
+			imageWidthPt: 0,
+			imageHeightPt: 0,
+			imageResourceName: ""
+		};
+	});
+	const anyRtlRun = plans.some((p) => p.resolvedRun.rtl);
+	const anyBidiChars = plans.some((p) => !p.isImage && hasBidiCharacters(p.run.text));
+	if (!(baseDir === "rtl" || anyRtlRun || anyBidiChars)) return tokenizePlansLtr(plans);
+	return tokenizePlansBidi(plans, segmentLevels(plans.map((plan) => ({
+		text: plan.run.text,
+		...plan.isImage || plan.math !== void 0 ? { object: true } : {},
+		...plan.resolvedRun.rtl ? { rtl: true } : {}
+	})), baseDir));
+}
+function tokenizePlansLtr(plans) {
+	const tokens = [];
+	for (const plan of plans) {
+		if (plan.isImage) {
+			tokens.push({
+				kind: "image",
+				imageResourceName: plan.imageResourceName,
+				widthPt: plan.imageWidthPt,
+				heightPt: plan.imageHeightPt,
+				isSpace: false,
+				bidiLevel: 0
+			});
+			continue;
+		}
+		if (plan.math) {
+			tokens.push({
+				kind: "math",
+				items: plan.math.items,
+				widthPt: plan.math.widthPt,
+				ascentPt: plan.math.ascentPt,
+				descentPt: plan.math.descentPt,
+				isSpace: false,
+				bidiLevel: 0
+			});
+			continue;
+		}
+		for (const t of tokenizeText(plan.run.text)) tokens.push({
+			kind: "text",
+			text: t.text,
+			isSpace: t.isSpace,
+			resolvedRun: plan.resolvedRun,
+			font: plan.font,
+			fontSizePt: plan.fontSizePt,
+			widthPt: plan.font.measure.textWidthPt(t.text, plan.fontSizePt),
+			bidiLevel: 0
+		});
+	}
+	return tokens;
+}
+function tokenizePlansBidi(plans, realLevels) {
+	const tokens = [];
+	let realIdx = 0;
+	for (let r = 0; r < plans.length; r++) {
+		const plan = plans[r];
+		if (plan.isImage) {
+			tokens.push({
+				kind: "image",
+				imageResourceName: plan.imageResourceName,
+				widthPt: plan.imageWidthPt,
+				heightPt: plan.imageHeightPt,
+				isSpace: false,
+				bidiLevel: realLevels[realIdx] ?? 0
+			});
+			realIdx++;
+			continue;
+		}
+		if (plan.math) {
+			tokens.push({
+				kind: "math",
+				items: plan.math.items,
+				widthPt: plan.math.widthPt,
+				ascentPt: plan.math.ascentPt,
+				descentPt: plan.math.descentPt,
+				isSpace: false,
+				bidiLevel: realLevels[realIdx] ?? 0
+			});
+			realIdx++;
+			continue;
+		}
+		const chars = [...plan.run.text];
+		let bufStart = 0;
+		let curSpace = false;
+		let curLevel = -1;
+		const flush = (endExclusive) => {
+			if (endExclusive <= bufStart) return;
+			const text = chars.slice(bufStart, endExclusive).join("");
+			tokens.push({
+				kind: "text",
+				text,
+				isSpace: curSpace,
+				resolvedRun: plan.resolvedRun,
+				font: plan.font,
+				fontSizePt: plan.fontSizePt,
+				widthPt: plan.font.measure.textWidthPt(text, plan.fontSizePt),
+				bidiLevel: curLevel
+			});
+		};
+		for (let c = 0; c < chars.length; c++) {
+			const ch = chars[c];
+			const isSpace = /\s/.test(ch);
+			const level = realLevels[realIdx] ?? 0;
+			if (c === 0) {
+				curSpace = isSpace;
+				curLevel = level;
+			} else if (isSpace !== curSpace || level !== curLevel) {
+				flush(c);
+				bufStart = c;
+				curSpace = isSpace;
+				curLevel = level;
+			}
+			realIdx++;
+		}
+		flush(chars.length);
+	}
+	return tokens;
+}
+function paragraphBaseDirection(paragraph, resolved) {
+	if (resolved.bidi) return "rtl";
+	let text = "";
+	for (const run of paragraph.runs) {
+		if (!run.inlineImage) text += run.text;
+		if (text.length > 64) break;
+	}
+	if (!hasBidiCharacters(text)) return "ltr";
+	return analyzeString(text, "auto").paragraphLevel === 1 ? "rtl" : "ltr";
+}
+function paragraphMaxWidth(p, contentWidth, firstLine) {
+	const indentLeft = p.indentLeft;
+	const indentRight = p.indentRight;
+	const firstLineExtra = firstLine ? p.indentFirstLine : 0;
+	return Math.max(1, contentWidth - indentLeft - indentRight - firstLineExtra);
+}
+function tokenizeText(text) {
+	const out = [];
+	if (text.length === 0) return out;
+	const re = /(\s+)|(\S+)/g;
+	let m;
+	while ((m = re.exec(text)) !== null) if (m[1] !== void 0) out.push({
+		text: m[1],
+		isSpace: true
+	});
+	else if (m[2] !== void 0) out.push({
+		text: m[2],
+		isSpace: false
+	});
+	return out;
+}
+var HYPHENATION_PENALTY = 50;
+function paragraphItemStream(tokens, hyphenator) {
+	const entries = [];
+	for (const tok of tokens) {
+		if (tok.isSpace || tok.kind === "image" || tok.kind === "math") {
+			entries.push({
+				item: tok.isSpace ? {
+					type: "glue",
+					width: tok.widthPt,
+					stretch: tok.widthPt * .6,
+					shrink: tok.widthPt * .3
+				} : {
+					type: "box",
+					width: tok.widthPt
+				},
+				token: tok
+			});
+			continue;
+		}
+		const positions = hyphenator ? hyphenator.hyphenate(tok.text) : [];
+		if (positions.length === 0) {
+			entries.push({
+				item: {
+					type: "box",
+					width: tok.widthPt
+				},
+				token: tok
+			});
+			continue;
+		}
+		const hyphenWidth = tok.font.measure.textWidthPt("-", tok.fontSizePt);
+		let prev = 0;
+		for (let pi = 0; pi <= positions.length; pi++) {
+			const end = pi < positions.length ? positions[pi] : tok.text.length;
+			const fragText = tok.text.substring(prev, end);
+			const fragWidth = tok.font.measure.textWidthPt(fragText, tok.fontSizePt);
+			const fragTok = {
+				kind: "text",
+				text: fragText,
+				isSpace: false,
+				resolvedRun: tok.resolvedRun,
+				font: tok.font,
+				fontSizePt: tok.fontSizePt,
+				widthPt: fragWidth,
+				bidiLevel: tok.bidiLevel
+			};
+			entries.push({
+				item: {
+					type: "box",
+					width: fragWidth
+				},
+				token: fragTok
+			});
+			if (pi < positions.length) entries.push({
+				item: {
+					type: "penalty",
+					width: hyphenWidth,
+					penalty: HYPHENATION_PENALTY,
+					flagged: true
+				},
+				token: null,
+				hyphenWidthPt: hyphenWidth
+			});
+			prev = end;
+		}
+	}
+	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
+	});
+	return entries;
+}
+function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved) {
+	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;
+		if (ft) lineTokens.push(ft);
+	}
+	const hyphenWidth = entries[breakIdx]?.hyphenWidthPt;
+	if (hyphenWidth !== void 0) {
+		const lastIdx = lineTokens.length - 1;
+		const last = lineTokens[lastIdx];
+		if (last && last.kind === "text") lineTokens[lastIdx] = {
+			...last,
+			text: last.text + "-",
+			widthPt: last.widthPt + hyphenWidth
+		};
+	}
+	const tokenLineSize = (t) => t.kind === "text" ? t.fontSizePt : t.kind === "image" ? t.heightPt : 0;
+	let contentWidth = 0;
+	let maxSize = 0;
+	let mathAscent = 0;
+	let mathDescent = 0;
+	for (const t of lineTokens) {
+		contentWidth += t.widthPt;
+		const sz = tokenLineSize(t);
+		if (sz > maxSize) maxSize = sz;
+		if (t.kind === "math") {
+			mathAscent = Math.max(mathAscent, t.ascentPt);
+			mathDescent = Math.max(mathDescent, t.descentPt);
+		}
+	}
+	return {
+		tokens: lineTokens,
+		contentWidthPt: contentWidth,
+		maxFontSizePt: maxSize,
+		availableWidthPt,
+		firstLine: isFirst,
+		resolved,
+		isLastInParagraph: false,
+		mathAscentPt: mathAscent,
+		mathDescentPt: mathDescent
+	};
+}
+function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator) {
+	if (tokens.length === 0) return [];
+	const entries = paragraphItemStream(tokens, hyphenator);
+	const { breaks } = breakLines(entries.map((e) => e.item), [firstLineWidth, otherWidth]);
+	const lines = [];
+	let start = 0;
+	let isFirst = true;
+	for (const breakIdx of breaks) {
+		const line = lineFromRange(entries, start, breakIdx, isFirst ? firstLineWidth : otherWidth, isFirst, resolved);
+		if (line) lines.push(line);
+		start = breakIdx + 1;
+		isFirst = false;
+	}
+	if (lines.length > 0) lines[lines.length - 1].isLastInParagraph = true;
+	return lines;
+}
+function computeLineHeight(line, p) {
+	const fontSize = line.maxFontSizePt || 12;
+	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 === "atLeast" && p.spacingLine > 0) return Math.max(fontSize * 1.2, p.spacingLine, mathNeed);
+	const lineTwips = Math.round(p.spacingLine * 20);
+	const multiple = lineTwips > 0 ? lineTwips / 240 : 1;
+	return Math.max(fontSize * 1.2 * multiple, mathNeed);
+}
+function lineDescent(line) {
+	const fs = line.maxFontSizePt || 12;
+	return Math.max(fs * .2, line.mathDescentPt ?? 0);
+}
+function alignmentOffset(alignment, lineWidth, available) {
+	if (alignment === "right") return Math.max(0, available - lineWidth);
+	if (alignment === "center") return Math.max(0, (available - lineWidth) / 2);
+	return 0;
+}
+function layoutTableBlock(table, options, fontResources, imageResources, contentWidth) {
+	const columnWidthsPt = computeColumnWidths(table, options, fontResources, contentWidth);
+	const mergeRoles = table.rows.map((r) => r.cells.map((c) => c.properties.merge ?? "standalone"));
+	const rows = [];
+	const colCount = columnWidthsPt.length;
+	let aboveBordersByCol = [];
+	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;
+		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;
+			ci += span;
+		}
+		aboveBordersByCol = nextAbove;
+		const rp = table.rows[r].properties;
+		rows.push(rp.isHeader || rp.pageBreakBefore ? {
+			...rl,
+			...rp.isHeader ? { isHeader: true } : {},
+			...rp.pageBreakBefore ? { breakBefore: true } : {}
+		} : rl);
+	}
+	const heightPt = rows.reduce((s, r) => s + r.heightPt, 0);
+	const totalWidthPt = columnWidthsPt.reduce((s, w) => s + w, 0);
+	return {
+		kind: "table",
+		rows,
+		heightPt,
+		totalWidthPt,
+		colCount,
+		xOffsetPt: tableXOffset(table.properties.alignment, contentWidth, totalWidthPt)
+	};
+}
+function tableXOffset(alignment, contentWidth, totalWidthPt) {
+	const slack = contentWidth - totalWidthPt;
+	if (slack <= 0 || !alignment || alignment === "left") return 0;
+	return alignment === "center" ? slack / 2 : slack;
+}
+function computeColumnWidths(table, options, fontResources, contentWidth) {
+	let colCount = table.grid.length;
+	for (const row of table.rows) {
+		let rowCols = 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 colNaturalWidths = new Array(colCount).fill(0);
+	for (const row of table.rows) {
+		let colIdx = 0;
+		for (let i = 0; i < row.cells.length; i++) {
+			const cell = row.cells[i];
+			const span = Math.max(1, cell.properties.colSpan ?? 1);
+			const padLeft = cell.properties.margins?.left ?? table.properties.defaultCellMargins?.left ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
+			const padRight = cell.properties.margins?.right ?? table.properties.defaultCellMargins?.right ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
+			let maxContent = 0;
+			for (const el of cell.content) {
+				if (el.kind !== "paragraph") continue;
+				const w = measureSingleLine(el.paragraph, options, fontResources);
+				if (w > maxContent) maxContent = w;
+			}
+			const perColumn = (maxContent + padLeft + padRight) / span;
+			for (let k = 0; k < span && colIdx + k < colCount; k++) if (perColumn > colNaturalWidths[colIdx + k]) colNaturalWidths[colIdx + k] = perColumn;
+			colIdx += span;
+		}
+	}
+	const naturalTotal = colNaturalWidths.reduce((s, w) => s + w, 0);
+	const explicitTarget = explicitTableTargetWidth(table, contentWidth);
+	if (naturalTotal === 0) return gridWidthsScaled(table, contentWidth, colCount);
+	if (explicitTarget !== void 0 && explicitTarget > 0) {
+		const scale = explicitTarget / naturalTotal;
+		return colNaturalWidths.map((w) => w * scale);
+	}
+	if (naturalTotal > contentWidth) {
+		const scale = contentWidth / naturalTotal;
+		return colNaturalWidths.map((w) => w * scale);
+	}
+	return colNaturalWidths;
+}
+function gridColTwips(table) {
+	return table.grid.map((w) => Math.round(w * 20));
+}
+function gridWidthsScaled(table, contentWidth, colCount) {
+	const gridTwips = gridColTwips(table);
+	const totalGridTwips = gridTwips.reduce((s, w) => s + w, 0);
+	if (totalGridTwips > 0) {
+		const target = totalTableTarget(table, contentWidth);
+		return gridTwips.map((w) => w / totalGridTwips * target);
+	}
+	const each = contentWidth / colCount;
+	return new Array(colCount).fill(each);
+}
+function totalTableTarget(table, contentWidth) {
+	const explicit = explicitTableTargetWidth(table, contentWidth);
+	if (explicit !== void 0 && explicit > 0) return explicit;
+	const sum = gridColTwips(table).reduce((s, g) => s + g, 0);
+	if (sum > 0) return sum * TWIP_TO_PT;
+	return contentWidth;
+}
+function explicitTableTargetWidth(table, contentWidth) {
+	const w = table.properties.widthPt;
+	const type = table.properties.widthType;
+	if (w !== void 0 && w > 0 && type === "dxa") return w;
+	const f = table.properties.widthFraction;
+	if (f !== void 0 && type === "pct") return f * contentWidth;
+}
+function measureSingleLine(paragraph, options, fontResources) {
+	let total = 0;
+	for (const run of paragraph.runs) {
+		const resolved = resolveRunProperties(run.properties, paragraph.properties, options.styles);
+		const { fontKey } = 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);
+	}
+	return total;
+}
+function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidthsPt, options, fontResources, imageResources, rowMergeRoles, aboveBordersByCol) {
+	const cells = [];
+	const columnXOffsets = [];
+	let cursorX = 0;
+	let colIdx = 0;
+	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];
+		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);
+		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);
+	return {
+		heightPt,
+		cells,
+		columnXOffsets,
+		rowIdx,
+		rowCount
+	};
+}
+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;
+	const padTopPt = cellMar?.top ?? tableMar?.top ?? 0;
+	const padBottomPt = cellMar?.bottom ?? tableMar?.bottom ?? 0;
+	const padLeftPt = cellMar?.left ?? tableMar?.left ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
+	const padRightPt = cellMar?.right ?? tableMar?.right ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
+	const innerWidth = Math.max(1, widthPt - padLeftPt - padRightPt);
+	const lines = [];
+	const nestedTables = [];
+	let contentHeightPt = 0;
+	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) {
+				lines.push(line);
+				contentHeightPt += computeLineHeight(line, block.resolved);
+			}
+			contentHeightPt += block.spacingAfterPt;
+		} else if (el.kind === "table") {
+			const nested = layoutTableBlock(el.table, options, fontResources, imageResources, innerWidth);
+			nestedTables.push(nested);
+			contentHeightPt += nested.heightPt;
+		}
+	}
+	const colEnd = colStart + colSpan - 1;
+	const borders = resolveCellBorders(cell.properties.borders, tableProps.borders, rowIdx, colStart, colEnd, rowCount, colCount, mergeRole, leftNeighborBorders, aboveNeighborBorders);
+	const totalHeightPt = mergeRole === "middle" || mergeRole === "end" ? 0 : padTopPt + contentHeightPt + padBottomPt;
+	return {
+		widthPt,
+		padTopPt,
+		padRightPt,
+		padBottomPt,
+		padLeftPt,
+		borders,
+		...cell.properties.shading?.colorHex ? { shadingColorHex: cell.properties.shading.colorHex } : {},
+		lines,
+		...nestedTables.length > 0 ? { nestedTables } : {},
+		contentHeightPt,
+		totalHeightPt,
+		colStart,
+		colSpan,
+		mergeRole
+	};
+}
+var BORDER_STYLE_RANK = {
+	double: 5,
+	thick: 4,
+	single: 3,
+	dashed: 2,
+	dotted: 1,
+	none: 0
+};
+function borderWeight(b) {
+	if (!b || b.style === "none") return 0;
+	return b.width ?? .5;
+}
+function heavierBorder(a, b) {
+	const wa = borderWeight(a);
+	const wb = borderWeight(b);
+	if (wa !== wb) return wa > wb ? a : b;
+	if (wa === 0) return void 0;
+	return BORDER_STYLE_RANK[a.style] >= BORDER_STYLE_RANK[b.style] ? a : b;
+}
+function resolveCellBorders(cellBorders, tableBorders, rowIdx, colStart, colEnd, rowCount, colCount, mergeRole, leftNeighbor, aboveNeighbor) {
+	const isFirstRow = rowIdx === 0;
+	const isLastRow = rowIdx === rowCount - 1;
+	const isFirstCol = colStart === 0;
+	const isLastCol = colEnd === colCount - 1;
+	const out = {};
+	const ownTop = cellBorders?.top ?? (isFirstRow ? tableBorders?.top : tableBorders?.insideH);
+	const ownBottom = cellBorders?.bottom ?? (isLastRow ? tableBorders?.bottom : tableBorders?.insideH);
+	const ownLeft = cellBorders?.left ?? (isFirstCol ? tableBorders?.left : tableBorders?.insideV);
+	const ownRight = cellBorders?.right ?? (isLastCol ? tableBorders?.right : tableBorders?.insideV);
+	const aboveBottom = aboveNeighbor ? aboveNeighbor.bottom ?? tableBorders?.insideH : void 0;
+	const leftRight = leftNeighbor ? leftNeighbor.right ?? tableBorders?.insideV : void 0;
+	const top = isFirstRow ? ownTop : heavierBorder(ownTop, aboveBottom);
+	const left = isFirstCol ? ownLeft : heavierBorder(ownLeft, leftRight);
+	const bottom = ownBottom;
+	const right = ownRight;
+	const suppressTop = mergeRole === "middle" || mergeRole === "end";
+	const suppressBottom = mergeRole === "start" || mergeRole === "middle";
+	if (top && !suppressTop) out.top = top;
+	if (bottom && !suppressBottom) out.bottom = bottom;
+	if (left) out.left = left;
+	if (right) out.right = right;
+	return out;
+}
+function paragraphStructType(resolved) {
+	const lvl = resolved.outlineLevel;
+	if (lvl !== void 0 && lvl >= 0 && lvl <= 8) return `H${Math.min(lvl, 5) + 1}`;
+	return headingFromStyleId(resolved.styleId) ?? "P";
+}
+function headingFromStyleId(styleId) {
+	if (!styleId) return null;
+	const m = /^Heading\s*([1-9])$/i.exec(styleId);
+	if (m) return `H${Math.min(Number(m[1]), 6)}`;
+	if (/^(Title|Subtitle)$/i.test(styleId)) return "H1";
+	return null;
+}
+function dominantParagraphLang(lines) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const line of lines) for (const tok of line.tokens) {
+		if (tok.kind !== "text") continue;
+		const l = tok.resolvedRun.lang;
+		if (l) counts.set(l, (counts.get(l) ?? 0) + tok.text.length);
+	}
+	let best;
+	let bestN = 0;
+	for (const [l, n] of counts) if (n > bestN) {
+		best = l;
+		bestN = n;
+	}
+	return best;
+}
+function createFigure(builder, alt, fallback) {
+	const node = builder.create("Figure", builder.root);
+	node.alt = alt && alt.trim().length > 0 ? alt : fallback;
+	return node.id;
+}
+function listItemParagraphNode(builder, stack, list) {
+	const lvl = list.level;
+	while (stack.length > 0) {
+		const t = stack[stack.length - 1];
+		if (t.level > lvl || t.level === lvl && t.numId !== list.numId) stack.pop();
+		else break;
+	}
+	let frame = stack[stack.length - 1];
+	if (!frame || frame.level < lvl) {
+		const parent = frame?.lbody ?? builder.root;
+		const listNode = builder.create("L", parent);
+		frame = {
+			level: lvl,
+			numId: list.numId,
+			listNode,
+			lbody: null
+		};
+		stack.push(frame);
+	}
+	const li = builder.create("LI", frame.listNode);
+	const lbody = builder.create("LBody", li);
+	frame.lbody = lbody;
+	return builder.create("P", lbody).id;
+}
+function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US") {
+	if (sectionCtxs.length === 0) return [];
+	const pages = [];
+	let ctx = sectionCtxs[0];
+	let secIdx = 0;
+	let pageInSection = 0;
+	let globalPageIdx = 0;
+	let current = [];
+	let pendingPageBreak = false;
+	let cursorY = ctx.pageHeight - ctx.marginTop;
+	const listStack = [];
+	const flushPage = (force = false) => {
+		if (current.length === 0 && !force) return;
+		const band = bandForPage(pageInSection, globalPageIdx, ctx.titlePg, ctx.evenAndOddHeaders);
+		const header = pickBand(ctx.headerSet, band);
+		const footer = pickBand(ctx.footerSet, band);
+		pages.push({
+			commands: [
+				...header,
+				...current,
+				...footer
+			],
+			width: pt(ctx.pageWidth),
+			height: pt(ctx.pageHeight)
+		});
+		current = [];
+		pageInSection++;
+		globalPageIdx++;
+		cursorY = ctx.pageHeight - ctx.marginTop;
+	};
+	for (let blockIdx = 0; blockIdx < blocks.length; blockIdx++) {
+		while (secIdx < sectionCtxs.length - 1 && blockIdx >= ctx.endIndex) {
+			flushPage();
+			secIdx++;
+			ctx = sectionCtxs[secIdx];
+			pageInSection = 0;
+			cursorY = ctx.pageHeight - ctx.marginTop;
+		}
+		const block = blocks[blockIdx];
+		if (pendingPageBreak) {
+			pendingPageBreak = false;
+			if (current.length > 0) flushPage();
+		}
+		if (builder && !(block.kind === "paragraph" && block.list)) listStack.length = 0;
+		if (block.kind === "paragraph") {
+			if (block.resolved.pageBreakBefore && current.length > 0) flushPage();
+			cursorY -= block.spacingBeforePt;
+			let structId;
+			if (builder) {
+				structId = block.list ? listItemParagraphNode(builder, listStack, block.list) : builder.create(paragraphStructType(block.resolved), builder.root).id;
+				const lang = dominantParagraphLang(block.lines);
+				if (lang && lang !== defaultLang) builder.node(structId).lang = lang;
+			}
+			for (const line of block.lines) {
+				const h = computeLineHeight(line, block.resolved);
+				if (cursorY - h < ctx.marginBottom && current.length > 0) flushPage();
+				cursorY -= h;
+				const indentLeft = block.resolved.indentLeft + (line.firstLine ? block.resolved.indentFirstLine : 0);
+				const offset = alignmentOffset(block.resolved.alignment, line.contentWidthPt, line.availableWidthPt);
+				current.push({
+					type: "line",
+					line,
+					originX: pt(ctx.marginLeft + indentLeft + offset),
+					baselineY: pt(ctx.pageHeight - (cursorY + lineDescent(line))),
+					...structId !== void 0 ? { structId } : {}
+				});
+			}
+			cursorY -= block.spacingAfterPt;
+			if (block.pageBreakAfter) pendingPageBreak = true;
+		} else if (block.kind === "image") {
+			const figId = builder ? createFigure(builder, block.altText, "Image") : void 0;
+			cursorY -= block.spacingBeforePt;
+			if (cursorY - block.heightPt < ctx.marginBottom && current.length > 0) flushPage();
+			cursorY -= block.heightPt;
+			current.push({
+				type: "image",
+				x: pt(ctx.marginLeft),
+				y: pt(ctx.pageHeight - cursorY - block.heightPt),
+				width: pt(block.widthPt),
+				height: pt(block.heightPt),
+				imageResourceName: block.resourceName,
+				...figId !== void 0 ? { structId: figId } : {}
+			});
+			cursorY -= block.spacingAfterPt;
+		} else if (block.kind === "shape") {
+			const figId = builder ? createFigure(builder, block.altText, "Shape") : void 0;
+			cursorY -= block.spacingBeforePt;
+			if (cursorY - block.heightPt < ctx.marginBottom && current.length > 0) flushPage();
+			cursorY -= block.heightPt;
+			const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, ctx.contentWidth);
+			const x = ctx.marginLeft + offset;
+			const transform = flipTransform(buildShapeTransform(x, cursorY, block.widthPt, block.heightPt, block.rotation60k, block.flipH, block.flipV), ctx.pageHeight);
+			current.push({
+				type: "shape",
+				shape: {
+					paths: block.paths,
+					...block.fillColorHex ? { fillColorHex: block.fillColorHex } : {},
+					...block.stroke ? { stroke: block.stroke } : {},
+					transform
+				},
+				...figId !== void 0 ? { structId: figId } : {}
+			});
+			if (block.textLines.length > 0) {
+				const shapeBottom = cursorY;
+				const shapeTop = cursorY + 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);
+					current.push({
+						type: "line",
+						line,
+						originX: pt(x + block.insetLeftPt + lineOffset),
+						baselineY: pt(ctx.pageHeight - (textY + lineDescent(line))),
+						...figId !== void 0 ? { structId: figId } : {}
+					});
+				}
+			}
+			cursorY -= block.spacingAfterPt;
+		} else if (block.kind === "chart") {
+			const figId = builder ? createFigure(builder, block.altText, "Chart") : void 0;
+			const fig = figId !== void 0 ? { structId: figId } : {};
+			cursorY -= block.spacingBeforePt;
+			if (cursorY - block.heightPt < ctx.marginBottom && current.length > 0) flushPage();
+			cursorY -= block.heightPt;
+			const offset = alignmentOffset(block.resolvedAlignment, block.widthPt, ctx.contentWidth);
+			const x = ctx.marginLeft + offset;
+			const y = cursorY;
+			for (const s of block.layout.shapes) current.push({
+				type: "shape",
+				shape: {
+					paths: s.paths,
+					...s.fillColorHex ? { fillColorHex: s.fillColorHex } : {},
+					...s.stroke ? { stroke: s.stroke } : {},
+					transform: flipTransform([
+						1,
+						0,
+						0,
+						1,
+						x,
+						y
+					], ctx.pageHeight)
+				},
+				...fig
+			});
+			for (const t of block.layout.texts) current.push({
+				type: "line",
+				line: t.line,
+				originX: pt(x + t.x),
+				baselineY: pt(ctx.pageHeight - (y + t.y)),
+				...fig
+			});
+			cursorY -= block.spacingAfterPt;
+		} 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 headerRows = [];
+			for (const r of block.rows) if (r.isHeader) headerRows.push(r);
+			else break;
+			const headerHeightPt = headerRows.reduce((s, r) => s + r.heightPt, 0);
+			const tableNode = builder ? builder.create("Table", builder.root) : void 0;
+			const tableX = ctx.marginLeft + block.xOffsetPt;
+			for (let ri = 0; ri < block.rows.length; ri++) {
+				const row = block.rows[ri];
+				const isLeadingHeader = ri < headerRows.length;
+				let cellStructIds;
+				if (builder && tableNode) {
+					const b = builder;
+					const tr = b.create("TR", tableNode);
+					cellStructIds = row.cells.map((cell) => {
+						if (cell.mergeRole === "middle" || cell.mergeRole === "end") return void 0;
+						const cellNode = b.create(row.isHeader ? "TH" : "TD", tr);
+						if (row.isHeader) cellNode.scope = "Column";
+						if (cell.colSpan > 1) cellNode.colSpan = cell.colSpan;
+						const rowSpan = tableCellRowSpan(block.rows, ri, cell.colStart);
+						if (rowSpan > 1) cellNode.rowSpan = rowSpan;
+						return b.create("P", cellNode).id;
+					});
+				}
+				const chunks = row.heightPt > ctx.pageContentHeight ? splitRowIntoChunks(row, ctx.pageContentHeight) : [row];
+				for (let ci = 0; ci < chunks.length; ci++) {
+					const chunk = chunks[ci];
+					const forcedBreak = ci === 0 && row.breakBefore && !isLeadingHeader && current.length > 0;
+					const overflow = cursorY - chunk.heightPt < ctx.marginBottom && current.length > 0;
+					if (forcedBreak || overflow) {
+						flushPage();
+						if (!isLeadingHeader && headerRows.length > 0 && cursorY - headerHeightPt - chunk.heightPt >= ctx.marginBottom) for (const hr of headerRows) {
+							emitRowChunk(current, hr, tableX, cursorY, ctx.pageHeight, colCount, void 0);
+							cursorY -= hr.heightPt;
+						}
+					}
+					emitRowChunk(current, chunk, tableX, cursorY, ctx.pageHeight, colCount, cellStructIds);
+					cursorY -= chunk.heightPt;
+				}
+			}
+		}
+	}
+	flushPage();
+	if (pages.length === 0) flushPage(true);
+	return pages;
+}
+function tableCellRowSpan(rows, startRowIdx, colStart) {
+	let span = 1;
+	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;
+		span++;
+		if (cont.mergeRole === "end") break;
+	}
+	return span;
+}
+function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds) {
+	const rowTop = cursorY;
+	const rowBottom = cursorY - row.heightPt;
+	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
+		});
+		emitCellBorders(out, cell, cellX, rowBottom, row.heightPt, pageHeight, row.rowIdx, row.rowCount, colCount);
+		if (cell.mergeRole === "middle" || cell.mergeRole === "end") continue;
+		let textY = rowTop - cell.padTopPt;
+		for (const line of cell.lines) {
+			const h = computeLineHeight(line, line.resolved);
+			textY -= h;
+			const offset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, cell.widthPt - cell.padLeftPt - cell.padRightPt);
+			out.push({
+				type: "line",
+				line,
+				originX: pt(cellX + cell.padLeftPt + offset),
+				baselineY: pt(pageHeight - (textY + lineDescent(line))),
+				...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;
+			}
+		}
+	}
+}
+function splitRowIntoChunks(row, capacity) {
+	if (row.cells.some((c) => c.nestedTables && c.nestedTables.length > 0)) return [row];
+	const queues = row.cells.map((c) => ({
+		remaining: [...c.lines],
+		template: c
+	}));
+	const anyHasLines = () => queues.some((q) => q.template.mergeRole === "middle" || q.template.mergeRole === "end" ? false : q.remaining.length > 0);
+	const out = [];
+	let isFirst = true;
+	let safety = 1e3;
+	while (anyHasLines() && safety-- > 0) {
+		const chunkCells = [];
+		let chunkHeight = 0;
+		for (let i = 0; i < queues.length; i++) {
+			const q = queues[i];
+			const tpl = q.template;
+			if (tpl.mergeRole === "middle" || tpl.mergeRole === "end") {
+				chunkCells.push(tpl);
+				continue;
+			}
+			const padTop = isFirst ? tpl.padTopPt : 0;
+			const capacityForLines = Math.max(0, capacity - padTop);
+			const taken = [];
+			let takenHeight = 0;
+			while (q.remaining.length > 0) {
+				const next = q.remaining[0];
+				const lh = computeLineHeight(next, next.resolved);
+				if (taken.length > 0 && takenHeight + lh > capacityForLines) break;
+				taken.push(next);
+				takenHeight += lh;
+				q.remaining.shift();
+			}
+			const cellHeight = padTop + takenHeight;
+			const chunkCell = {
+				...tpl,
+				padTopPt: padTop,
+				padBottomPt: 0,
+				lines: taken,
+				contentHeightPt: takenHeight,
+				totalHeightPt: cellHeight
+			};
+			chunkCells.push(chunkCell);
+			if (cellHeight > chunkHeight) chunkHeight = cellHeight;
+		}
+		const isLast = !anyHasLines();
+		if (isLast) for (let i = 0; i < chunkCells.length; i++) {
+			const tpl = queues[i].template;
+			if (tpl.mergeRole === "middle" || tpl.mergeRole === "end") continue;
+			const cell = chunkCells[i];
+			const total = cell.padTopPt + cell.contentHeightPt + tpl.padBottomPt;
+			chunkCells[i] = {
+				...cell,
+				padBottomPt: tpl.padBottomPt,
+				totalHeightPt: total
+			};
+			if (total > chunkHeight) chunkHeight = total;
+		}
+		for (let i = 0; i < chunkCells.length; i++) {
+			const cell = chunkCells[i];
+			const src = cell.borders;
+			const borders = {
+				...isFirst && src.top ? { top: src.top } : {},
+				...isLast && src.bottom ? { bottom: src.bottom } : {},
+				...src.left ? { left: src.left } : {},
+				...src.right ? { right: src.right } : {}
+			};
+			chunkCells[i] = {
+				...cell,
+				borders
+			};
+		}
+		out.push({
+			heightPt: chunkHeight,
+			cells: chunkCells,
+			columnXOffsets: row.columnXOffsets,
+			rowIdx: row.rowIdx,
+			rowCount: row.rowCount
+		});
+		isFirst = false;
+	}
+	return out.length > 0 ? out : [row];
+}
+function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx, rowCount, colCount) {
+	const pushSide = (side, border) => {
+		if (!border || border.style === "none") return;
+		const sz = border.width ?? DEFAULT_BORDER_SIZE_EIGHTH * EIGHTH_PT;
+		out.push({
+			type: "border",
+			side,
+			x: pt(cellX),
+			y: pt(pageHeight - cellY - rowHeight),
+			width: pt(cell.widthPt),
+			height: pt(rowHeight),
+			borderSizePt: sz,
+			borderColorHex: border.colorHex ?? "000000"
+		});
+	};
+	pushSide("top", cell.borders.top);
+	pushSide("left", cell.borders.left);
+	if (rowIdx === rowCount - 1) pushSide("bottom", cell.borders.bottom);
+	if (cell.colStart + cell.colSpan - 1 === colCount - 1) pushSide("right", cell.borders.right);
+}
+//#endregion
+export { layoutStyledDocument };