reamkit 1.22.0 → 1.23.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 / 96 * (shape.fill.tileScale?.sx ?? 1),
+		heightPt: fillImage.prepared.heightPx * 72 / 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);
@@ -1225,11 +1227,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 +1295,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 +1312,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 +1324,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 +1378,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 +1400,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 +1728,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 +1771,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 +1840,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)];
 }
@@ -2173,24 +2238,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 +2445,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 +2830,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 +2870,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 +2946,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 +2960,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 +3004,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 +3056,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 +3072,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 +3084,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++;
 		}
@@ -3656,10 +3922,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;
 }

package/dist/esm/pdf/styled-page-emitter.js

@@ -621,6 +621,7 @@ var BORDER_DASHES = new Map([
 		2.5
 	]]
 ]);
+var FAUX_ITALIC_SHEAR = .2126;
 /** The PDF dash array for a border style; an empty string means a solid rule. */
 function dashPatternFor(style) {
 	const pattern = style !== void 0 ? BORDER_DASHES.get(style) : void 0;
@@ -642,6 +643,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 	let lastTc = 0;
 	let lastSize = -1;
 	let lastColor = "";
+	let lastFauxWidth = 0;
+	let lastTz = 100;
 	const switchFontIfNeeded = (tok) => {
 		const fontKey = tok.font.resourceName;
 		if (fontKey !== lastFont || tok.fontSizePt !== lastSize) {
@@ -649,6 +652,16 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			lastFont = fontKey;
 			lastSize = tok.fontSizePt;
 		}
+		const fauxWidth = tok.synthetic?.bold === true ? tok.fontSizePt * .03 : 0;
+		if (fauxWidth !== lastFauxWidth) {
+			out.push(fauxWidth > 0 ? `2 Tr ${formatNumber(fauxWidth)} w` : "0 Tr");
+			lastFauxWidth = fauxWidth;
+		}
+		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * 100);
+		if (tz !== lastTz) {
+			out.push(`${formatNumber(tz)} Tz`);
+			lastTz = tz;
+		}
 		const tc = tok.resolvedRun.letterSpacingPt ?? 0;
 		if (tc !== lastTc) {
 			out.push(`${formatNumber(tc)} Tc`);
@@ -670,6 +683,12 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			const b = tok.drawBox;
 			const ox = x + (b?.dxPt ?? 0);
 			const oy = baselineY + (b?.dyPt ?? 0);
+			for (const img of meta.images ?? []) {
+				if (img.resourceName === "") continue;
+				out.push("q");
+				out.push(...placeImage(ox + img.x, oy + img.y, img.width, img.height, void 0, img.rotationDeg));
+				out.push(`/${img.resourceName} Do`, "Q");
+			}
 			for (const sh of meta.shapes) for (const op of emitVectorShape({
 				...sh,
 				transform: [
@@ -693,6 +712,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 				out.push("ET");
 			}
 			lastFont = "";
+			lastFauxWidth = 0;
+			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
 			return;
@@ -739,6 +760,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push("Q");
 		}
 		lastFont = "";
+		lastFauxWidth = 0;
+		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
 		lastTc = 0;
@@ -771,6 +794,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push("f");
 			out.push("Q");
 			lastFont = "";
+			lastFauxWidth = 0;
+			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
 		} else {
@@ -796,6 +821,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			};
 			for (const op of emitVectorShape(shape)) out.push(op);
 			lastFont = "";
+			lastFauxWidth = 0;
+			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
 		}
@@ -813,6 +840,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		out.push("q");
 		out.push(`${formatNumber(clip.x)} ${formatNumber(H - clip.y - clip.height)} ${formatNumber(clip.width)} ${formatNumber(clip.height)} re W n`);
 		lastFont = "";
+		lastFauxWidth = 0;
+		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
 		lastTc = 0;
@@ -825,6 +854,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		}
 		out.push("Q");
 		lastFont = "";
+		lastFauxWidth = 0;
+		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
 		lastTc = 0;
@@ -977,6 +1008,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push("Q");
 		}
 		const hasRise = line.tokens.some((t) => t.kind === "text" && t.risePt !== void 0);
+		const hasFauxItalic = line.tokens.some((t) => t.kind === "text" && t.synthetic?.italic === true);
 		if (rotationDeg !== 0 && !hasImageToken && !hasMathToken) {
 			if (!inBT) {
 				out.push("BT");
@@ -991,7 +1023,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 				switchFontIfNeeded(tok);
 				out.push(tok.font.measure.showText(tok.text));
 			}
-		} else if (extraPerSpace !== 0 || hasImageToken || hasMathToken || hasRtl || hasRise || hasTab) {
+		} else if (extraPerSpace !== 0 || hasImageToken || hasMathToken || hasRtl || hasRise || hasFauxItalic || hasTab) {
 			const order = hasRtl ? lineVisualOrder(line) : line.tokens.map((_, i) => i);
 			let x = originX;
 			for (const ti of order) {
@@ -1013,7 +1045,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 					inBT = true;
 				}
 				switchFontIfNeeded(tok);
-				out.push(`1 0 0 1 ${formatNumber(x)} ${formatNumber(baselineY + (tok.risePt ?? 0))} Tm`);
+				const slant = tok.synthetic?.italic === true ? FAUX_ITALIC_SHEAR : 0;
+				out.push(`1 0 ${formatNumber(slant)} 1 ${formatNumber(x)} ${formatNumber(baselineY + (tok.risePt ?? 0))} Tm`);
 				out.push(showToken(tok));
 				const tokenX0 = x;
 				x += tok.widthPt;

package/dist/esm/pdf-reader/image-decode.js

@@ -1,8 +1,8 @@
 import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
 import { lzwDecodeMsb } from "../core/lzw.js";
+import { encodePng } from "../core/png-encode.js";
 import { reversePredictor } from "./predictor.js";
 import { decodeCcitt } from "./ccitt.js";
-import { encodePng } from "./png-encode.js";
 import { unzlibSync } from "fflate";
 //#region src/pdf-reader/image-decode.ts
 var MAX_PIXELS = 4e7;