reamkit 1.22.0 → 1.24.0

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

@@ -1,4 +1,5 @@
-import { resolveFamilyKey } from "../core/fonts/remote-fonts.js";
+import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
+import { scriptForCodepoint } from "../core/fonts/scripts.js";
 import { shapeText } from "../core/font/opentype-layout.js";
 import { createFontMeasure } from "../core/font/measure.js";
 import { halfPtToPt, pt } from "../core/ir/units.js";
@@ -948,8 +949,9 @@ function layoutBodyElement(el, options, fontResources, imageResources, contentWi
 	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") {
-		const meta = el.image.resource ? imageResources?.get(el.image.resource)?.metafile : void 0;
-		return meta ? layoutMetafileBlock(el.image, meta, options, fontResources, contentWidth, maxHeight, box) : layoutImageBlock(el.image, imageResources, contentWidth, maxHeight, box);
+		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);
 	}
 	if (el.kind === "chart") return layoutChartBlock(el.chart, options, fontResources, contentWidth, maxHeight, imageResources);
 	return layoutShapeBlock(el.shape, options, fontResources, imageResources, contentWidth, maxHeight, box);
@@ -1027,9 +1029,9 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 	const fillGradient = shape.fill.kind === "gradient" ? shape.fill.gradient : void 0;
 	const fillImage = shape.fill.kind === "picture" && shape.fill.imageResource !== void 0 ? imageResources?.get(shape.fill.imageResource) : void 0;
 	const fillImageResourceName = fillImage?.resourceName;
-	const fillImageTile = shape.fill.kind === "picture" && shape.fill.tiled === true && fillImage?.prepared ? {
-		widthPt: fillImage.prepared.widthPx * 72 / 96,
-		heightPt: fillImage.prepared.heightPx * 72 / 96
+	const fillImageTile = shape.fill.kind === "picture" && shape.fill.tiled === true && fillImage?.prepared ? shape.fill.tileSizePt ?? {
+		widthPt: fillImage.prepared.widthPx * 72 / (fillImage.prepared.dpiX ?? 96) * (shape.fill.tileScale?.sx ?? 1),
+		heightPt: fillImage.prepared.heightPx * 72 / (fillImage.prepared.dpiY ?? 96) * (shape.fill.tileScale?.sy ?? 1)
 	} : void 0;
 	const fillColorHex = shape.fill.kind === "solid" ? shape.fill.colorHex : fillGradient ? gradientToSolid(fillGradient) : void 0;
 	const stroke = buildStroke(shape.line);
@@ -1047,8 +1049,9 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 	const textLineGaps = /* @__PURE__ */ new Map();
 	let textHeightPt = 0;
 	const vertical = text?.vertical;
+	const warp = text?.warp;
 	if (text && text.content.length > 0) {
-		const innerWidth = vertical ? Math.max(1, heightPt - insetTopPt - insetBottomPt) : Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		const innerWidth = warp ? Number.MAX_SAFE_INTEGER : vertical ? Math.max(1, heightPt - insetTopPt - insetBottomPt) : Math.max(1, widthPt - insetLeftPt - insetRightPt);
 		for (const el of text.content) {
 			if (el.kind === "image") {
 				const res = el.image.resource ? imageResources?.get(el.image.resource) : void 0;
@@ -1141,6 +1144,16 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		}
 	}
 	if (text?.autoFit && !vertical && textLines.length > 0) heightPt = textHeightPt + insetTopPt + insetBottomPt;
+	if (text?.shrinkToFit === true && text.fitToBox !== true && warp === void 0 && textLines.length > 0 && fitPass < MAX_FIT_PASSES) {
+		const innerW = Math.max(1, widthPt - insetLeftPt - insetRightPt);
+		const innerH = Math.max(1, heightPt - insetTopPt - insetBottomPt);
+		const widest = textLines.reduce((a, l) => Math.max(a, l.contentWidthPt), 0);
+		const k = Math.min(1, innerW / Math.max(1, widest), innerH / Math.max(1, textHeightPt));
+		if (Number.isFinite(k) && k > .05 && k < .98) return layoutShapeBlock({
+			...shape,
+			text: scaleTextBody(text, k)
+		}, options, fontResources, imageResources, contentWidth, maxHeight, box, fitPass + 1);
+	}
 	if (text?.fitToBox === true && textLines.length > 0 && fitPass < MAX_FIT_PASSES) {
 		const innerW = Math.max(1, widthPt - insetLeftPt - insetRightPt);
 		const innerH = Math.max(1, heightPt - insetTopPt - insetBottomPt);
@@ -1164,6 +1177,10 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 			text: scaleTextBody(text, k)
 		}, options, fontResources, imageResources, contentWidth, maxHeight, box, fitPass + 1);
 	}
+	const warpInk = warp && textLines.length > 0 ? {
+		above: lineInk(textLines[0]).above,
+		below: lineInk(textLines[textLines.length - 1]).below
+	} : void 0;
 	const paths = buildShapePaths(shape.geometry, widthPt, heightPt);
 	const markerPaths = lineEndPaths(paths, shape.line, stroke?.widthPt ?? 0);
 	const scale = shape.width > 0 ? widthPt / shape.width : 1;
@@ -1185,6 +1202,7 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		...markerPaths.length > 0 ? { markerPaths } : {},
 		...fillImageResourceName ? { fillImageResourceName } : {},
 		...fillImageTile ? { fillImageTile } : {},
+		...fillImageTile && shape.fill.kind === "picture" && shape.fill.tileFromCentre === true ? { fillImageTileFromCentre: true } : {},
 		...fillImageResourceName && shape.fill.imageCrop ? { fillImageCrop: shape.fill.imageCrop } : {},
 		...fillImageResourceName && shape.fill.imageFillRect ? { fillImageRect: shape.fill.imageFillRect } : {},
 		...fillImageResourceName && shape.fill.duotone ? { fillImageDuotone: shape.fill.duotone } : {},
@@ -1200,6 +1218,12 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		spacingBeforePt: pp.spacingBefore ?? 0,
 		spacingAfterPt: pp.spacingAfter ?? 0,
 		textLines,
+		...warp && warpInk ? { textWarp: {
+			preset: warp.preset,
+			...warp.adjust !== void 0 ? { adjust: warp.adjust } : {},
+			inkAbovePt: warpInk.above,
+			inkBelowPt: warpInk.below
+		} } : {},
 		...textCharts.size > 0 ? { textCharts } : {},
 		...textShapes.size > 0 ? { textShapes } : {},
 		...textTables.size > 0 ? { textTables } : {},
@@ -1225,11 +1249,11 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 * frame. So one is turned into the other rather than growing a block kind, a
 * pagination arm and an emitter of its own.
 */
-function layoutMetafileBlock(image, pic, options, fontResources, contentWidth, maxHeight, box) {
+function layoutMetafileBlock(image, pic, blitted, options, fontResources, contentWidth, maxHeight, box) {
 	const placed = layoutImageBlock(image, void 0, contentWidth, maxHeight, box);
 	const widthPt = placed.widthPt;
 	const heightPt = placed.heightPt;
-	const layout = rotateDrawing(metafileDrawing(pic, widthPt, heightPt, options, fontResources, image.colorChange), (image.rotation60k ?? 0) / 6e4, widthPt / 2, heightPt / 2);
+	const layout = rotateDrawing(metafileDrawing(pic, widthPt, heightPt, options, fontResources, image.colorChange, blitted), (image.rotation60k ?? 0) / 6e4, widthPt / 2, heightPt / 2);
 	const pp = image.paragraphProperties;
 	return {
 		kind: "chart",
@@ -1293,7 +1317,16 @@ function rotateDrawing(layout, deg, cx, cy) {
 				y: p.y,
 				rotationDeg: (t.rotationDeg ?? 0) - deg
 			};
-		})
+		}),
+		...layout.images ? { images: layout.images.map((img) => {
+			const c = at(img.x + img.width / 2, img.y + img.height / 2);
+			return {
+				...img,
+				x: c.x - img.width / 2,
+				y: c.y - img.height / 2,
+				rotationDeg: (img.rotationDeg ?? 0) + deg
+			};
+		}) } : {}
 	};
 }
 /**
@@ -1301,7 +1334,7 @@ function rotateDrawing(layout, deg, cx, cy) {
 * `heightPt` one and turned y-up about its bottom-left corner — the frame both
 * a chart block and an inline picture token are drawn in.
 */
-function metafileDrawing(pic, widthPt, heightPt, options, fontResources, colorChange) {
+function metafileDrawing(pic, widthPt, heightPt, options, fontResources, colorChange, blitted) {
 	const recolour = (hex) => {
 		if (hex === void 0 || colorChange === void 0) return hex;
 		if (hex.toUpperCase() !== colorChange.fromHex.toUpperCase()) return hex;
@@ -1313,8 +1346,26 @@ function metafileDrawing(pic, widthPt, heightPt, options, fontResources, colorCh
 	const mapY = (y) => heightPt - (y - pic.top) * sy;
 	const shapes = [];
 	const texts = [];
+	const images = [];
 	let seq = 0;
+	let blit = 0;
 	for (const prim of pic.prims) {
+		if (prim.kind === "image") {
+			const resourceName = blitted?.[blit++] ?? "";
+			if (resourceName === "") {
+				seq++;
+				continue;
+			}
+			images.push({
+				seq: seq++,
+				resourceName,
+				x: mapX(prim.x),
+				y: mapY(prim.y + prim.height),
+				width: prim.width * sx,
+				height: prim.height * sy
+			});
+			continue;
+		}
 		if (prim.kind === "path") {
 			const fill = recolour(prim.fillColorHex);
 			const strokeHex = recolour(prim.stroke?.colorHex);
@@ -1349,7 +1400,6 @@ function metafileDrawing(pic, widthPt, heightPt, options, fontResources, colorCh
 			});
 			continue;
 		}
-		if (prim.kind !== "text") continue;
 		const { variant } = options.registry.resolveByStyle(prim.bold === true, prim.italic === true);
 		const font = fontResources.get(variant);
 		if (!font) continue;
@@ -1372,7 +1422,8 @@ function metafileDrawing(pic, widthPt, heightPt, options, fontResources, colorCh
 	}
 	return {
 		shapes,
-		texts
+		texts,
+		...images.length > 0 ? { images } : {}
 	};
 }
 function layoutChartBlock(block, options, fontResources, contentWidth, maxHeight, imageResources) {
@@ -1699,9 +1750,29 @@ function collectImageResources(body, headersFooters, options) {
 		if (!bytes) continue;
 		if (isEmf(bytes) || isWmf(bytes)) {
 			try {
+				const metafile = isEmf(bytes) ? readEmf(bytes) : readWmf(bytes);
+				const metafileImages = [];
+				for (const prim of metafile.prims) {
+					if (prim.kind !== "image") continue;
+					let blitted;
+					try {
+						blitted = prepareImage(prim.png, { flattenAlpha });
+					} catch {
+						metafileImages.push("");
+						continue;
+					}
+					counter++;
+					const name = `Im${counter}`;
+					metafileImages.push(name);
+					out.set(`${resourceId}#${String(metafileImages.length)}`, {
+						resourceName: name,
+						prepared: blitted
+					});
+				}
 				out.set(resourceId, {
 					resourceName: "",
-					metafile: isEmf(bytes) ? readEmf(bytes) : readWmf(bytes)
+					metafile,
+					...metafileImages.length > 0 ? { metafileImages } : {}
 				});
 			} catch {}
 			continue;
@@ -1722,7 +1793,7 @@ function collectImageResources(body, headersFooters, options) {
 }
 function chartPageItems(laid, x, bottomYUp, pageHeight, structId) {
 	const fig = structId !== void 0 ? { structId } : {};
-	const ordered = laid.layout.shapes.some((sh) => sh.seq !== void 0);
+	const ordered = laid.layout.shapes.some((sh) => sh.seq !== void 0) || (laid.layout.images?.length ?? 0) > 0;
 	const picture = ordered ? { pictureId: nextPictureId++ } : {};
 	const backdrop = [];
 	if (laid.background) {
@@ -1791,7 +1862,23 @@ function chartPageItems(laid, x, bottomYUp, pageHeight, structId) {
 		...picture,
 		seq: t.seq ?? Number.MAX_SAFE_INTEGER
 	}));
-	const all = [...shapes, ...texts];
+	const blits = (laid.layout.images ?? []).map((img) => ({
+		type: "image",
+		x: pt(x + img.x),
+		y: pt(pageHeight - (bottomYUp + img.y + img.height)),
+		width: pt(img.width),
+		height: pt(img.height),
+		imageResourceName: img.resourceName,
+		...img.rotationDeg ? { rotationDeg: img.rotationDeg } : {},
+		...fig,
+		...picture,
+		seq: img.seq ?? 0
+	}));
+	const all = [
+		...shapes,
+		...texts,
+		...blits
+	];
 	if (ordered) all.sort((a, b) => a.seq - b.seq);
 	return [...backdrop, ...all.map(({ seq: _seq, ...item }) => item)];
 }
@@ -1819,6 +1906,10 @@ function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
 		}
 		return;
 	}
+	if (sh.textWarp) {
+		emitWarpedText(sh, sh.textWarp, x, bottomYUp, sink, pageHeight, figId);
+		return;
+	}
 	const shapeTop = bottomYUp + sh.heightPt;
 	const innerWidth = Math.max(1, sh.widthPt - sh.insetLeftPt - sh.insetRightPt);
 	let textY;
@@ -1858,6 +1949,65 @@ function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
 		textY -= sh.textLineGaps?.get(i) ?? 0;
 	});
 }
+/**
+* §20.1.9.10 — place a WordArt body's lines in the block's own frame and hand
+* each one the warp that maps that frame onto the shape's box.
+*
+* The block is laid out flat: its lines stack by their own heights, each
+* aligned within the widest of them, and its ink starts at the box's top-left
+* corner. Nothing here bends anything — the emitter does that, glyph by glyph,
+* from the two frames this records.
+*
+* @param sh         The laid-out shape.
+* @param warp       The shape's warp and the block's ink reach.
+* @param x          The shape's left edge on the page.
+* @param bottomYUp  The shape's bottom edge, y-up from the page's bottom.
+* @param sink       Where the line items are pushed.
+* @param pageHeight The page's height, for the y-up ⇄ top-left conversion.
+* @param figId      The tagged-PDF Figure this text belongs to, when it has one.
+*/
+function emitWarpedText(sh, warp, x, bottomYUp, sink, pageHeight, figId) {
+	const boxX = x + sh.insetLeftPt;
+	const boxY = pageHeight - (bottomYUp + sh.heightPt) + sh.insetTopPt;
+	const boxWidth = Math.max(1, sh.widthPt - sh.insetLeftPt - sh.insetRightPt);
+	const boxHeight = Math.max(1, sh.heightPt - sh.insetTopPt - sh.insetBottomPt);
+	const srcWidth = Math.max(1, ...sh.textLines.map((l) => l.contentWidthPt));
+	const baselines = [];
+	let top = 0;
+	sh.textLines.forEach((line, i) => {
+		const h = computeLineHeight(line, line.resolved);
+		baselines.push(top + h - lineBaselineOffset(line, line.resolved));
+		top += h + (sh.textLineGaps?.get(i) ?? 0);
+	});
+	const first = baselines[0] ?? 0;
+	const last = baselines[baselines.length - 1] ?? 0;
+	const srcTop = boxY;
+	const srcHeight = Math.max(1, last - first + warp.inkAbovePt + warp.inkBelowPt);
+	const shift = srcTop + warp.inkAbovePt - first;
+	sh.textLines.forEach((line, i) => {
+		if (sh.textCharts?.has(i) === true || sh.textShapes?.has(i) === true) return;
+		if (sh.textTables?.has(i) === true) return;
+		sink.push({
+			type: "line",
+			line,
+			originX: pt(boxX + alignmentOffset(line.resolved.alignment, line.contentWidthPt, srcWidth)),
+			baselineY: pt(baselines[i] + shift),
+			warp: {
+				preset: warp.preset,
+				...warp.adjust !== void 0 ? { adjust: warp.adjust } : {},
+				boxX: pt(boxX),
+				boxY: pt(boxY),
+				boxWidth: pt(boxWidth),
+				boxHeight: pt(boxHeight),
+				srcX: pt(boxX),
+				srcWidth: pt(srcWidth),
+				srcTop: pt(srcTop),
+				srcHeight: pt(srcHeight)
+			},
+			...figId !== void 0 ? { structId: figId } : {}
+		});
+	});
+}
 /** The page a table is being drawn onto, as a cell's floats need to see it. */
 function cellAnchorCtx(asm) {
 	return {
@@ -1897,6 +2047,19 @@ function emitCellFloat(cf, ctx, frame) {
 	if (float.wrap !== "none") ctx.exclude(float, x, topYUp, cf.block.widthPt, cf.block.heightPt);
 }
 function emitShapeItems(sh, x, bottomYUp, sink, pageHeight, figId) {
+	const castsUnderPicture = sh.fillImageResourceName !== void 0 ? sh.shadow : void 0;
+	const shadowedFill = castsUnderPicture !== void 0;
+	const group = shadowedFill ? { pictureId: nextPictureId++ } : {};
+	if (castsUnderPicture) sink.push({
+		type: "shape",
+		shape: {
+			paths: sh.paths,
+			shadow: castsUnderPicture,
+			transform: flipTransform(buildShapeTransform(x, bottomYUp, sh.widthPt, sh.heightPt, sh.rotation60k, sh.flipH, sh.flipV), pageHeight)
+		},
+		...group,
+		...figId !== void 0 ? { structId: figId } : {}
+	});
 	if (sh.fillImageResourceName) {
 		const clip = {
 			paths: sh.paths,
@@ -1909,12 +2072,13 @@ function emitShapeItems(sh, x, bottomYUp, sink, pageHeight, figId) {
 			y: pageHeight - (bottomYUp + sh.heightPt),
 			width: sh.widthPt,
 			height: sh.heightPt
-		})) {
+		}, sh.fillImageTileFromCentre === true)) {
 			if (item.type !== "image") continue;
 			sink.push({
 				...item,
 				clip,
 				...fig,
+				...group,
 				...sh.fillAlpha !== void 0 ? { alpha: sh.fillAlpha } : {}
 			});
 		}
@@ -1935,7 +2099,8 @@ function emitShapeItems(sh, x, bottomYUp, sink, pageHeight, figId) {
 				...sh.fillAlpha !== void 0 ? { alpha: sh.fillAlpha } : {},
 				...sh.fillImageDuotone ? { duotone: sh.fillImageDuotone } : {},
 				clip,
-				...fig
+				...fig,
+				...group
 			});
 		}
 	}
@@ -1956,9 +2121,10 @@ function emitShapeItems(sh, x, bottomYUp, sink, pageHeight, figId) {
 			...sh.fillGradient ? { fillGradient: sh.fillGradient } : {},
 			...sh.fillAlpha !== void 0 ? { fillAlpha: sh.fillAlpha } : {},
 			...sh.stroke ? { stroke: sh.stroke } : {},
-			...sh.shadow ? { shadow: sh.shadow } : {},
+			...sh.shadow && !shadowedFill ? { shadow: sh.shadow } : {},
 			transform: flipTransform(buildShapeTransform(x, bottomYUp, sh.widthPt, sh.heightPt, sh.rotation60k, sh.flipH, sh.flipV), pageHeight)
 		},
+		...group,
 		...figId !== void 0 ? { structId: figId } : {}
 	});
 	for (const child of sh.children ?? []) emitShapeItems(child.laid, x + child.xPt, bottomYUp + sh.heightPt - child.yPt - child.laid.heightPt, sink, pageHeight, figId);
@@ -2173,24 +2339,197 @@ function runFontKeyAndParsed(options, ascii, bold, italic) {
 	}
 	const byFamily = options.registriesByFamily;
 	if (byFamily && byFamily.size > 0) {
-		let key = resolveFamilyKey(ascii);
+		const named = resolveFamilyStyle(ascii);
+		let key = named.key;
 		let reg = byFamily.get(key);
 		if (!reg) {
 			key = byFamily.keys().next().value;
 			reg = byFamily.get(key);
 		}
-		const { variant, parsed } = reg.resolveByStyle(bold, italic);
+		const wantBold = bold || named.bold === true;
+		const wantItalic = italic || named.italic === true;
+		const { variant, parsed } = reg.resolveByStyle(wantBold, wantItalic);
 		return {
 			fontKey: `${key}:${variant}`,
-			parsed
+			parsed,
+			...syntheticFace(variant, wantBold, wantItalic, named.widthScale)
 		};
 	}
 	const { variant, parsed } = options.registry.resolveByStyle(bold, italic);
 	return {
 		fontKey: variant,
-		parsed
+		parsed,
+		...syntheticFace(variant, bold, italic, resolveFamilyStyle(ascii).widthScale)
+	};
+}
+/**
+* The face a CHARACTER falls back to when the run's own has no glyph for it.
+*
+* The curated substitutes are Latin families: Han, Kana, Hangul, Arabic, Thai
+* and the geometric symbols are a notdef box in every one of them, and 2145
+* characters of the corpus are exactly those. A face for the character's
+* writing system is fetched when the document holds one (see `addScriptFonts`),
+* and this is where a run reaches it — followed by every other family already
+* loaded, because a glyph one of them happens to carry is still better than a
+* box.
+*
+* Called from BOTH walks that need it — the glyph-subset collection and the
+* tokenizer — so the face a character is measured, subset and drawn with is one
+* decision made once.
+*
+* @param options The render options (the loaded registries).
+* @param cp      The code point with no glyph in the run's own face.
+* @param bold    Whether the run is bold…
+* @param italic  …and whether it is italic.
+* @returns The face to draw it with, or `undefined` when nobody has it.
+*/
+function fallbackFaceKey(options, cp, bold, italic) {
+	const byFamily = options.registriesByFamily;
+	if (!byFamily || byFamily.size === 0) return void 0;
+	const script = scriptForCodepoint(cp, byFamily.has("jp") ? "jp" : byFamily.has("kr") ? "kr" : "sc");
+	const order = script ? [script] : [];
+	for (const key of byFamily.keys()) if (key !== script) order.push(key);
+	for (const key of order) {
+		const reg = byFamily.get(key);
+		if (!reg) continue;
+		const { variant, parsed } = reg.resolveByStyle(bold, italic);
+		if (parsed.glyphForCodepoint(cp) !== 0) return {
+			fontKey: `${key}:${variant}`,
+			parsed
+		};
+	}
+}
+/**
+* §9.2.2 — the face a request had to settle for, and what is left to draw.
+*
+* A registry may hold one face and be asked for four: `FontBytesByVariant`
+* requires only `regular`, so a caller who supplies a single file (or a script
+* fallback with no bold cut) had every heading drawn plain. What the file does
+* not carry, the page draws: a stroke around the glyphs for weight, a shear for
+* slant — the same two tricks a word processor calls faux bold and faux italic.
+*
+* @param variant    The face the registry actually gave.
+* @param bold       Whether bold was asked for.
+* @param italic     Whether italic was.
+* @param widthScale The squeeze a condensed NAME asks for, when it does.
+* @returns `{ synthetic }` when something is missing, `{}` when nothing is.
+*/
+function syntheticFace(variant, bold, italic, widthScale) {
+	const missingBold = bold && variant !== "bold" && variant !== "boldItalic";
+	const missingItalic = italic && variant !== "italic" && variant !== "boldItalic";
+	if (!missingBold && !missingItalic && widthScale === void 0) return {};
+	return { synthetic: {
+		...missingBold ? { bold: true } : {},
+		...missingItalic ? { italic: true } : {},
+		...widthScale !== void 0 ? { widthScale } : {}
+	} };
+}
+/**
+* `text` cut into the stretches ONE face draws — the whole string as a single
+* piece when the run's own face covers it, which is nearly always.
+*
+* @param plan The run being tokenized.
+* @param text The stretch of it to cut.
+*/
+function splitByFace(plan, text) {
+	const first = faceOf(plan, text.codePointAt(0) ?? 0);
+	if (!plan.faceFor || plan.faceFor.size === 0) return [{
+		text,
+		face: first
+	}];
+	const out = [];
+	let buf = "";
+	let face = first;
+	for (const ch of text) {
+		const next = faceOf(plan, ch.codePointAt(0));
+		if (buf !== "" && next.font !== face.font) {
+			out.push({
+				text: buf,
+				face
+			});
+			buf = "";
+		}
+		face = next;
+		buf += ch;
+	}
+	if (buf !== "") out.push({
+		text: buf,
+		face
+	});
+	return out;
+}
+/**
+* The face a character of a run is drawn with — its own, unless the run carries
+* a fallback for that code point (see {@link facesForRun}).
+*/
+function faceOf(plan, cp) {
+	return plan.faceFor?.get(cp) ?? {
+		font: plan.font,
+		...plan.synthetic ? { synthetic: plan.synthetic } : {}
 	};
 }
+/**
+* `text` cut into the stretches ONE face draws, by the same decision the
+* tokenizer makes — the whole string as a single span when the run's own face
+* covers it, which is nearly always.
+*
+* @param options  The render options (the loaded registries).
+* @param primary  The run's own face.
+* @param resolved Its resolved properties (weight and slant).
+* @param text     The run's text.
+*/
+function faceSpans(options, primary, resolved, text) {
+	const out = [];
+	let cur = primary;
+	let buf = "";
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		const face = primary.parsed.glyphForCodepoint(cp) !== 0 ? primary : fallbackFaceKey(options, cp, resolved.bold, resolved.italic) ?? primary;
+		if (buf !== "" && face.fontKey !== cur.fontKey) {
+			out.push({
+				...cur,
+				text: buf
+			});
+			buf = "";
+		}
+		cur = face;
+		buf += ch;
+	}
+	if (buf !== "") out.push({
+		...cur,
+		text: buf
+	});
+	return out;
+}
+/**
+* The face for every character of `text` the run's own cannot draw.
+*
+* @param options       The render options (the loaded registries).
+* @param fontResources The faces the document embeds, by key.
+* @param primary       The run's own face.
+* @param resolved      Its resolved properties (weight and slant).
+* @param text          The run's text.
+* @returns A map from code point to face, or `undefined` when the run's own
+*          face draws all of it.
+*/
+function facesForRun(options, fontResources, primary, resolved, text) {
+	let out;
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (out?.has(cp) === true || primary.glyphForCodepoint(cp) !== 0) continue;
+		const fallback = fallbackFaceKey(options, cp, resolved.bold, resolved.italic);
+		if (!fallback) continue;
+		const font = fontResources.get(fallback.fontKey);
+		if (!font) continue;
+		out ??= /* @__PURE__ */ new Map();
+		const { variant } = { variant: fallback.fontKey.split(":")[1] ?? "" };
+		out.set(cp, {
+			font,
+			...syntheticFace(variant === "bold" || variant === "boldItalic" || variant === "italic" ? variant : "regular", resolved.bold, resolved.italic)
+		});
+	}
+	return out;
+}
 function lookupFont(resources, fontKey) {
 	return resources.get(fontKey) ?? resources.values().next().value;
 }
@@ -2207,8 +2546,22 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 			};
 			used.set(fontKey, bucket);
 		}
-		const shaped = shapeText(run.listMarker === true ? markerText(run.text, parsed) : run.text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
-		for (const g of shaped.gids) bucket.gids.add(g);
+		const text = run.listMarker === true ? markerText(run.text, parsed) : run.text;
+		for (const span of faceSpans(options, {
+			fontKey,
+			parsed
+		}, resolved, text)) {
+			let sink = used.get(span.fontKey);
+			if (!sink) {
+				sink = {
+					parsed: span.parsed,
+					gids: /* @__PURE__ */ new Set()
+				};
+				used.set(span.fontKey, sink);
+			}
+			const shaped = shapeText(span.text, span.parsed.glyphForCodepoint, span.parsed.advanceWidths, span.parsed.ligatures, span.parsed.kerning, span.parsed.joiningForms);
+			for (const g of shaped.gids) sink.gids.add(g);
+		}
 		if (run.text.includes("	")) for (const stop of resolveParagraphProperties(para.properties, options.styles).tabs) {
 			const ch = stop.leader === void 0 ? void 0 : TAB_LEADER_CHARS.get(stop.leader);
 			if (ch !== void 0) bucket.gids.add(parsed.glyphForCodepoint(ch.codePointAt(0)));
@@ -2578,7 +2931,7 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 				imageWidthPt: widthPt,
 				imageHeightPt: heightPt,
 				imageResourceName: res?.resourceName ?? "",
-				...res?.metafile ? { imageMetafile: metafileDrawing(res.metafile, drawBox?.widthPt ?? widthPt, drawBox?.heightPt ?? heightPt, options, fontResources) } : {},
+				...res?.metafile ? { imageMetafile: metafileDrawing(res.metafile, drawBox?.widthPt ?? widthPt, drawBox?.heightPt ?? heightPt, options, fontResources, void 0, res.metafileImages) } : {},
 				...run.inlineImage.outline ? { imageOutline: run.inlineImage.outline } : {},
 				...run.inlineImage.shadow ? { imageShadow: run.inlineImage.shadow } : {},
 				...run.inlineImage.wash ? { imageWash: run.inlineImage.wash } : {},
@@ -2618,12 +2971,16 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 			};
 		}
 		const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
-		const { fontKey } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
+		const { fontKey, synthetic } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
 		const script = SCRIPT_OFFSET[resolvedRun.verticalAlign] ?? 0;
+		const own = lookupFont(fontResources, fontKey);
+		const faceFor = facesForRun(options, fontResources, own.parsed, resolvedRun, run.text);
 		return {
 			run,
 			resolvedRun,
-			font: lookupFont(fontResources, fontKey),
+			font: own,
+			...faceFor ? { faceFor } : {},
+			...synthetic ? { synthetic } : {},
 			fontSizePt: script === 0 ? resolvedRun.fontSizePt : resolvedRun.fontSizePt * SCRIPT_SCALE,
 			...script === 0 ? {} : { risePt: resolvedRun.fontSizePt * script },
 			isImage: false,
@@ -2690,8 +3047,8 @@ function tokenizePlansLtr(plans) {
 			continue;
 		}
 		const highlight = (plan.run.commentRangeRefs?.length ?? 0) > 0;
-		for (const t of tokenizeText(plan.run.text)) {
-			const text = plan.run.listMarker === true ? markerText(t.text, plan.font.parsed) : t.text;
+		for (const t of tokenizeText(plan.run.text)) for (const piece of splitByFace(plan, t.text)) {
+			const text = plan.run.listMarker === true ? markerText(piece.text, plan.font.parsed) : piece.text;
 			tokens.push({
 				kind: "text",
 				text,
@@ -2704,10 +3061,11 @@ function tokenizePlansLtr(plans) {
 				...plan.run.columnBreak ? { columnBreak: true } : {},
 				...highlight ? { highlight: true } : {},
 				resolvedRun: plan.resolvedRun,
-				font: plan.font,
+				font: piece.face.font,
+				...piece.face.synthetic ? { synthetic: piece.face.synthetic } : {},
 				fontSizePt: plan.fontSizePt,
 				...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
-				widthPt: measureRunText(plan, text),
+				widthPt: measureRunText(plan, text, piece.face),
 				bidiLevel: 0
 			});
 		}
@@ -2747,8 +3105,12 @@ function markerText(text, parsed) {
 * @param text The token's text.
 * @returns The advance width in points.
 */
-function measureRunText(plan, text) {
-	const base = plan.font.measure.textWidthPt(text, plan.fontSizePt);
+function measureRunText(plan, text, face) {
+	const drawn = face ?? {
+		font: plan.font,
+		...plan.synthetic ? { synthetic: plan.synthetic } : {}
+	};
+	const base = drawn.font.measure.textWidthPt(text, plan.fontSizePt) * (drawn.synthetic?.widthScale ?? 1);
 	const extra = plan.resolvedRun.letterSpacingPt;
 	return extra === void 0 || extra === 0 ? base : base + extra * [...text].length;
 }
@@ -2795,6 +3157,7 @@ function tokenizePlansBidi(plans, realLevels) {
 		let bufStart = 0;
 		let curSpace = false;
 		let curLevel = -1;
+		let curFace = { font: plan.font };
 		const flush = (endExclusive) => {
 			if (endExclusive <= bufStart) return;
 			const raw = chars.slice(bufStart, endExclusive).join("");
@@ -2810,10 +3173,11 @@ function tokenizePlansBidi(plans, realLevels) {
 				...plan.run.columnBreak ? { columnBreak: true } : {},
 				...(plan.run.commentRangeRefs?.length ?? 0) > 0 ? { highlight: true } : {},
 				resolvedRun: plan.resolvedRun,
-				font: plan.font,
+				font: curFace.font,
+				...curFace.synthetic ? { synthetic: curFace.synthetic } : {},
 				fontSizePt: plan.fontSizePt,
 				...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
-				widthPt: measureRunText(plan, text),
+				widthPt: measureRunText(plan, text, curFace),
 				bidiLevel: curLevel
 			});
 		};
@@ -2821,14 +3185,17 @@ function tokenizePlansBidi(plans, realLevels) {
 			const ch = chars[c];
 			const isSpace = /\s/.test(ch);
 			const level = realLevels[realIdx] ?? 0;
+			const face = faceOf(plan, ch.codePointAt(0));
 			if (c === 0) {
 				curSpace = isSpace;
 				curLevel = level;
-			} else if (isSpace !== curSpace || level !== curLevel) {
+				curFace = face;
+			} else if (isSpace !== curSpace || level !== curLevel || face.font !== curFace.font) {
 				flush(c);
 				bufStart = c;
 				curSpace = isSpace;
 				curLevel = level;
+				curFace = face;
 			}
 			realIdx++;
 		}
@@ -3381,6 +3748,30 @@ function alignmentOffset(alignment, lineWidth, available) {
 	return 0;
 }
 /**
+* How far a line's INK reaches either side of its baseline — the union of its
+* glyphs' own bounding boxes, not the line box its font metrics describe. Only
+* WordArt needs this: it stretches the marks it draws onto its shape, and the
+* empty band an ascender or descender reserves is not one of them.
+*
+* @param line The laid-out line.
+* @returns Points above the baseline the ink rises, and below it that it drops.
+*/
+function lineInk(line) {
+	let above = 0;
+	let below = 0;
+	for (const tok of line.tokens) {
+		if (tok.kind !== "text" || tok.isSpace) continue;
+		const ink = tok.font.measure.textInkPt(tok.text, tok.fontSizePt);
+		const rise = tok.risePt ?? 0;
+		above = Math.max(above, ink.above + rise);
+		below = Math.max(below, ink.below - rise);
+	}
+	return {
+		above,
+		below
+	};
+}
+/**
 * §17.4.85 `w:vMerge` — a vertical merge is ONE cell, so its continuation rows
 * are painted with the START cell's shading. Word writes the fill on the cell
 * that opens the merge and nothing on the rest; painting only what is written,
@@ -3656,10 +4047,10 @@ 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 { 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);
+		total += font.measure.textWidthPt(run.text, fontSizePt) * (synthetic?.widthScale ?? 1);
 	}
 	return total;
 }
@@ -3800,7 +4191,9 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	const padRightBase = cellMar?.right ?? tableMar?.right ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
 	const padLeftPt = padLeftBase + (cell.properties.icon ? CF_ICON_GUTTER_PT : 0);
 	const padRightPt = padRightBase;
+	const turned = mergeRole === "middle" || mergeRole === "end" ? void 0 : cell.properties.textDirection;
 	const innerWidth = Math.max(1, widthPt - padLeftPt - padRightPt);
+	const measureWidth = turned ? NO_WRAP_MEASURE_WIDTH : innerWidth;
 	const lines = [];
 	const nestedTables = [];
 	const cellShapes = [];
@@ -3819,7 +4212,7 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	if (mergeRole !== "middle" && mergeRole !== "end") {
 		for (const el of cell.content) if (el.kind === "paragraph") {
 			const noWrap = cell.properties.noWrap === true;
-			const block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, noWrap ? NO_WRAP_MEASURE_WIDTH : innerWidth);
+			const block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, noWrap ? NO_WRAP_MEASURE_WIDTH : measureWidth);
 			const cutAt = widthPt - padLeftPt;
 			if (noWrap && (block.lines[0]?.contentWidthPt ?? 0) > cutAt) clipped = true;
 			const keep = noWrap ? clipLineToWidth(block.lines, cutAt, cell.properties.hashOnOverflow === true) : block.lines;
@@ -3870,7 +4263,9 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	}
 	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;
+	const alongPt = turned ? lines.reduce((a, l) => Math.max(a, l.contentWidthPt), 0) : 0;
+	const heightPt = turned ? alongPt : contentHeightPt;
+	const totalHeightPt = mergeRole === "middle" || mergeRole === "end" ? 0 : padTopPt + heightPt + padBottomPt;
 	return {
 		widthPt,
 		padTopPt,
@@ -3887,8 +4282,9 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 		...nestedTables.length > 0 ? { nestedTables } : {},
 		...cellShapes.length > 0 ? { shapes: cellShapes } : {},
 		...cellFloats.length > 0 ? { floats: cellFloats } : {},
-		contentHeightPt,
+		contentHeightPt: heightPt,
 		totalHeightPt,
+		...turned ? { textDirection: turned } : {},
 		...cell.properties.verticalAlign ? { verticalAlign: cell.properties.verticalAlign } : {},
 		colStart,
 		colSpan,
@@ -4541,16 +4937,24 @@ var PageAssembler = class PageAssembler {
 	* one: stretched over the page it is a blur, and its 128 pixels are 96 points
 	* at the resolution Office measures a picture in.
 	*/
-	static tileItems = (resourceName, natural, box) => {
+	static tileItems = (resourceName, natural, box, fromCentre = false) => {
 		const tw = Math.max(1, natural.widthPt);
 		const th = Math.max(1, natural.heightPt);
-		const cols = Math.min(200, Math.ceil(box.width / tw));
-		const rows = Math.min(200, Math.ceil(box.height / th));
+		const first = (start, span, step) => {
+			if (!fromCentre) return start;
+			let at = start + span / 2 - step / 2;
+			while (at > start) at -= step;
+			return at;
+		};
+		const x0 = first(box.x, box.width, tw);
+		const y0 = first(box.y, box.height, th);
+		const cols = Math.min(200, Math.max(1, Math.ceil((box.x + box.width - x0) / tw)));
+		const rows = Math.min(200, Math.max(1, Math.ceil((box.y + box.height - y0) / th)));
 		const out = [];
 		for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) out.push({
 			type: "image",
-			x: pt(box.x + c * tw),
-			y: pt(box.y + r * th),
+			x: pt(x0 + c * tw),
+			y: pt(y0 + r * th),
 			width: pt(tw),
 			height: pt(th),
 			imageResourceName: resourceName
@@ -4925,7 +5329,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				const chunks = !row.cantSplit && row.heightPt > room && asm.colHasContent() && room > 0 ? splitRowIntoChunks(row, room, page) : row.heightPt > page ? splitRowIntoChunks(row, page) : [row];
 				for (let ci = 0; ci < chunks.length; ci++) {
 					const chunk = chunks[ci];
-					const forcedBreak = ci === 0 && row.breakBefore && !isLeadingHeader && asm.current.length > 0;
+					const forcedBreak = ci === 0 && row.breakBefore && !isLeadingHeader && asm.pageHasContent();
 					const overflow = asm.cursorY - chunk.heightPt < asm.bottomLimit() && asm.colHasContent();
 					if (forcedBreak || overflow) {
 						if (forcedBreak) asm.flushPage();
@@ -5218,6 +5622,29 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 				});
 			}
 		};
+		if (cell.textDirection !== void 0) {
+			const up = cell.textDirection === "vert270";
+			const along = Math.max(1, boxHeightPt - cell.padTopPt - cell.padBottomPt);
+			const cellBottomYUp = rowTop - boxHeightPt;
+			let across = cell.padLeftPt;
+			for (const line of cell.lines) {
+				const h = computeLineHeight(line, line.resolved);
+				const lineOffset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, along);
+				const off = lineBaselineOffset(line, line.resolved);
+				const baselineAcross = up ? across + h - off : across + off;
+				out.push({
+					type: "line",
+					line,
+					originX: pt(up ? cellX + baselineAcross : cellX + cell.widthPt - baselineAcross),
+					baselineY: pt(pageHeight - (up ? cellBottomYUp + cell.padBottomPt + lineOffset : rowTop - cell.padTopPt - lineOffset)),
+					rotationDeg: up ? 90 : -90,
+					...structId !== void 0 ? { structId } : {}
+				});
+				across += h;
+			}
+			drawNestedBefore(cell.lines.length);
+			continue;
+		}
 		for (const [lineIdx, line] of cell.lines.entries()) {
 			drawNestedBefore(lineIdx);
 			textY -= cell.lineGaps?.get(lineIdx) ?? 0;