reamkit 1.23.0 → 1.24.0

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

@@ -1030,8 +1030,8 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 	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 ? 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)
+		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);
@@ -1049,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;
@@ -1143,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);
@@ -1166,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;
@@ -1187,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 } : {},
@@ -1202,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 } : {},
@@ -1884,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;
@@ -1923,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 {
@@ -1962,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,
@@ -1974,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 } : {}
 			});
 		}
@@ -2000,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
 			});
 		}
 	}
@@ -2021,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);
@@ -3647,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,
@@ -4066,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 = [];
@@ -4085,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;
@@ -4136,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,
@@ -4153,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,
@@ -4807,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
@@ -5191,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();
@@ -5484,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;

package/dist/esm/pdf/shading.js

@@ -284,14 +284,16 @@ function normalizeStops(stops) {
 		colorHex: "000000",
 		alpha: 1
 	}];
-	out[0] = {
-		...out[0],
+	const first = out[0];
+	if (first.offset > 0) out.unshift({
+		...first,
 		offset: 0
-	};
-	out[out.length - 1] = {
-		...out[out.length - 1],
+	});
+	const last = out[out.length - 1];
+	if (last.offset < 1) out.push({
+		...last,
 		offset: 1
-	};
+	});
 	return out;
 }
 function rgb01(hex) {

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

@@ -7,6 +7,7 @@ import { GLUE_SHRINK_RATIO } from "../layout/styled-layout.js";
 import { paintPlan } from "../layout/page-doc.js";
 import { emitClipPath, emitVectorShape, shadowBlurLayers } from "./vector-graphics.js";
 import { buildGradientAlphaMask, buildGradientPattern, shapeBbox } from "./shading.js";
+import { warpGlyphMatrix } from "../core/drawingml/text-warp.js";
 import { sanitizeHref } from "../core/links.js";
 import { embedAssociatedFile } from "./embedded-file.js";
 import { buildSrgbIccProfile } from "./icc-profile.js";
@@ -111,7 +112,11 @@ function assembleStyledPdf(laid, options, doc) {
 	if (!pdfaProfile) for (const page of renderedPages) {
 		const ph = page.height;
 		const plan = paintPlan(page.commands);
-		const shapesNeedingPatterns = [...plan.shapes, ...[...plan.behind, ...plan.pictures.flat()].filter((i) => i.type === "shape")];
+		const shapesNeedingPatterns = [...plan.shapes, ...[
+			...plan.behind,
+			...plan.pictures.flat(),
+			...plan.ordered.flat()
+		].filter((i) => i.type === "shape")];
 		for (const item of shapesNeedingPatterns) {
 			const gradient = item.shape.fillGradient;
 			if (!gradient) continue;
@@ -211,7 +216,11 @@ function assembleStyledPdf(laid, options, doc) {
 			wantAlpha(img.alpha);
 			wantDuotone(img, page.height);
 		}
-		for (const item of [...plan.behind, ...plan.pictures.flat()]) {
+		for (const item of [
+			...plan.behind,
+			...plan.pictures.flat(),
+			...plan.ordered.flat()
+		]) {
 			if (item.type === "image") {
 				wantAlpha(washVeil(item.wash)?.alpha);
 				wantAlpha(item.alpha);
@@ -1009,6 +1018,34 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		}
 		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);
+		const warp = cmd.warp;
+		if (warp) {
+			if (!inBT) {
+				out.push("BT");
+				inBT = true;
+			}
+			let cursor = originX;
+			for (const tok of line.tokens) {
+				if (tok.kind !== "text" || tok.isSpace) {
+					cursor += tok.widthPt;
+					continue;
+				}
+				switchFontIfNeeded(tok);
+				const chars = [...tok.text];
+				const raw = chars.map((c) => tok.font.measure.textWidthPt(c, tok.fontSizePt));
+				const total = raw.reduce((a, b) => a + b, 0);
+				const k = total > 0 ? tok.widthPt / total : 1;
+				for (let i = 0; i < chars.length; i++) {
+					const adv = raw[i] * k;
+					const m = warpGlyphMatrix(warp, cursor, adv, cmd.baselineY);
+					cursor += adv;
+					if (!m) continue;
+					out.push(`${formatNumber(m[0])} ${formatNumber(-m[1])} ${formatNumber(m[2])} ${formatNumber(-m[3])} ${formatNumber(m[4])} ${formatNumber(H - m[5])} Tm`);
+					out.push(tok.font.measure.showText(chars[i]));
+				}
+			}
+			return;
+		}
 		if (rotationDeg !== 0 && !hasImageToken && !hasMathToken) {
 			if (!inBT) {
 				out.push("BT");
@@ -1104,6 +1141,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		if (item.type === "shape") {
 			const t = item.shape.transform;
 			const fillAlpha = item.shape.fillAlpha;
+			const layer = item.shape.shadow ? shadowBlurLayers(item.shape.shadow) : void 0;
 			for (const op of emitVectorShape({
 				...item.shape,
 				transform: [
@@ -1114,7 +1152,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 					t[4],
 					H - t[5]
 				]
-			}, gradientNames?.get(item.shape), void 0, gradientMaskNames?.get(item.shape) ?? (fillAlpha !== void 0 && fillAlpha < 1 ? alphaStateNames?.get(Math.round(fillAlpha * 1e3) / 1e3) : void 0))) out.push(op);
+			}, gradientNames?.get(item.shape), layer && layer.alpha < 1 ? alphaStateNames?.get(Math.round(layer.alpha * 1e3) / 1e3) : void 0, gradientMaskNames?.get(item.shape) ?? (fillAlpha !== void 0 && fillAlpha < 1 ? alphaStateNames?.get(Math.round(fillAlpha * 1e3) / 1e3) : void 0))) out.push(op);
 			return;
 		}
 		if (item.type === "image") {
@@ -1287,6 +1325,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		for (const item of run) emitInOrder(item);
 		if (tagging) out.push("EMC");
 	}
+	for (const run of plan.ordered) for (const item of run) emitInOrder(item);
 	emitLinesPass();
 	return {
 		content: encoder.encode(out.join("\n")),

package/dist/esm/pdf/vector-graphics.js

@@ -31,7 +31,7 @@ function shadowBlurLayers(shadow) {
 	const count = Math.min(8, Math.max(2, Math.round(shadow.blurPt / 2)));
 	return {
 		count,
-		alpha: shadow.alpha / count
+		alpha: 1 - Math.pow(1 - shadow.alpha, 1 / count)
 	};
 }
 function shadowBbox(shape) {

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

@@ -1,6 +1,6 @@
 import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
-import { lzwDecodeMsb } from "../core/lzw.js";
 import { encodePng } from "../core/png-encode.js";
+import { lzwDecodeMsb } from "../core/lzw.js";
 import { reversePredictor } from "./predictor.js";
 import { decodeCcitt } from "./ccitt.js";
 import { unzlibSync } from "fflate";

package/dist/esm/pptx/ppt/ppt-reader.js

@@ -1,6 +1,7 @@
 import { pt } from "../../core/ir/units.js";
 import { ResourceStore } from "../../core/ir/resources.js";
 import { FEATURES } from "../../core/ir/features.js";
+import { knockOutColor } from "../../core/images.js";
 import { isEmf } from "../../core/metafile/emf.js";
 import { isWmf } from "../../core/metafile/wmf.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../../core/style-cascade/resolver.js";
@@ -136,8 +137,9 @@ function bulletedRuns(para) {
 	const runs = para.runs.map(toRun);
 	if (para.bullet === void 0) return runs;
 	const { bold: _b, italic: _i, ...rest } = runs[0]?.properties ?? {};
+	const gap = hangs(para) ? "	" : " ";
 	return [{
-		text: `${para.bullet} `,
+		text: `${para.bullet}${gap}`,
 		properties: rest
 	}, ...runs];
 }
@@ -175,16 +177,13 @@ function backdropFill(bg, resources) {
 	if (bg.image) return {
 		kind: "picture",
 		imageResource: resources.put(bg.image.bytes),
-		...bg.imageTiled ? { tiled: true } : {}
+		...bg.imageTiled ? {
+			tiled: true,
+			tileFromCentre: true
+		} : {}
 	};
 	if (bg.gradient) {
-		const stops = [{
-			offset: 0,
-			colorHex: bg.gradient.fromHex
-		}, {
-			offset: 1,
-			colorHex: bg.gradient.toHex
-		}];
+		const stops = gradientStops(bg.gradient);
 		return {
 			kind: "gradient",
 			gradient: bg.gradient.radial ? {
@@ -242,9 +241,10 @@ function positionedImage(rect, image, resources) {
 		kind: "image",
 		image: {
 			float: floatAt(rect),
-			resource: resources.put(image.bytes),
+			resource: resources.put(drawnBytes(image)),
 			width: pt(rect.w),
 			height: pt(rect.h),
+			...image.crop ? { crop: image.crop } : {},
 			paragraphProperties: {}
 		}
 	};
@@ -290,34 +290,72 @@ function toCustomGeometry(g) {
 		commands
 	};
 }
+/**
+* §2.3.7.6 `fillFocus` — the stops a shaded fill's two colours make.
+*
+* A focus of zero is the plain ramp everyone expects: the first colour at one
+* end, the second at the other. Any other value means the sweep runs OUT from
+* one of them — a focus of 50 puts the first colour halfway along with the
+* second at BOTH ends, which is what 23884's every slide asks for and why its
+* background read as a flat wash into violet where the reference is blue
+* across the middle and dark only at the corners.
+*
+* @param g The gradient as the `.ppt` states it.
+* @returns The stops, in order.
+*/
+function gradientStops(g) {
+	const focus = g.focusPct ?? 0;
+	if (focus === 0) return [{
+		offset: 0,
+		colorHex: g.fromHex
+	}, {
+		offset: 1,
+		colorHex: g.toHex
+	}];
+	if (Math.abs(focus) >= 100) return [{
+		offset: 0,
+		colorHex: g.toHex
+	}, {
+		offset: 1,
+		colorHex: g.fromHex
+	}];
+	const peak = focus > 0 ? g.fromHex : g.toHex;
+	const ends = focus > 0 ? g.toHex : g.fromHex;
+	const at = focus > 0 ? focus / 100 : 1 + focus / 100;
+	return [
+		{
+			offset: 0,
+			colorHex: ends
+		},
+		{
+			offset: at,
+			colorHex: peak
+		},
+		{
+			offset: 1,
+			colorHex: ends
+		}
+	];
+}
 function positionedAutoShape(rect, auto, resources) {
 	const line = isLineShape(auto.shapeType);
 	const fill = line ? { kind: "none" } : auto.image ? {
 		kind: "picture",
 		imageResource: resources.put(auto.image.bytes),
-		...auto.imageTiled ? { tiled: true } : {},
+		...auto.imageTiled ? {
+			tiled: true,
+			tileFromCentre: true
+		} : {},
 		...auto.tileSizePt ? { tileSizePt: auto.tileSizePt } : {}
 	} : auto.gradient ? {
 		kind: "gradient",
 		gradient: auto.gradient.radial ? {
 			kind: "radial",
-			stops: [{
-				offset: 0,
-				colorHex: auto.gradient.fromHex
-			}, {
-				offset: 1,
-				colorHex: auto.gradient.toHex
-			}]
+			stops: gradientStops(auto.gradient)
 		} : {
 			kind: "linear",
 			angle: auto.gradient.angleDeg,
-			stops: [{
-				offset: 0,
-				colorHex: auto.gradient.fromHex
-			}, {
-				offset: 1,
-				colorHex: auto.gradient.toHex
-			}]
+			stops: gradientStops(auto.gradient)
 		}
 	} : auto.fillColorHex ? {
 		kind: "solid",
@@ -353,13 +391,30 @@ function inFlowImage(image, resources) {
 	return {
 		kind: "image",
 		image: {
-			resource: resources.put(image.bytes),
+			resource: resources.put(drawnBytes(image)),
 			width: pt(size.w * .75),
 			height: pt(size.h * .75),
+			...image.crop ? { crop: image.crop } : {},
 			paragraphProperties: {}
 		}
 	};
 }
+/**
+* The bytes a picture is actually DRAWN from.
+*
+* §2.3.23 `pictureTransparent` names a colour the picture is drawn without, and
+* a raster carries no alpha channel to say so — so the knock-out is baked into
+* bytes of its own. The resource store hashes content, so two shapes knocking
+* different colours out of the same blip stay two resources by themselves, and
+* one that knocks out nothing keeps the bytes it arrived with.
+*
+* @param image The picture as the shape states it.
+* @returns The bytes to store, knocked out where the shape asks for it.
+*/
+function drawnBytes(image) {
+	if (image.transparentHex === void 0 || isMetafile(image.bytes)) return image.bytes;
+	return knockOutColor(image.bytes, image.transparentHex) ?? image.bytes;
+}
 function isMetafile(d) {
 	return isEmf(d) || isWmf(d);
 }
@@ -418,12 +473,25 @@ function toRun(r) {
 function toParaProperties(p, breakBefore) {
 	const alignment = p.align !== void 0 ? alignmentFrom(p.align) : void 0;
 	const level = p.level ?? 0;
+	const leftPt = p.leftMarginPt ?? (level > 0 ? level * LEVEL_INDENT_PT : void 0);
+	const firstPt = p.indentPt !== void 0 ? p.indentPt - (leftPt ?? 0) : void 0;
 	return {
 		...breakBefore ? { pageBreakBefore: true } : {},
 		...alignment ? { alignment } : {},
-		...level > 0 ? { indentLeft: pt(level * LEVEL_INDENT_PT) } : {}
+		...leftPt !== void 0 ? { indentLeft: pt(leftPt) } : {},
+		...firstPt !== void 0 && firstPt !== 0 ? { indentFirstLine: pt(firstPt) } : {},
+		...p.spaceBeforePt !== void 0 ? { spacingBefore: pt(p.spaceBeforePt) } : {},
+		...p.spaceAfterPt !== void 0 ? { spacingAfter: pt(p.spaceAfterPt) } : {},
+		...p.lineSpacing !== void 0 && p.lineSpacing > 0 ? {
+			spacingLineRule: "auto",
+			spacingLine: pt(p.lineSpacing / 100 * 12)
+		} : {}
 	};
 }
+/** Whether the paragraph's first line starts LEFT of its body — a hanging bullet. */
+function hangs(p) {
+	return p.indentPt !== void 0 && p.leftMarginPt !== void 0 && p.indentPt < p.leftMarginPt;
+}
 function alignmentFrom(a) {
 	switch (a) {
 		case 1: return "center";