reamkit 1.23.0 → 1.25.0

package/dist/esm/html/html-writer.js

@@ -1,4 +1,5 @@
 import { FEATURES } from "../core/ir/features.js";
+import { headingLevelOf } from "../core/outline.js";
 import { detectImageFormat } from "../core/images.js";
 import { PathBuilder, flipTransform, svgPathData } from "../core/vector.js";
 import { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
@@ -321,8 +322,8 @@ function emitOneShape(out, shape, ctx) {
 }
 function emitParagraph(out, p, ctx) {
 	const resolved = resolveParagraphProperties(p.properties, EMPTY_STYLE_SHEET);
-	const lvl = resolved.outlineLevel;
-	const tag = lvl !== void 0 && lvl >= 0 && lvl <= 8 ? `h${Math.min(lvl, 5) + 1}` : "p";
+	const lvl = headingLevelOf(resolved);
+	const tag = lvl !== void 0 ? `h${String(lvl)}` : "p";
 	const style = paragraphCss(resolved);
 	const dir = resolved.bidi ? " dir=\"rtl\"" : "";
 	const anchored = (p.bookmarks ?? []).filter((b) => ctx.referencedAnchors.has(b));
@@ -653,7 +654,8 @@ var MIME_BY_FORMAT = {
 	png: "image/png",
 	jpeg2000: "image/jp2",
 	gif: "image/gif",
-	tiff: "image/tiff"
+	tiff: "image/tiff",
+	bmp: "image/bmp"
 };
 function dataUri(resource, store) {
 	if (resource === void 0) return void 0;

package/dist/esm/index.d.ts

@@ -49,6 +49,9 @@ export type { FontProvider, FontRequest, FontAnswer } from './core/fonts/provide
 export { svgWriter, writeSvg } from './svg/svg-writer.js';
 export type { SvgWriteOptions } from './svg/svg-writer.js';
 export { htmlWriter, writeHtml } from './html/html-writer.js';
+export { markdownWriter, writeMarkdown } from './markdown/markdown-writer.js';
+export type { StreamFilter, StreamFilters } from './pdf-reader/document.js';
+export type { MarkdownWriteOptions } from './markdown/markdown-writer.js';
 export { docxWriter, writeDocx } from './word/docx-writer.js';
 export { layoutStyledDocument } from './layout/styled-layout.js';
 export type { LaidOutDocument } from './layout/page-doc.js';

package/dist/esm/index.js

@@ -17,8 +17,9 @@ import { readXlsx, xlsxReader } from "./excel/xlsx-reader.js";
 import { NO_FONT, callerFontProvider, chainProviders, embeddedDocFontProvider, isEmbeddingRestricted, localFontProvider, readOs2FsType, remoteFontProvider } from "./core/fonts/provider.js";
 import { docxWriter, writeDocx } from "./word/docx-writer.js";
 import { htmlWriter, writeHtml } from "./html/html-writer.js";
+import { markdownWriter, writeMarkdown } from "./markdown/markdown-writer.js";
 import { svgWriter, writeSvg } from "./svg/svg-writer.js";
 import { createConverter } from "./core/converter/facade.js";
 import { WrongPasswordError, isEncryptedPackage } from "./core/crypto/offcrypto.js";
 import { Ream } from "./core/converter/ream.js";
-export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, WrongPasswordError, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, docxWriter, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, htmlWriter, inchToPt, isEmbeddingRestricted, isEncryptedPackage, layoutStyledDocument, localFontProvider, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeDocx, writeHtml, writeSvg, xlsxReader };
+export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, WrongPasswordError, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, docxWriter, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, htmlWriter, inchToPt, isEmbeddingRestricted, isEncryptedPackage, layoutStyledDocument, localFontProvider, markdownWriter, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeDocx, writeHtml, writeMarkdown, writeSvg, xlsxReader };

package/dist/esm/layout/page-doc.d.ts

@@ -326,6 +326,32 @@ export interface TextLineItem extends PageItemBase {
      * the plot's own tick labels. Absent ⇒ horizontal.
      */
     readonly rotationDeg?: number;
+    /**
+     * §20.1.9.10 `a:prstTxWarp` — the line is WordArt: each glyph is placed on
+     * its own, bent through the preset's curve and stretched onto the shape's
+     * box. Absent ⇒ the line is set flat, one text matrix for the whole of it.
+     */
+    readonly warp?: TextLineWarp;
+}
+/**
+ * What placing a warped line needs: the preset, the shape box the warped block
+ * is stretched onto, and the box the UN-warped block occupies — both in the
+ * page's top-left frame, so a glyph's position in the second maps straight into
+ * the first.
+ */
+export interface TextLineWarp {
+    readonly preset: string;
+    readonly adjust?: number;
+    readonly boxX: Pt;
+    readonly boxY: Pt;
+    readonly boxWidth: Pt;
+    readonly boxHeight: Pt;
+    /** The un-warped block's left edge and width (its widest line). */
+    readonly srcX: Pt;
+    readonly srcWidth: Pt;
+    /** The un-warped block's ink top and total ink height. */
+    readonly srcTop: Pt;
+    readonly srcHeight: Pt;
 }
 /** One edge of a table-cell frame; `(x, y)` is the cell box's top-left corner. */
 export interface BorderItem extends PageItemBase {
@@ -422,6 +448,15 @@ export interface PagePaintPlan {
      * per {@link PageItemBase.pictureId}. They paint where the shape pass does.
      */
     readonly pictures: ReadonlyArray<ReadonlyArray<PageItem>>;
+    /**
+     * §19.3.1 — the items of a page that STATES its own paint order, each run in
+     * the order it paints, the runs sorted by the order they were given. A slide
+     * is such a page: its shape tree is a z-order, and a picture standing after a
+     * rectangle in it is drawn over that rectangle. Split by kind instead — every
+     * image, then every shape — the six logos of 54542_cropped_bitmap.pptx were
+     * painted first and the six panels they sit on were painted over them.
+     */
+    readonly ordered: ReadonlyArray<ReadonlyArray<PageItem>>;
 }
 export declare function paintPlan(commands: ReadonlyArray<PageItem>): PagePaintPlan;
 export interface LaidOutDocument {

package/dist/esm/layout/page-doc.js

@@ -7,11 +7,23 @@ function paintPlan(commands) {
 	const lines = [];
 	const pictures = /* @__PURE__ */ new Map();
 	const behind = [];
+	const ordered = /* @__PURE__ */ new Map();
+	const orderOf = /* @__PURE__ */ new Map();
 	for (const c of commands) {
 		if (c.behind === true) {
 			behind.push(c);
 			continue;
 		}
+		if (c.z !== void 0 && c.type !== "fill" && c.type !== "border" && (c.type !== "line" || c.pictureId !== void 0)) {
+			const key = c.pictureId !== void 0 ? `p${c.pictureId}` : `i${orderOf.size}`;
+			const run = ordered.get(key);
+			if (run) run.push(c);
+			else {
+				ordered.set(key, [c]);
+				orderOf.set(key, c.z);
+			}
+			continue;
+		}
 		if (c.pictureId !== void 0) {
 			const group = pictures.get(c.pictureId);
 			if (group) group.push(c);
@@ -44,7 +56,8 @@ function paintPlan(commands) {
 		borders,
 		shapes,
 		lines,
-		pictures: [...pictures.values()]
+		pictures: [...pictures.values()],
+		ordered: [...ordered.entries()].sort((a, b) => (orderOf.get(a[0]) ?? 0) - (orderOf.get(b[0]) ?? 0)).map(([, run]) => run)
 	};
 }
 function assertNeverPageItem(item) {

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

@@ -4,6 +4,7 @@ import { shapeText } from "../core/font/opentype-layout.js";
 import { createFontMeasure } from "../core/font/measure.js";
 import { halfPtToPt, pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
+import { headingLevelOf } from "../core/outline.js";
 import { prepareImage } from "../core/images.js";
 import { PathBuilder, flipTransform } from "../core/vector.js";
 import { isEmf, readEmf } from "../core/metafile/emf.js";
@@ -1030,8 +1031,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 +1050,10 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 	const textLineGaps = /* @__PURE__ */ new Map();
 	let textHeightPt = 0;
 	const vertical = text?.vertical;
+	const upright = text?.upright;
+	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 +1146,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 +1179,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 +1204,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 +1220,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 } : {},
@@ -1213,6 +1237,7 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		insetTopPt,
 		insetBottomPt,
 		anchor: text?.anchor ?? "t",
+		...upright ? { upright } : {},
 		...vertical ? { vertical } : {},
 		...shape.altText ? { altText: shape.altText } : {},
 		...shape.float ? { float: shape.float } : {}
@@ -1863,6 +1888,9 @@ function chartPageItems(laid, x, bottomYUp, pageHeight, structId) {
 var nextPictureId = 1;
 function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
 	if (sh.textLines.length === 0) return;
+	const turnDeg = sh.upright === true || sh.flipH || sh.flipV ? 0 : -(sh.rotation60k || 0) / 6e4;
+	const centreX = x + sh.widthPt / 2;
+	const centreY = bottomYUp + sh.heightPt / 2;
 	if (sh.vertical) {
 		const up = sh.vertical === "vert270";
 		const innerHeight = Math.max(1, sh.heightPt - sh.insetTopPt - sh.insetBottomPt);
@@ -1872,18 +1900,23 @@ function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
 			const lineOffset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, innerHeight);
 			const off = lineBaselineOffset(line, line.resolved);
 			const baselineAcross = up ? across + h - off : across + off;
+			const origin = spinAboutCentre(up ? x + baselineAcross : x + sh.widthPt - baselineAcross, up ? bottomYUp + sh.insetBottomPt + lineOffset : bottomYUp + sh.heightPt - sh.insetTopPt - lineOffset, centreX, centreY, turnDeg);
 			sink.push({
 				type: "line",
 				line,
-				originX: pt(up ? x + baselineAcross : x + sh.widthPt - baselineAcross),
-				baselineY: pt(pageHeight - (up ? bottomYUp + sh.insetBottomPt + lineOffset : bottomYUp + sh.heightPt - sh.insetTopPt - lineOffset)),
-				rotationDeg: up ? 90 : -90,
+				originX: pt(origin.x),
+				baselineY: pt(pageHeight - origin.y),
+				rotationDeg: (up ? 90 : -90) + turnDeg,
 				...figId !== void 0 ? { structId: figId } : {}
 			});
 			across += h;
 		}
 		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;
@@ -1913,16 +1946,102 @@ function emitShapeText(sh, x, bottomYUp, sink, pageHeight, figId) {
 			return;
 		}
 		const indentLeft = line.resolved.indentLeft + (line.firstLine ? line.resolved.indentFirstLine : 0);
+		const origin = spinAboutCentre(x + sh.insetLeftPt + indentLeft + lineOffset, textY + lineBaselineOffset(line, line.resolved), centreX, centreY, turnDeg);
 		sink.push({
 			type: "line",
 			line,
-			originX: pt(x + sh.insetLeftPt + indentLeft + lineOffset),
-			baselineY: pt(pageHeight - (textY + lineBaselineOffset(line, line.resolved))),
+			originX: pt(origin.x),
+			baselineY: pt(pageHeight - origin.y),
+			...turnDeg !== 0 ? { rotationDeg: turnDeg } : {},
 			...figId !== void 0 ? { structId: figId } : {}
 		});
 		textY -= sh.textLineGaps?.get(i) ?? 0;
 	});
 }
+/**
+* A point spun about another, counter-clockwise in the y-up page frame.
+*
+* @param px  The point's x.
+* @param py  The point's y (y-up).
+* @param cx  The centre's x.
+* @param cy  The centre's y (y-up).
+* @param deg How far to turn, counter-clockwise; zero returns the point.
+* @returns The turned point.
+*/
+function spinAboutCentre(px, py, cx, cy, deg) {
+	if (deg === 0) return {
+		x: px,
+		y: py
+	};
+	const rad = deg * Math.PI / 180;
+	const cos = Math.cos(rad);
+	const sin = Math.sin(rad);
+	const dx = px - cx;
+	const dy = py - cy;
+	return {
+		x: cx + dx * cos - dy * sin,
+		y: cy + dx * sin + dy * cos
+	};
+}
+/**
+* §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 +2081,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 +2106,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 +2133,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 +2155,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 +3782,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 +4225,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 +4246,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 +4297,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 +4316,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,
@@ -4209,16 +4373,8 @@ function resolveCellBorders(cellBorders, tableBorders, rowIdx, colStart, colEnd,
 	return out;
 }
 function paragraphStructType(resolved) {
-	const lvl = resolved.outlineLevel;
-	if (lvl !== void 0 && lvl >= 0 && lvl <= 8) return `H${Math.min(lvl, 5) + 1}`;
-	return headingFromStyleId(resolved.styleId) ?? "P";
-}
-function headingFromStyleId(styleId) {
-	if (!styleId) return null;
-	const m = /^Heading\s*([1-9])$/i.exec(styleId);
-	if (m) return `H${Math.min(Number(m[1]), 6)}`;
-	if (/^(Title|Subtitle)$/i.test(styleId)) return "H1";
-	return null;
+	const lvl = headingLevelOf(resolved);
+	return lvl !== void 0 ? `H${String(lvl)}` : "P";
 }
 function dominantParagraphLang(lines) {
 	const counts = /* @__PURE__ */ new Map();
@@ -4807,16 +4963,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 +5355,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 +5648,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/markdown/markdown-writer.d.ts

@@ -0,0 +1,41 @@
+import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
+import { FlowDoc } from '../core/ir/flow.js';
+/** Options for {@link writeMarkdown}. */
+export interface MarkdownWriteOptions {
+    /**
+     * How a picture reaches the output. `'dataUri'` (the default) inlines the
+     * bytes as a `data:` URI, keeping the single-blob {@link WriteResult}
+     * contract and the zero-I/O promise; `'link'` emits a relative
+     * `./media/…` path and records that the bytes were not written anywhere;
+     * `'drop'` omits pictures entirely.
+     */
+    readonly images?: 'dataUri' | 'link' | 'drop';
+    /**
+     * What a page break becomes. `'drop'` (the default) leaves it out and
+     * reports it: a paginated document breaks its pages wherever the layout
+     * needs to, and a rule at every one of them would litter the text. `'rule'`
+     * writes a `---` thematic break instead, which is what a SLIDE DECK wants —
+     * the `.pptx` and `.ppt` readers mark each slide boundary with a page break,
+     * and it is the only structure a deck has.
+     */
+    readonly pageBreaks?: 'rule' | 'drop';
+}
+/**
+ * Render a {@link FlowDoc} to GitHub-Flavored Markdown (ir-design §7).
+ *
+ * A flow medium: no pagination, no layout engine and no fonts, so this is a
+ * pure, zero-I/O transform. Markdown says far less than the document model
+ * does — alignment, indents, colour, font metrics, tab stops and page
+ * geometry have no expression at all — so those are dropped and reported as
+ * {@link Loss} entries, deduplicated so one recurring omission reports once.
+ *
+ * @param flow    The format-neutral interlayer document tree.
+ * @param options Picture handling; see {@link MarkdownWriteOptions}.
+ * @returns The encoded Markdown bytes plus the recorded {@link Loss} list.
+ */
+export declare function writeMarkdown(flow: FlowDoc, options?: MarkdownWriteOptions): WriteResult;
+/**
+ * The flow-medium {@link DocumentWriter} adapter (id `'md'`), wrapping
+ * {@link writeMarkdown}, with the set of {@link FEATURES} it renders.
+ */
+export declare const markdownWriter: DocumentWriter<FlowDoc>;