reamkit 1.9.0 → 1.11.0

package/README.md

@@ -20,9 +20,9 @@ Runtime dependencies are minimal: `fflate` (ZIP/Deflate) and `fast-xml-parser`.
 
 Parse once into the format-neutral interlayer, convert to any target. The
 format (docx/xlsx) is sniffed from the bytes; no fonts to wire up — an open
-substitute font (Roboto for sans, Tinos for serif, Cousine for monospace — the
-same families LibreOffice substitutes) is fetched automatically based on the
-document's referenced fonts:
+metric-compatible substitute font (Arimo for sans, Tinos for serif, Cousine for
+monospace, plus Carlito/Caladea for Calibri/Cambria — the same families LibreOffice
+substitutes) is fetched automatically based on the document's referenced fonts:
 
 ```ts
 import { Ream } from 'reamkit';
@@ -30,7 +30,7 @@ import { Ream } from 'reamkit';
 // e.g. from an <input type="file"> or a fetch() — anything that yields bytes.
 const bytes = new Uint8Array(await file.arrayBuffer());
 
-const doc = Ream.parse(bytes);            // docx, xlsx or pdf — sniffed
+const doc = Ream.parse(bytes);            // docx, xlsx, pptx or pdf — sniffed
 const pdf = await doc.convert('pdf');     // async — fetches a font if needed
 const svg = await doc.convert('svg');     // same parse, different target
 const html = await doc.convert('html');   // flowed HTML — needs no fonts at all
@@ -130,7 +130,7 @@ rendering — inspect or analyze it without converting:
 
 ```ts
 const doc = Ream.parse(bytes);
-doc.format;     // 'docx' | 'xlsx' | 'pdf'
+doc.format;     // 'docx' | 'xlsx' | 'pptx' | 'pdf'
 doc.flow.body;  // paragraphs / tables / images / charts …
 doc.losses;     // read-time losses
 ```
@@ -187,6 +187,12 @@ gradient vector shapes. It reads modern compressed files (cross-reference + obje
 streams) and encrypted ones (RC4 / AES — the user password is passed to
 `Ream.parse(bytes, { password })`, defaulting to the permissions-only case).
 
+**Reads PowerPoint, too.** `Ream.parse` accepts a `.pptx` and turns each slide
+into a page at the deck size — text boxes (with run formatting, alignment,
+bullets and indents), layout/master placeholders, pictures, shapes, DrawingML
+tables, embedded charts, theme colours, slide backgrounds, grouped shapes and
+hyperlinks — then converts onward to PDF, SVG, HTML or DOCX like any source.
+
 See [`CHANGELOG.md`](./CHANGELOG.md) for the release history; the docs
 [**Scope**](https://reamkit.dev/guides/scope/) guide has the full feature matrix
 and known limitations.

package/dist/esm/core/converter/facade.js

@@ -13,6 +13,7 @@ import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { convertDocxToPdf } from "../../word/docx-to-pdf.js";
 import { convertXlsxToPdf } from "../../excel/xlsx-to-pdf.js";
+import { pptxReader } from "../../pptx/pptx-reader.js";
 import { pdfReader } from "../../pdf-reader/reader.js";
 //#region src/core/converter/facade.ts
 function toFlowDoc(doc) {
@@ -28,6 +29,7 @@ function readToFlow(reader, bytes) {
 var DEFAULT_READERS = [
 	docxReader,
 	xlsxReader,
+	pptxReader,
 	pdfReader
 ];
 function createConverter(opts = {}) {

package/dist/esm/core/converter/ream.js

@@ -16,6 +16,7 @@ import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 var SOURCE_MIME = {
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
 	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
 	pdf: "application/pdf"
 };
 var Ream = class Ream {

package/dist/esm/core/font/measure.d.ts

@@ -4,4 +4,4 @@ export interface FontMeasure {
     readonly textWidthPt: (text: string, fontSize: number) => number;
     readonly encodeTextAsCidHex: (text: string) => string;
 }
-export declare function createFontMeasure(parsed: ParsedTtf): FontMeasure;
+export declare function createFontMeasure(parsed: ParsedTtf, kern?: boolean): FontMeasure;

package/dist/esm/core/font/measure.js

@@ -1,7 +1,9 @@
 import { shapeText } from "./opentype-layout.js";
 //#region src/core/font/measure.ts
-function createFontMeasure(parsed) {
+var EMPTY_KERNING = /* @__PURE__ */ new Map();
+function createFontMeasure(parsed, kern = true) {
 	const scale = 1e3 / parsed.unitsPerEm;
+	const kerning = kern ? parsed.kerning : EMPTY_KERNING;
 	const widths = new Array(parsed.numGlyphs);
 	for (let i = 0; i < parsed.numGlyphs; i++) widths[i] = Math.round((parsed.advanceWidths[i] ?? 0) * scale);
 	const pdfWidthForGid = (gid) => {
@@ -9,13 +11,13 @@ function createFontMeasure(parsed) {
 		return widths[gid];
 	};
 	const textWidthPt = (text, fontSize) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
 		let totalEm = 0;
 		for (const a of shaped.advances) totalEm += a;
 		return totalEm * fontSize / parsed.unitsPerEm;
 	};
 	const encodeTextAsCidHex = (text) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
 		let out = "";
 		for (const gid of shaped.gids) out += gid.toString(16).padStart(4, "0").toUpperCase();
 		return out;

package/dist/esm/core/font/ttf-parser.d.ts

@@ -12,8 +12,17 @@ export interface ParsedTtf {
     readonly fontBBox: readonly [number, number, number, number];
     readonly ascender: number;
     readonly descender: number;
+    readonly lineGap: number;
     readonly capHeight: number;
     readonly xHeight: number;
+    readonly vmetrics: {
+        readonly typoAscent: number;
+        readonly typoDescent: number;
+        readonly typoLineGap: number;
+        readonly winAscent: number;
+        readonly winDescent: number;
+        readonly useTypoMetrics: boolean;
+    };
     readonly italicAngle: number;
     readonly stemV: number;
     readonly flags: number;

package/dist/esm/core/font/ttf-parser.js

@@ -41,7 +41,7 @@ function parseTtf(raw) {
 	r.seek(hhea.offset + 4);
 	const ascender = r.i16();
 	const descender = r.i16();
-	r.skip(2);
+	const lineGap = r.i16();
 	r.skip(24);
 	const numberOfHMetrics = r.u16();
 	const maxp = require("maxp");
@@ -74,6 +74,12 @@ function parseTtf(raw) {
 	let xHeight = 0;
 	let isItalic = false;
 	let usWeightClass = 400;
+	let typoAscent = ascender;
+	let typoDescent = descender;
+	let typoLineGap = lineGap;
+	let winAscent = Math.abs(ascender);
+	let winDescent = Math.abs(descender);
+	let useTypoMetrics = false;
 	const os2 = tables.get("OS/2");
 	if (os2) {
 		r.seek(os2.offset);
@@ -81,7 +87,17 @@ function parseTtf(raw) {
 		r.skip(2);
 		usWeightClass = r.u16();
 		r.seek(os2.offset + 62);
-		isItalic = (r.u16() & 1) !== 0;
+		const fsSelection = r.u16();
+		isItalic = (fsSelection & 1) !== 0;
+		useTypoMetrics = (fsSelection & 128) !== 0;
+		if (os2.length >= 78) {
+			r.seek(os2.offset + 68);
+			typoAscent = r.i16();
+			typoDescent = r.i16();
+			typoLineGap = r.i16();
+			winAscent = r.u16();
+			winDescent = r.u16();
+		}
 		if (os2Version >= 2 && os2.length >= 90) {
 			r.seek(os2.offset + 86);
 			xHeight = r.i16();
@@ -113,8 +129,17 @@ function parseTtf(raw) {
 		],
 		ascender,
 		descender,
+		lineGap,
 		capHeight,
 		xHeight,
+		vmetrics: {
+			typoAscent,
+			typoDescent,
+			typoLineGap,
+			winAscent,
+			winDescent,
+			useTypoMetrics
+		},
 		italicAngle,
 		stemV,
 		flags,

package/dist/esm/core/fonts/provider.d.ts

@@ -35,7 +35,8 @@ export declare function callerFontProvider(fonts: FontBytesByVariant): FontProvi
  */
 export declare function embeddedDocFontProvider(embedded: ReadonlyMap<string, FontRegistry>): FontProvider;
 /**
- * Open CDN substitutes (Roboto / Tinos / Cousine — the LibreOffice mapping).
+ * Open CDN substitutes (Arimo / Tinos / Cousine / Carlito / Caladea — the
+ * LibreOffice metric-compatible mapping).
  * Always answers; the chain reports it as a substitution.
  */
 export declare function remoteFontProvider(options?: {

package/dist/esm/core/fonts/provider.js

@@ -62,7 +62,8 @@ function embeddedDocFontProvider(embedded) {
 	};
 }
 /**
-* Open CDN substitutes (Roboto / Tinos / Cousine — the LibreOffice mapping).
+* Open CDN substitutes (Arimo / Tinos / Cousine / Carlito / Caladea — the
+* LibreOffice metric-compatible mapping).
 * Always answers; the chain reports it as a substitution.
 */
 function remoteFontProvider(options = {}) {

package/dist/esm/core/fonts/remote-fonts.d.ts

@@ -1,5 +1,5 @@
 import { FontBytesByVariant } from '../font/index.js';
-export type FamilyKey = 'roboto' | 'tinos' | 'cousine';
+export type FamilyKey = 'arimo' | 'tinos' | 'cousine' | 'carlito' | 'caladea';
 export declare function resolveFamilyKey(name: string | undefined): FamilyKey;
 export type FetchLike = (url: string) => Promise<{
     ok: boolean;

package/dist/esm/core/fonts/remote-fonts.js

@@ -7,9 +7,9 @@ var VARIANT_SUFFIX = {
 	boldItalic: "700Bold_Italic"
 };
 var FAMILIES = {
-	roboto: {
-		pkg: "roboto",
-		file: "Roboto"
+	arimo: {
+		pkg: "arimo",
+		file: "Arimo"
 	},
 	tinos: {
 		pkg: "tinos",
@@ -18,13 +18,32 @@ var FAMILIES = {
 	cousine: {
 		pkg: "cousine",
 		file: "Cousine"
+	},
+	carlito: {
+		pkg: "carlito",
+		file: "Carlito",
+		nested: true
+	},
+	caladea: {
+		pkg: "caladea",
+		file: "Caladea"
 	}
 };
+var EXACT = {
+	calibri: "carlito",
+	cambria: "caladea",
+	arial: "arimo",
+	helvetica: "arimo",
+	"liberation sans": "arimo",
+	"times new roman": "tinos",
+	times: "tinos",
+	"liberation serif": "tinos",
+	"courier new": "cousine",
+	courier: "cousine",
+	"liberation mono": "cousine"
+};
 var SERIF = new Set([
-	"times",
-	"times new roman",
 	"georgia",
-	"cambria",
 	"garamond",
 	"book antiqua",
 	"palatino",
@@ -33,8 +52,6 @@ var SERIF = new Set([
 	"serif"
 ]);
 var MONO = new Set([
-	"courier",
-	"courier new",
 	"consolas",
 	"monaco",
 	"menlo",
@@ -43,14 +60,18 @@ var MONO = new Set([
 	"monospace"
 ]);
 function resolveFamilyKey(name) {
-	if (!name) return "roboto";
+	if (!name) return "arimo";
 	const n = name.trim().toLowerCase();
+	const exact = EXACT[n];
+	if (exact) return exact;
 	if (MONO.has(n)) return "cousine";
 	if (SERIF.has(n)) return "tinos";
-	return "roboto";
+	return "arimo";
 }
 function fontUrl(family, variant) {
-	return `${CDN_BASE}/${family.pkg}/${family.file}_${VARIANT_SUFFIX[variant]}.ttf`;
+	const suffix = VARIANT_SUFFIX[variant];
+	const leaf = `${family.file}_${suffix}.ttf`;
+	return family.nested ? `${CDN_BASE}/${family.pkg}/${suffix}/${leaf}` : `${CDN_BASE}/${family.pkg}/${leaf}`;
 }
 var cache = /* @__PURE__ */ new Map();
 async function fetchTtf(url, fetchImpl, required) {

package/dist/esm/core/line-breaker/greedy.d.ts

@@ -0,0 +1,2 @@
+import { Item } from './knuth-plass.js';
+export declare function greedyBreakLines(items: ReadonlyArray<Item>, lineWidths: number | ReadonlyArray<number>): ReadonlyArray<number>;

package/dist/esm/core/line-breaker/greedy.js

@@ -0,0 +1,67 @@
+import { FORBIDDEN_BREAK } from "./knuth-plass.js";
+//#region src/core/line-breaker/greedy.ts
+function greedyBreakLines(items, lineWidths) {
+	if (items.length === 0) return [];
+	const widthFor = (line) => typeof lineWidths === "number" ? lineWidths : lineWidths[Math.min(line, lineWidths.length - 1)];
+	const widthBefore = new Array(items.length + 1);
+	widthBefore[0] = 0;
+	for (let i = 0; i < items.length; i++) {
+		const it = items[i];
+		widthBefore[i + 1] = widthBefore[i] + (it.type === "penalty" ? 0 : it.width);
+	}
+	const lineWidth = (start, b) => {
+		let w = widthBefore[b] - widthBefore[start];
+		const item = items[b];
+		if (item.type === "penalty") w += item.width;
+		return w;
+	};
+	const isFeasible = (i) => {
+		const item = items[i];
+		if (item.type === "penalty") return item.penalty < FORBIDDEN_BREAK;
+		if (item.type === "glue") {
+			const prev = items[i - 1];
+			return !!prev && prev.type === "box";
+		}
+		return false;
+	};
+	const breaks = [];
+	let lineStart = 0;
+	let lineNo = 0;
+	let lastGood = -1;
+	let i = 0;
+	while (i < items.length) {
+		if (!isFeasible(i)) {
+			i++;
+			continue;
+		}
+		const item = items[i];
+		const forced = item.type === "penalty" && item.penalty <= -1e4;
+		const fits = lineWidth(lineStart, i) <= widthFor(lineNo);
+		if (!fits && lastGood >= 0) {
+			breaks.push(lastGood);
+			lineStart = lastGood + 1;
+			lineNo++;
+			lastGood = -1;
+			continue;
+		}
+		if (forced) {
+			breaks.push(i);
+			lineStart = i + 1;
+			lineNo++;
+			lastGood = -1;
+			i++;
+			continue;
+		}
+		if (fits) lastGood = i;
+		else {
+			breaks.push(i);
+			lineStart = i + 1;
+			lineNo++;
+			lastGood = -1;
+		}
+		i++;
+	}
+	return breaks;
+}
+//#endregion
+export { greedyBreakLines };

package/dist/esm/core/line-breaker/index.d.ts

@@ -1,2 +1,3 @@
 export { FORCED_BREAK, breakLines } from './knuth-plass.js';
+export { greedyBreakLines } from './greedy.js';
 export type { Item, BoxItem, GlueItem, PenaltyItem, BreakResult, } from './knuth-plass.js';

package/dist/esm/core/line-breaker/knuth-plass.d.ts

@@ -20,6 +20,7 @@ export interface BreakResult {
     readonly ratios: ReadonlyArray<number>;
 }
 export declare const FORCED_BREAK = -10000;
+export declare const FORBIDDEN_BREAK = 10000;
 /**
  * Break a paragraph into lines using the Knuth-Plass total-fit algorithm.
  *

package/dist/esm/core/line-breaker/knuth-plass.js

@@ -47,7 +47,7 @@ function breakLines(items, lineWidths) {
 	let active = [startNode];
 	const isFeasibleBreakpoint = (i) => {
 		const item = items[i];
-		if (item.type === "penalty" && item.penalty < FORBIDDEN_BREAK) return true;
+		if (item.type === "penalty" && item.penalty < 1e4) return true;
 		if (item.type === "glue") {
 			const prev = items[i - 1];
 			return !!prev && prev.type === "box";
@@ -90,7 +90,7 @@ function breakLines(items, lineWidths) {
 	const lineDemerits = (r, penaltyAtBreak, lastItemPenalty) => {
 		const badness = 100 * Math.pow(Math.abs(r), 3);
 		let d;
-		if (penaltyAtBreak >= 0 && penaltyAtBreak < FORBIDDEN_BREAK) d = Math.pow(LINE_PENALTY + badness + penaltyAtBreak, 2);
+		if (penaltyAtBreak >= 0 && penaltyAtBreak < 1e4) d = Math.pow(LINE_PENALTY + badness + penaltyAtBreak, 2);
 		else if (penaltyAtBreak > -1e4 && penaltyAtBreak < 0) d = Math.pow(LINE_PENALTY + badness, 2) - penaltyAtBreak * penaltyAtBreak;
 		else d = Math.pow(LINE_PENALTY + badness, 2);
 		return d;
@@ -169,4 +169,4 @@ function breakLines(items, lineWidths) {
 	};
 }
 //#endregion
-export { FORCED_BREAK, breakLines };
+export { FORBIDDEN_BREAK, FORCED_BREAK, breakLines };

package/dist/esm/excel/xlsx-to-pdf.js

@@ -46,7 +46,7 @@ function prepareXlsxStyledRender(xlsx, options) {
 	if (!fonts) throw new Error("convertXlsxToPdfSync requires options.fonts or options.fontBytes");
 	const registry = FontRegistry.fromBytes(fonts);
 	const { doc: flow } = readXlsx(xlsx);
-	const { fontBytes: _ignoreA, fonts: _ignoreB, section: sectionOverride, info: callerInfo, embedSource, attachments: callerAttachments, signature: _ignoreSig, ...renderOptions } = options;
+	const { fontBytes: _ignoreA, fonts: _ignoreB, section: sectionOverride, info: callerInfo, embedSource, attachments: callerAttachments, signature: _ignoreSig, layoutProfile: _ignoreProfile, ...renderOptions } = options;
 	const section = sectionOverride ?? flow.section;
 	const info = flow.info || callerInfo ? {
 		...flow.info,

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

@@ -70,6 +70,8 @@ export interface Line {
     isLastInParagraph: boolean;
     readonly mathAscentPt?: number;
     readonly mathDescentPt?: number;
+    readonly metricHeightPt?: number;
+    readonly metricDescentPt?: number;
 }
 export interface ImageResource {
     readonly resourceName: string;

package/dist/esm/layout/styled-layout.d.ts

@@ -15,8 +15,10 @@ export interface PdfAProfile {
     readonly tagged: boolean;
     readonly version: '1.4' | '1.7';
 }
+export type LayoutProfile = 'ream' | 'word' | 'libreoffice';
 export interface StyledRenderOptions {
     readonly registry: FontRegistry;
+    readonly layoutProfile?: LayoutProfile;
     readonly registriesByFamily?: ReadonlyMap<FamilyKey, FontRegistry>;
     readonly embeddedFonts?: ReadonlyMap<string, FontRegistry>;
     readonly styles: StyleSheet;

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

@@ -7,6 +7,7 @@ import { prepareImage } from "../core/images.js";
 import { segmentLevels } from "../core/bidi/segments.js";
 import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
 import { FORCED_BREAK, breakLines } from "../core/line-breaker/knuth-plass.js";
+import { greedyBreakLines } from "../core/line-breaker/greedy.js";
 import { applyNumbering, applyNumberingToHeadersFooters } from "../core/numbering/apply.js";
 import { DEFAULT_RESOLVED_PARAGRAPH, DEFAULT_RESOLVED_RUN } from "../core/style-cascade/types.js";
 import { resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
@@ -930,7 +931,7 @@ function collectFontResources(body, headersFooters, options) {
 		out.set(variant, {
 			resourceName,
 			parsed: info.parsed,
-			measure: createFontMeasure(info.parsed),
+			measure: createFontMeasure(info.parsed, options.layoutProfile !== "word"),
 			gids: info.gids
 		});
 	}
@@ -943,7 +944,7 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 		...baseResolved,
 		alignment: "right"
 	} : baseResolved;
-	const lines = wrap(tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir), paragraphMaxWidth(resolved, contentWidth, true), paragraphMaxWidth(resolved, contentWidth, false), resolved, options.hyphenator, lineWidths);
+	const lines = wrap(tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir), paragraphMaxWidth(resolved, contentWidth, true), paragraphMaxWidth(resolved, contentWidth, false), resolved, options.hyphenator, options.layoutProfile ?? "ream", lineWidths);
 	let heightPt = 0;
 	for (const line of lines) heightPt += computeLineHeight(line, resolved);
 	const numbering = paragraph.properties.numbering;
@@ -1290,7 +1291,7 @@ function paragraphItemStream(tokens, hyphenator) {
 	});
 	return entries;
 }
-function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved) {
+function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, profile) {
 	let st = start;
 	let et = breakIdx;
 	while (st < et && (entries[st].token === null || entries[st].token?.isSpace)) st++;
@@ -1316,6 +1317,10 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 	let maxSize = 0;
 	let mathAscent = 0;
 	let mathDescent = 0;
+	const useMetric = profile !== "ream";
+	let metricAscent = 0;
+	let metricDescent = 0;
+	let metricLineGap = 0;
 	for (const t of lineTokens) {
 		contentWidth += t.widthPt;
 		const sz = tokenLineSize(t);
@@ -1323,8 +1328,14 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 		if (t.kind === "math") {
 			mathAscent = Math.max(mathAscent, t.ascentPt);
 			mathDescent = Math.max(mathDescent, t.descentPt);
+		} else if (useMetric && t.kind === "text") {
+			const m = fontLeadingPt(t.font.parsed, t.fontSizePt, profile);
+			if (m.ascentPt > metricAscent) metricAscent = m.ascentPt;
+			if (m.descentPt > metricDescent) metricDescent = m.descentPt;
+			if (m.lineGapPt > metricLineGap) metricLineGap = m.lineGapPt;
 		}
 	}
+	const hasMetric = useMetric && metricAscent + metricDescent > 0;
 	return {
 		tokens: lineTokens,
 		contentWidthPt: contentWidth,
@@ -1334,21 +1345,26 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 		resolved,
 		isLastInParagraph: false,
 		mathAscentPt: mathAscent,
-		mathDescentPt: mathDescent
+		mathDescentPt: mathDescent,
+		...hasMetric ? {
+			metricHeightPt: metricAscent + metricDescent + metricLineGap,
+			metricDescentPt: metricDescent
+		} : {}
 	};
 }
-function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, lineWidths) {
+function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, lineWidths) {
 	if (tokens.length === 0) return [];
 	const widths = lineWidths ?? [firstLineWidth, otherWidth];
 	const entries = paragraphItemStream(tokens, hyphenator);
-	const { breaks } = breakLines(entries.map((e) => e.item), widths);
+	const items = entries.map((e) => e.item);
+	const breaks = profile === "ream" ? breakLines(items, widths).breaks : greedyBreakLines(items, widths);
 	const lines = [];
 	let start = 0;
 	let isFirst = true;
 	let lineIdx = 0;
 	for (const breakIdx of breaks) {
 		const width = lineIdx < widths.length ? widths[lineIdx] : widths[widths.length - 1];
-		const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved);
+		const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, profile);
 		if (line) lines.push(line);
 		start = breakIdx + 1;
 		isFirst = false;
@@ -1357,19 +1373,38 @@ function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, lineWidt
 	if (lines.length > 0) lines[lines.length - 1].isLastInParagraph = true;
 	return lines;
 }
+function fontLeadingPt(parsed, sizePt, profile) {
+	const s = sizePt / parsed.unitsPerEm;
+	const vm = parsed.vmetrics;
+	if (profile === "word") return {
+		ascentPt: vm.winAscent * s,
+		descentPt: vm.winDescent * s,
+		lineGapPt: 0
+	};
+	const asc = vm.useTypoMetrics ? vm.typoAscent : parsed.ascender;
+	const desc = vm.useTypoMetrics ? vm.typoDescent : parsed.descender;
+	const gap = vm.useTypoMetrics ? vm.typoLineGap : parsed.lineGap;
+	return {
+		ascentPt: asc * s,
+		descentPt: -desc * s,
+		lineGapPt: gap * s
+	};
+}
 function computeLineHeight(line, p) {
 	const fontSize = line.maxFontSizePt || 12;
+	const natural = line.metricHeightPt ?? fontSize * 1.2;
 	const mathH = (line.mathAscentPt ?? 0) + (line.mathDescentPt ?? 0);
 	const mathNeed = mathH > 0 ? mathH * 1.05 : 0;
 	if (p.spacingLineRule === "exact" && p.spacingLine > 0) return Math.max(p.spacingLine, mathNeed);
-	if (p.spacingLineRule === "atLeast" && p.spacingLine > 0) return Math.max(fontSize * 1.2, p.spacingLine, mathNeed);
+	if (p.spacingLineRule === "atLeast" && p.spacingLine > 0) return Math.max(natural, p.spacingLine, mathNeed);
 	const lineTwips = Math.round(p.spacingLine * 20);
 	const multiple = lineTwips > 0 ? lineTwips / 240 : 1;
-	return Math.max(fontSize * 1.2 * multiple, mathNeed);
+	return Math.max(natural * multiple, mathNeed);
 }
 function lineDescent(line) {
 	const fs = line.maxFontSizePt || 12;
-	return Math.max(fs * .2, line.mathDescentPt ?? 0);
+	const base = line.metricDescentPt ?? fs * .2;
+	return Math.max(base, line.mathDescentPt ?? 0);
 }
 function alignmentOffset(alignment, lineWidth, available) {
 	if (alignment === "right") return Math.max(0, available - lineWidth);

package/dist/esm/pptx/placeholder-cascade.d.ts

@@ -0,0 +1,9 @@
+import { RunProperties } from '../core/document-model/index.js';
+import { ColorResolver } from '../core/drawingml/colors.js';
+import { PoNode } from '../core/po-helpers.js';
+import { PlaceholderRef, ShapeBoxEmu } from './sp-helpers.js';
+export interface PlaceholderCascade {
+    readonly geometryFor: (ph: PlaceholderRef) => ShapeBoxEmu | undefined;
+    readonly defaultsFor: (ph: PlaceholderRef, level: number) => RunProperties;
+}
+export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver): PlaceholderCascade;

package/dist/esm/pptx/placeholder-cascade.js

@@ -0,0 +1,77 @@
+import { poChildren, poIs } from "../core/po-helpers.js";
+import { parsePh, parseXfrmBox, rPrToRunProps } from "./sp-helpers.js";
+//#region src/pptx/placeholder-cascade.ts
+function categoryOf(type) {
+	if (type === "title" || type === "ctrTitle") return "title";
+	if (type === void 0 || type === "body" || type === "subTitle" || type === "obj") return "body";
+	return "other";
+}
+function buildPlaceholderCascade(layoutTree, masterTree, colors) {
+	const layoutPhs = collectPlaceholders(layoutTree, "p:sldLayout");
+	const masterPhs = masterTree ? collectPlaceholders(masterTree, "p:sldMaster") : [];
+	const txStyles = masterTree ? collectTxStyles(masterTree, colors) : {
+		title: [],
+		body: [],
+		other: []
+	};
+	return {
+		geometryFor(ph) {
+			return matchPlaceholder(layoutPhs, ph)?.box ?? matchPlaceholder(masterPhs, ph)?.box;
+		},
+		defaultsFor(ph, level) {
+			const levels = txStyles[categoryOf(ph.type)];
+			if (levels.length === 0) return {};
+			return levels[Math.min(Math.max(level, 0), levels.length - 1)] ?? {};
+		}
+	};
+}
+function collectPlaceholders(tree, root) {
+	const sld = tree.find((n) => poIs(n, root));
+	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
+	const spTree = cSld ? poChildren(cSld).find((c) => poIs(c, "p:spTree")) : void 0;
+	if (!spTree) return [];
+	const out = [];
+	for (const sp of poChildren(spTree)) {
+		if (!poIs(sp, "p:sp")) continue;
+		const ref = parsePh(sp);
+		if (!ref) continue;
+		const box = parseXfrmBox(poChildren(sp).find((c) => poIs(c, "p:spPr")));
+		out.push({
+			ref,
+			...box ? { box } : {}
+		});
+	}
+	return out;
+}
+function matchPlaceholder(list, ph) {
+	if (ph.idx !== void 0) {
+		const byIdx = list.find((p) => p.ref.idx === ph.idx);
+		if (byIdx) return byIdx;
+	}
+	const byType = list.find((p) => p.ref.type === ph.type);
+	if (byType) return byType;
+	const cat = categoryOf(ph.type);
+	return list.find((p) => categoryOf(p.ref.type) === cat);
+}
+function collectTxStyles(masterTree, colors) {
+	const sld = masterTree.find((n) => poIs(n, "p:sldMaster"));
+	const txStyles = sld ? poChildren(sld).find((c) => poIs(c, "p:txStyles")) : void 0;
+	return {
+		title: levelStyles(txStyles, "p:titleStyle", colors),
+		body: levelStyles(txStyles, "p:bodyStyle", colors),
+		other: levelStyles(txStyles, "p:otherStyle", colors)
+	};
+}
+function levelStyles(txStyles, tag, colors) {
+	const style = txStyles ? poChildren(txStyles).find((c) => poIs(c, tag)) : void 0;
+	if (!style) return [];
+	const out = [];
+	for (let lvl = 1; lvl <= 9; lvl++) {
+		const lvlPr = poChildren(style).find((c) => poIs(c, `a:lvl${lvl}pPr`));
+		const defRPr = lvlPr ? poChildren(lvlPr).find((c) => poIs(c, "a:defRPr")) : void 0;
+		out.push(rPrToRunProps(defRPr, colors));
+	}
+	return out;
+}
+//#endregion
+export { buildPlaceholderCascade };

package/dist/esm/pptx/pptx-reader.d.ts

@@ -0,0 +1,4 @@
+import { DocumentReader, ReadResult } from '../core/ir/adapters.js';
+import { FlowDoc } from '../core/ir/flow.js';
+export declare function readPptx(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare const pptxReader: DocumentReader<FlowDoc>;