pptx-ts 0.0.1

package/dist/fit-BKs0zxMI.js

@@ -0,0 +1,1356 @@
+import { d as emuToInches, i as EMU_PER_POINT, x as warn } from "./units-1kRzYShk.js";
+import { n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError } from "./errors-Bvln0H-7.js";
+import { M as LINEH_MODIFIER, a as inch2Emu, i as getSmartParseNumber, s as marginToEmu, u as resolveTableColWidthsEmu, y as DEF_CELL_MARGIN_IN } from "./units-internal-Dg95w_YD.js";
+//#region src/measure/font-collection.ts
+/**
+* Font **collection** (`.ttc` / `.otc`) support for the write-side metrics.
+*
+* A collection is a single file holding several fonts that share their heavy tables.
+* `msgothic.ttc` is three fonts (MS Gothic, MS UI Gothic, MS PGothic) over one 5.5 MB
+* `glyf`; `cambria.ttc` is Cambria plus Cambria Math over one outline set. On Windows
+* that is how most of the East Asian faces ship, and Cambria too, so a measurement API
+* that only reads a bare sfnt cannot measure them at all.
+*
+* `opentype.js` does not read the `ttcf` wrapper (it throws `Unsupported OpenType
+* signature ttcf` from `parseBuffer`, still true in 2.0.0), so this module unwraps one
+* member into a standalone sfnt before handing the bytes over. It parses only the two
+* structures that requires: the table directories and the `name` table.
+*
+* Upstream tracks the gap as opentypejs/opentype.js#379, open since 2019, with #866 an
+* unmerged PR implementing it; check both before rewriting any of this.
+*
+* ## Layout
+*
+* ```text
+* 0    'ttcf'  uint16 major, uint16 minor, uint32 numFonts, uint32 dirOffset[numFonts]
+* ...  per member: uint32 sfntVersion, uint16 numTables, uint16 searchRange,
+*      uint16 entrySelector, uint16 rangeShift, then numTables x 16-byte records
+*      { char tag[4], uint32 checksum, uint32 offset, uint32 length }
+* ```
+*
+* The record `offset` is **absolute from the start of the file**, which is the whole
+* trick: two members name the same `glyf` bytes by pointing at them. So a member does
+* not have to be *copied out* to be read on its own; it is enough to give the reader a
+* buffer whose first bytes are that member's directory, leaving every table where it
+* already sits. See {@link extractFontFace}.
+*/
+/** `'ttcf'`, the tag that marks a font collection. */
+const TTC_TAG = "ttcf";
+/** Bytes in one sfnt table record: tag, checksum, offset, length. */
+const RECORD_SIZE = 16;
+/** Bytes in an sfnt table directory header, before the first record. */
+const DIRECTORY_HEADER_SIZE = 12;
+/** `name` IDs read for face identity: family, subfamily, full name, PostScript name. */
+const NAME_FAMILY = 1;
+const NAME_SUBFAMILY = 2;
+const NAME_FULL = 4;
+const NAME_POSTSCRIPT = 6;
+function view(data) {
+	return new DataView(data.buffer, data.byteOffset, data.byteLength);
+}
+/** Four ASCII bytes at `off` as a string, or `''` when they run past the end. */
+function tagAt(data, off) {
+	if (off < 0 || off + 4 > data.byteLength) return "";
+	let s = "";
+	for (let i = 0; i < 4; i++) s += String.fromCharCode(data[off + i]);
+	return s;
+}
+/** True when `data` starts with the `ttcf` tag, i.e. holds more than one font. */
+function isFontCollection(data) {
+	return tagAt(data, 0) === TTC_TAG;
+}
+/**
+* Offsets of every member's table directory, in file order. A plain sfnt has exactly
+* one, at 0.
+*/
+function directoryOffsets(data) {
+	if (!isFontCollection(data)) return [0];
+	const dv = view(data);
+	if (data.byteLength < 12) throw new MediaError("font/parse-failed", "Font collection header is truncated");
+	const numFonts = dv.getUint32(8);
+	if (numFonts === 0) throw new MediaError("font/parse-failed", "Font collection declares 0 fonts");
+	if (12 + numFonts * 4 > data.byteLength) throw new MediaError("font/parse-failed", `Font collection declares ${numFonts} fonts but the offset table is truncated`);
+	const offsets = [];
+	for (let i = 0; i < numFonts; i++) offsets.push(dv.getUint32(12 + i * 4));
+	return offsets;
+}
+/** Read the table directory at `dirOff`, materializing every record before any write. */
+function readDirectory(data, dirOff) {
+	const dv = view(data);
+	if (dirOff + DIRECTORY_HEADER_SIZE > data.byteLength) throw new MediaError("font/parse-failed", `Font table directory at ${dirOff} is truncated`);
+	const sfntVersion = dv.getUint32(dirOff);
+	const numTables = dv.getUint16(dirOff + 4);
+	if (numTables === 0) throw new MediaError("font/parse-failed", `Font at ${dirOff} declares 0 tables`);
+	if (dirOff + DIRECTORY_HEADER_SIZE + numTables * RECORD_SIZE > data.byteLength) throw new MediaError("font/parse-failed", `Font at ${dirOff} declares ${numTables} tables but the directory is truncated`);
+	const tables = [];
+	for (let i = 0; i < numTables; i++) {
+		const rec = dirOff + DIRECTORY_HEADER_SIZE + i * RECORD_SIZE;
+		tables.push({
+			tag: tagAt(data, rec),
+			checksum: dv.getUint32(rec + 4),
+			offset: dv.getUint32(rec + 8),
+			length: dv.getUint32(rec + 12)
+		});
+	}
+	return {
+		sfntVersion,
+		tables
+	};
+}
+/**
+* Decode one `name` record's string. Windows (platform 3) and Unicode (platform 0)
+* records are UTF-16BE; Macintosh (platform 1) Roman is byte-per-character and
+* coincides with Latin-1 over the ASCII range these names use.
+*/
+function decodeNameString(data, off, length, platformID) {
+	if (off < 0 || off + length > data.byteLength) return "";
+	if (platformID === 1) {
+		let s = "";
+		for (let i = 0; i < length; i++) s += String.fromCharCode(data[off + i]);
+		return s;
+	}
+	let s = "";
+	for (let i = 0; i + 1 < length; i += 2) s += String.fromCharCode(data[off + i] << 8 | data[off + i + 1]);
+	return s;
+}
+/**
+* How much a `name` record is preferred when several carry the same ID. Windows English
+* wins, then any Windows or Unicode record, then Macintosh. The ranking matters because
+* `msgothic.ttc` carries both `'MS Gothic'` (0x409) and the Japanese localized name for
+* the same ID, and a caller selecting by name types the former.
+*/
+function nameRecordRank(platformID, languageID) {
+	if (platformID === 3) return languageID === 1033 ? 3 : 2;
+	if (platformID === 0) return 2;
+	if (platformID === 1) return languageID === 0 ? 1 : 0;
+	return 0;
+}
+/** Read the wanted IDs out of a `name` table, keeping the best-ranked record for each. */
+function readNames(data, base, length) {
+	const out = /* @__PURE__ */ new Map();
+	const ranks = /* @__PURE__ */ new Map();
+	if (base + 6 > data.byteLength || base + length > data.byteLength) return out;
+	const dv = view(data);
+	const count = dv.getUint16(base + 2);
+	const storage = base + dv.getUint16(base + 4);
+	for (let i = 0; i < count; i++) {
+		const rec = base + 6 + i * 12;
+		if (rec + 12 > data.byteLength) break;
+		const nameID = dv.getUint16(rec + 6);
+		if (nameID !== NAME_FAMILY && nameID !== NAME_SUBFAMILY && nameID !== NAME_FULL && nameID !== NAME_POSTSCRIPT) continue;
+		const platformID = dv.getUint16(rec);
+		const rank = nameRecordRank(platformID, dv.getUint16(rec + 4));
+		if (rank <= (ranks.get(nameID) ?? -1)) continue;
+		const text = decodeNameString(data, storage + dv.getUint16(rec + 10), dv.getUint16(rec + 8), platformID);
+		if (!text) continue;
+		out.set(nameID, text);
+		ranks.set(nameID, rank);
+	}
+	return out;
+}
+/**
+* The fonts inside `data`, in file order. A plain TTF/OTF yields exactly one entry, so a
+* caller never has to branch on the container format.
+*
+* Identity comes from each member's own `name` table, which is one of the tables a
+* collection does *not* share. A field is absent when the table carries no readable
+* record for it; a font whose `name` table is missing or malformed still yields an entry
+* (with only `index`), because the metrics do not depend on it.
+* @param {Uint8Array} data - the font file's bytes
+* @returns {FontFaceInfo[]} one entry per font, index-ordered
+* @example listFontFaces(readFileSync('C:/Windows/Fonts/msgothic.ttc')).map((f) => f.family)
+*/
+function listFontFaces(data) {
+	return directoryOffsets(data).map((dirOff, index) => {
+		const { tables } = readDirectory(data, dirOff);
+		const name = tables.find((t) => t.tag === "name");
+		const names = name ? readNames(data, name.offset, name.length) : /* @__PURE__ */ new Map();
+		const family = names.get(NAME_FAMILY);
+		const subfamily = names.get(NAME_SUBFAMILY);
+		const fullName = names.get(NAME_FULL);
+		const postScriptName = names.get(NAME_POSTSCRIPT);
+		return {
+			index,
+			...family ? { family } : {},
+			...subfamily ? { subfamily } : {},
+			...fullName ? { fullName } : {},
+			...postScriptName ? { postScriptName } : {}
+		};
+	});
+}
+/** A face's names, lowercased, for case-insensitive selection. */
+function selectableNames(face) {
+	return [
+		face.family,
+		face.fullName,
+		face.postScriptName
+	].filter((n) => typeof n === "string" && n.length > 0).map((n) => n.toLowerCase());
+}
+/** Render the available faces for an error message, e.g. ``0 `MS Gothic`, 1 `MS PGothic` ``. */
+function describeFaces(faces) {
+	return faces.map((f) => `${f.index} \`${f.family ?? f.fullName ?? "(unnamed)"}\``).join(", ");
+}
+/**
+* Resolve a `font` selector against the faces in `data`.
+*
+* The selector means the same thing whatever the container: a plain TTF/OTF is a
+* one-entry list, so `{ font: 1 }` or a name that does not match is an error there too
+* rather than being quietly ignored. Silently falling back to the only/first font is the
+* failure mode worth refusing: it measures one face's advances while the caller believes
+* it registered another's, and nothing downstream can tell.
+* @param {Uint8Array} data - the font file's bytes
+* @param {number | string} [font] - 0-based index, or a name matched case-insensitively
+*   against the family, full, and PostScript names. Absent selects index 0.
+* @returns {number} the index of the selected font
+*/
+function resolveFontFace(data, font) {
+	if (font === void 0) return 0;
+	const faces = listFontFaces(data);
+	if (typeof font === "number") {
+		if (!Number.isInteger(font) || font < 0 || font >= faces.length) throw new InvalidOptionError("font/collection-index-out-of-range", `Font index ${font} is out of range: the file holds ${faces.length} font(s) (${describeFaces(faces)})`);
+		return font;
+	}
+	const wanted = font.toLowerCase();
+	const hit = faces.find((f) => selectableNames(f).includes(wanted));
+	if (!hit) throw new InvalidOptionError("font/collection-face-not-found", `No font named "${font}" in this file. It holds: ${describeFaces(faces)}`);
+	return hit.index;
+}
+/**
+* Bytes for one font of `data` as a standalone sfnt, ready for a parser that does not
+* read the `ttcf` wrapper.
+*
+* A plain TTF/OTF at index 0 is returned as-is. For a collection the member's tables are
+* **not copied out**: the file is copied once and the member's directory is written over
+* the prologue at offset 0, so every record keeps the absolute offset it already had and
+* the shared `glyf` is neither duplicated nor moved. The prologue is always large enough
+* to hold that directory, because a well-formed collection places the first table after
+* the `ttcf` header *and* every member's directory, which already includes this one.
+* That is asserted rather than assumed: a file that violates it would otherwise have its
+* first table silently overwritten.
+* @param {Uint8Array} data - the font file's bytes
+* @param {number} index - which font, as resolved by {@link resolveFontFace}
+* @returns {Uint8Array} a buffer whose first bytes are a plain sfnt table directory
+*/
+function extractFontFace(data, index) {
+	const offsets = directoryOffsets(data);
+	const dirOff = offsets[index];
+	if (dirOff === void 0) throw new InvalidOptionError("font/collection-index-out-of-range", `Font index ${index} is out of range: the file holds ${offsets.length} font(s)`);
+	if (!isFontCollection(data)) return data;
+	const { sfntVersion, tables } = readDirectory(data, dirOff);
+	const prologue = DIRECTORY_HEADER_SIZE + tables.length * RECORD_SIZE;
+	const firstTable = Math.min(...tables.map((t) => t.offset));
+	if (prologue > firstTable) throw new MediaError("font/parse-failed", `Font ${index} in this collection cannot be unwrapped: its ${tables.length}-table directory needs ${prologue} bytes but the first table starts at ${firstTable}`);
+	const out = new Uint8Array(data);
+	const dv = new DataView(out.buffer, out.byteOffset, out.byteLength);
+	const entrySelector = Math.floor(Math.log2(tables.length));
+	const searchRange = RECORD_SIZE * 2 ** entrySelector;
+	dv.setUint32(0, sfntVersion);
+	dv.setUint16(4, tables.length);
+	dv.setUint16(6, searchRange);
+	dv.setUint16(8, entrySelector);
+	dv.setUint16(10, tables.length * RECORD_SIZE - searchRange);
+	let p = DIRECTORY_HEADER_SIZE;
+	for (const t of tables) {
+		for (let i = 0; i < 4; i++) out[p + i] = t.tag.charCodeAt(i) & 255;
+		dv.setUint32(p + 4, t.checksum);
+		dv.setUint32(p + 8, t.offset);
+		dv.setUint32(p + 12, t.length);
+		p += RECORD_SIZE;
+	}
+	return out;
+}
+//#endregion
+//#region src/measure/font-metrics.ts
+/**
+* Write-side font metrics.
+*
+* Provides per-glyph advance widths for measured text fit (see `text-fit.ts`).
+* The library has no write-side font registration otherwise; consumers register
+* a face's font file via `pptx.registerFontMetrics(...)` and the measured-fit
+* pass uses these advances to compute a baked `fontScale` for `fit: 'shrink'`.
+*
+* Width is summed from **raw `hmtx` advances with no kerning/shaping** (GPOS/GSUB
+* are deliberately ignored): kerning almost always narrows a line, so raw advances
+* over-estimate width — the conservative direction (shrink a touch too much, never
+* overflow). See `docs/measured-text-fit.md` ("Font metrics provider").
+*/
+var OpentypeFontMetrics = class {
+	font;
+	constructor(font) {
+		this.font = font;
+	}
+	get unitsPerEm() {
+		return this.font.unitsPerEm;
+	}
+	advanceWidthPt(text, sizePt, charSpacingPt = 0) {
+		if (!text) return 0;
+		const scale = sizePt / this.font.unitsPerEm;
+		let width = 0;
+		let count = 0;
+		for (const ch of text) {
+			const glyph = this.font.charToGlyph(ch);
+			width += (glyph?.advanceWidth ?? 0) * scale;
+			count++;
+		}
+		if (charSpacingPt) width += charSpacingPt * count;
+		return width;
+	}
+	hasCodepoint(cp) {
+		return this.font.hasChar(String.fromCodePoint(cp));
+	}
+};
+const HEURISTIC_UNITS_PER_EM = 1e3;
+/**
+* Advance width of an ASCII/Unicode code point as a fraction of em, for the
+* unregistered-font fallback. Values are biased to **over-estimate** a typical
+* proportional Latin face: over-estimating width is the conservative direction for
+* both solvers (shrink a touch too much / grow a touch too tall, never overflow).
+* Non-Latin code points are treated as full-em (safe for CJK, which is otherwise
+* out of scope; slightly over-wide for accented Latin, which is harmless).
+*/
+function heuristicCharRatio(ch) {
+	const cp = ch.codePointAt(0) ?? 0;
+	if (cp > 11903) return 1;
+	if (cp > 255) return .62;
+	if (ch === " " || ch === "	") return .3;
+	if ("ijl.,'`!|:;".includes(ch)) return .3;
+	if ("ftr()[]{}/\\I".includes(ch)) return .4;
+	if (ch === "m" || ch === "w") return .9;
+	if (ch === "M" || ch === "W") return .98;
+	if (ch === "@" || ch === "%") return 1;
+	if (ch >= "A" && ch <= "Z") return .72;
+	return .58;
+}
+var HeuristicFontMetrics = class {
+	unitsPerEm = HEURISTIC_UNITS_PER_EM;
+	advanceWidthPt(text, sizePt, charSpacingPt = 0) {
+		if (!text) return 0;
+		let width = 0;
+		let count = 0;
+		for (const ch of text) {
+			width += heuristicCharRatio(ch) * sizePt;
+			count++;
+		}
+		if (charSpacingPt) width += charSpacingPt * count;
+		return width;
+	}
+	hasCodepoint() {
+		return true;
+	}
+};
+let heuristicSingleton;
+/**
+* Shared, font-independent `FontMetrics` used when a named face has no registered
+* metrics but the deck has opted into measured fit (some other face is registered).
+* Approximate but conservative — see {@link heuristicCharRatio}. A deck with no
+* registered metrics at all does not engage measured fit, so this never fires there.
+*/
+function getHeuristicFontMetrics() {
+	if (!heuristicSingleton) heuristicSingleton = new HeuristicFontMetrics();
+	return heuristicSingleton;
+}
+/**
+* Parse a font file into a `FontMetrics`. Lazily imports opentype.js.
+*
+* Reads plain TTF/OTF and **font collections** (`.ttc`/`.otc`); for a collection, pass
+* `font` to say which member, since a collection has no single answer. The underlying
+* parser does not read the `ttcf` wrapper, so the selected member is unwrapped into a
+* standalone sfnt first (see `measure/font-collection.ts`).
+* @param {Uint8Array} data - the font file's bytes
+* @param {ParseFontMetricsOptions} [opts] - which font, for a file holding several
+* @returns {Promise<FontMetrics>} advance widths and cmap coverage for that font
+* @example await parseFontMetrics(bytes) // a plain .ttf
+* @example await parseFontMetrics(ttcBytes, { font: 'MS PGothic' })
+*/
+async function parseFontMetrics(data, opts) {
+	const mod = await import("opentype.js");
+	const parse = mod.parse ?? mod.default?.parse;
+	if (typeof parse !== "function") throw new UnsupportedFeatureError("font/opentype-unavailable", "opentype.js: parse() not found in module exports");
+	const sfnt = extractFontFace(data, resolveFontFace(data, opts?.font));
+	const buf = sfnt.buffer.slice(sfnt.byteOffset, sfnt.byteOffset + sfnt.byteLength);
+	try {
+		return new OpentypeFontMetrics(parse(buf));
+	} catch (ex) {
+		throw new MediaError("font/parse-failed", `Unable to parse font file: ${String(ex)}`, { cause: ex });
+	}
+}
+/**
+* Registry of `FontMetrics` keyed by `(face, bold, italic)`. Variant advances
+* differ, so bold/italic are stored separately; lookup falls back to the regular
+* variant (then any registered variant of the face) so a deck that only registers
+* the regular weight still measures bold runs approximately rather than not at all.
+*/
+var FontMetricsRegistry = class {
+	map = /* @__PURE__ */ new Map();
+	key(face, bold, italic) {
+		return `${face.toLowerCase()}\0${bold ? 1 : 0}\0${italic ? 1 : 0}`;
+	}
+	set(face, metrics, opts) {
+		this.map.set(this.key(face, !!opts?.bold, !!opts?.italic), metrics);
+	}
+	/** True if any variant of `face` has registered metrics. */
+	hasFace(face) {
+		const prefix = `${face.toLowerCase()}\0`;
+		for (const k of this.map.keys()) if (k.startsWith(prefix)) return true;
+		return false;
+	}
+	/**
+	* Coverage of code point `cp` for `face`, read from the registered font's cmap:
+	* `true`/`false` when a variant of `face` is registered (see {@link get} for the
+	* exact→regular→any-variant fallback), or `undefined` when the face has **no**
+	* registered metrics — "unknown", deliberately distinct from a `false`
+	* "registered but not covered". A coverage audit must not treat an unregistered
+	* face as fully covered, so callers get `undefined` here rather than the per-face
+	* {@link FontMetrics.hasCodepoint} boolean (which, for the heuristic fallback,
+	* always reports covered). Register the face via {@link parseFontMetrics} +
+	* {@link set} first.
+	*/
+	hasCodepoint(face, cp, opts) {
+		return this.get(face, opts?.bold, opts?.italic)?.hasCodepoint(cp);
+	}
+	/** Resolve metrics for a run, falling back from exact variant → regular → any variant. */
+	get(face, bold = false, italic = false) {
+		if (typeof face !== "string" || face.length === 0) return void 0;
+		const exact = this.map.get(this.key(face, bold, italic));
+		if (exact) return exact;
+		const regular = this.map.get(this.key(face, false, false));
+		if (regular) return regular;
+		const prefix = `${face.toLowerCase()}\0`;
+		for (const [k, v] of this.map) if (k.startsWith(prefix)) return v;
+	}
+	get size() {
+		return this.map.size;
+	}
+};
+/**
+* A {@link MetricsResolver} backed by a registry: exact metrics for a registered face, otherwise
+* the shared heuristic fallback (with `onHeuristic` told which face it stood in for). A run with
+* no `fontFace` at all resolves to `undefined`, which the callers treat as unmeasurable.
+*/
+function makeRegistryResolver(registry, onHeuristic) {
+	return (run) => {
+		const exact = registry.get(run.fontFace, run.bold, run.italic);
+		if (exact) return exact;
+		if (typeof run.fontFace === "string" && run.fontFace.length > 0) {
+			onHeuristic?.(run.fontFace);
+			return getHeuristicFontMetrics();
+		}
+	};
+}
+/**
+* Accumulate, per face, the code points `paragraphs` uses that the run's **registered**
+* metrics have no glyph for.
+*
+* This is the one thing the width arithmetic cannot see. PowerPoint substitutes another
+* face per code point and lays the run out in *that* font's advances; the model has no
+* fallback and charges the registered font's `.notdef` advance instead, which is a single
+* flat number unrelated to the glyph that actually paints. Unlike the other approximations
+* here it is **not** conservative in a fixed direction: a `.notdef` wider than the real
+* glyph over-reports (a phantom line — safe), a narrower one under-reports and can drop a
+* line, which is the overflow direction the resize bake has no safety net for. So it is
+* surfaced rather than absorbed — see `docs/measured-text-fit.md` ("No font fallback").
+*
+* Runs whose face has no registered metrics at all are skipped: they measure through the
+* cmap-less heuristic, which has no coverage to report, and the caller already flags them
+* as approximated faces.
+* @param paragraphs - the runs to audit, as handed to the layout
+* @param registry - the metrics the layout resolved against
+* @param into - face → uncovered code points, added to in place
+*/
+function collectUncoveredCodepoints(paragraphs, registry, into) {
+	for (const para of paragraphs) for (const run of para.runs) {
+		const face = run.fontFace;
+		if (typeof face !== "string" || face.length === 0) continue;
+		const metrics = registry.get(face, run.bold, run.italic);
+		if (!metrics) continue;
+		let missing;
+		for (const ch of run.text) {
+			const cp = ch.codePointAt(0);
+			if (cp === void 0 || metrics.hasCodepoint(cp)) continue;
+			missing ??= into.get(face) ?? /* @__PURE__ */ new Set();
+			missing.add(cp);
+		}
+		if (missing) into.set(face, missing);
+	}
+}
+//#endregion
+//#region src/measure/text-fit.ts
+/**
+* PowerPoint single-spacing line pitch as a multiple of font size.
+*
+* Calibrated from `autofit-calibration.json` (Deck 1, `autofit-line-metrics`):
+* the per-line `cy` delta is a **font-independent** 1.2117× at 12/18/32 pt across
+* {Aptos, Aptos SemiBold, Calibri, Tahoma, Arial}, and PowerPoint vs LibreOffice
+* agree to ≤ 0.041 pt. See `test/read/fixtures/README.md` → "Findings" #1–#2.
+*/
+const SINGLE_LINE_PITCH = 1.2117;
+/** PowerPoint's `fontScale` search grid: discrete 2.5% steps (Findings #3). */
+const FONT_SCALE_STEP_PCT = 2.5;
+/** Floor for the shrink search (see `docs/measured-text-fit.md` → Solvers). */
+const MIN_FONT_SCALE_PCT = 25;
+/**
+* Conservative safety factors applied by the shrink solver (not by the pure
+* `measureHeightPt`). Raw `hmtx` advances summed without shaping still pack a line
+* a little tighter than PowerPoint, which lays text out at a device DPI and rounds
+* each glyph advance up — so PowerPoint wraps marginally earlier and its fitted
+* box is marginally taller. Inflating measured width and height by these factors
+* makes the computed `fontScale` ≤ PowerPoint's across the calibration oracle
+* (`test/read/autofit-calibration-oracle.test.js`: 0 violations over the Aptos
+* cases). They err on the side of shrinking slightly too much, never overflowing.
+*/
+const WIDTH_SAFETY_FACTOR = 1.03;
+const HEIGHT_SAFETY_FACTOR = 1.04;
+const isWhitespace = (ch) => ch === " " || ch === "	" || ch === "\xA0" || /\s/.test(ch);
+/**
+* A code point that is its own wrap opportunity: a line may break either side of
+* it, with no whitespace involved. Latin words break only at whitespace, but
+* Chinese and Japanese text breaks between any two characters, so treating one
+* long run of them as a single unbreakable "word" moves the whole run to the next
+* line, over-reports the laid-out line count, and shrinks text that actually fits.
+*
+* **Hangul is deliberately absent.** UAX #14 makes Hangul breakable between
+* syllables, but PowerPoint does not: Korean is written with spaces between words
+* and the app breaks it like Latin. `autofit-cjk-wrap.pptx` pins that directly —
+* the same box that lays out in 2 lines in Han or Kana takes 3 in Hangul, because
+* the run moves down whole. A Hangul run longer than one line still breaks between
+* syllables, but that is the over-long-token character-wrap fallback in
+* `countLines`, which handles it without a break class. Adding Hangul here would
+* *under*-report the line count for Korean, which is the direction that overflows.
+*
+* Backed by `autofit-cjk-wrap.pptx` (PowerPoint-authored, one case per claim):
+* CJK Unified Ideographs, Hiragana/Katakana, fullwidth Latin, halfwidth Katakana
+* and Plane 2 all break per character; Hangul syllables do not. The remaining
+* ranges are the sibling blocks of the same UAX #14 class ID, generalized from
+* those cases rather than pinned one by one.
+*
+* Known gap: no kinsoku (line-break prohibition) rules. PowerPoint will not start
+* a line with `。` or `、` and hangs them past the right inset instead; this model
+* breaks before them. That is a widest-line difference, not a line-count one, and
+* `docs/measured-text-fit.md` records it.
+*/
+function isCjkBreakCharacter(ch) {
+	const cp = ch.codePointAt(0) ?? 0;
+	return cp >= 11904 && cp <= 12351 || cp >= 12352 && cp <= 12543 || cp >= 12544 && cp <= 12591 || cp >= 12688 && cp <= 12703 || cp >= 12704 && cp <= 12799 || cp >= 12800 && cp <= 19903 || cp >= 19968 && cp <= 40959 || cp >= 63744 && cp <= 64255 || cp >= 65040 && cp <= 65055 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65439 || cp >= 65504 && cp <= 65519 || cp >= 110592 && cp <= 110959 || cp >= 131072 && cp <= 196605 || cp >= 196608 && cp <= 205743;
+}
+/**
+* Tokenize one paragraph at a given `fontScalePct`. Words can span run boundaries
+* (a break is only allowed at whitespace, or either side of a per-character
+* breaking code point — see `isCjkBreakCharacter`). Returns `null` if any run's
+* face has no registered metrics (the paragraph cannot be measured).
+*/
+function tokenizeParagraph(para, resolve, fontScalePct, widthSafety) {
+	const tokens = [];
+	let curWord = null;
+	const flushWord = () => {
+		if (curWord) {
+			tokens.push(curWord);
+			curWord = null;
+		}
+	};
+	for (const run of para.runs) {
+		const metrics = resolve(run);
+		if (!metrics) return null;
+		const scaledSize = run.sizePt * (fontScalePct / 100);
+		const charSpacingPt = run.charSpacingPt ?? 0;
+		for (const ch of run.text ?? "") if (ch === "\n") {
+			flushWord();
+			tokens.push({
+				kind: "newline",
+				w: 0
+			});
+		} else if (isWhitespace(ch)) {
+			flushWord();
+			const w = metrics.advanceWidthPt(ch === "	" ? " " : ch, scaledSize, charSpacingPt) * widthSafety;
+			tokens.push({
+				kind: "space",
+				w
+			});
+		} else {
+			const w = metrics.advanceWidthPt(ch, scaledSize, charSpacingPt) * widthSafety;
+			if (isCjkBreakCharacter(ch)) {
+				flushWord();
+				tokens.push({
+					kind: "word",
+					w,
+					charWidths: [w]
+				});
+				continue;
+			}
+			if (!curWord) curWord = {
+				kind: "word",
+				w: 0,
+				charWidths: []
+			};
+			curWord.w += w;
+			curWord.charWidths.push(w);
+		}
+	}
+	flushWord();
+	return tokens;
+}
+/**
+* Greedy `wrap=square` line layout: the wrapped line count plus the widest
+* laid-out line width. `maxLineWidthPt` tracks the running line width and records
+* it whenever a line completes (a wrap or the final line), so callers can measure
+* the actual text extent, not just the box width. Trailing whitespace counts
+* toward width (Findings #7), which slightly over-reports — the conservative
+* direction, consistent with the wrap model erring wide.
+*/
+function countLines(tokens, innerWidthPt) {
+	let lines = 1;
+	let lineW = 0;
+	let maxLineWidthPt = 0;
+	const finishLine = () => {
+		if (lineW > maxLineWidthPt) maxLineWidthPt = lineW;
+	};
+	for (const tok of tokens) if (tok.kind === "newline") {
+		finishLine();
+		lines++;
+		lineW = 0;
+	} else if (tok.kind === "space") {
+		if (lineW + tok.w > innerWidthPt && lineW > 0) {
+			finishLine();
+			lines++;
+			lineW = 0;
+		} else lineW += tok.w;
+	} else if (tok.w <= innerWidthPt) {
+		if (lineW + tok.w > innerWidthPt && lineW > 0) {
+			finishLine();
+			lines++;
+			lineW = tok.w;
+		} else lineW += tok.w;
+	} else {
+		if (lineW > 0) {
+			finishLine();
+			lines++;
+			lineW = 0;
+		}
+		for (const cw of tok.charWidths) if (lineW + cw > innerWidthPt && lineW > 0) {
+			finishLine();
+			lines++;
+			lineW = cw;
+		} else lineW += cw;
+	}
+	finishLine();
+	return {
+		lines,
+		maxLineWidthPt
+	};
+}
+/** Max run size in a paragraph (line height follows the tallest run — Findings #7). */
+function maxRunSizePt(para) {
+	let max = 0;
+	for (const run of para.runs) if (run.sizePt > max) max = run.sizePt;
+	return max;
+}
+/**
+* Lay out `paragraphs` at a given scale/reduction and return the total height
+* (points) and wrapped line count, or `null` if any paragraph is unmeasurable.
+* Errs tall (conservative): includes space-before/after and the calibrated line
+* pitch. The single source of truth for both {@link measureHeightPt} (the solvers)
+* and the public layout-time measure API.
+*/
+function measureLayout(paragraphs, innerWidthPt, resolve, fontScalePct, lnSpcReductionPct, widthSafety = 1) {
+	if (innerWidthPt <= 0) return null;
+	let total = 0;
+	let lineCount = 0;
+	let widestLineWidthPt = 0;
+	for (const para of paragraphs) {
+		const tokens = tokenizeParagraph(para, resolve, fontScalePct, widthSafety);
+		if (tokens === null) return null;
+		const { lines, maxLineWidthPt } = countLines(tokens, innerWidthPt);
+		lineCount += lines;
+		if (maxLineWidthPt > widestLineWidthPt) widestLineWidthPt = maxLineWidthPt;
+		const scaledMax = maxRunSizePt(para) * (fontScalePct / 100);
+		let lineHeight = para.lineSpacingPts != null && para.lineSpacingPts > 0 ? para.lineSpacingPts : SINGLE_LINE_PITCH * scaledMax * ((para.lineSpacingPct ?? 100) / 100);
+		lineHeight *= 1 - lnSpcReductionPct / 100;
+		total += lines * lineHeight + (para.spaceBeforePts ?? 0) + (para.spaceAfterPts ?? 0);
+	}
+	return {
+		heightPt: total,
+		lineCount,
+		widestLineWidthPt
+	};
+}
+/**
+* Total laid-out height (points) at a given scale/reduction, or `null` if any
+* paragraph is unmeasurable. Thin wrapper over {@link measureLayout}.
+*/
+function measureHeightPt(paragraphs, innerWidthPt, resolve, fontScalePct, lnSpcReductionPct, widthSafety = 1) {
+	const result = measureLayout(paragraphs, innerWidthPt, resolve, fontScalePct, lnSpcReductionPct, widthSafety);
+	return result === null ? null : result.heightPt;
+}
+/**
+* Inner height (points) the text needs at full size — the value to bake into the
+* shape's `a:ext/@cy` for `fit: 'resize'` (`spAutoFit`). Unlike shrink, resize has
+* **no safety net**: an under-estimate overflows (there is no text scaling
+* fallback), so this errs **tall** — width is inflated (earlier wrap ⇒ more lines)
+* and the laid-out height by the calibrated height factor, so the computed `cy` is
+* ≥ PowerPoint's and ≥ the LibreOffice-rendered height across the resize oracle.
+*/
+/**
+* Width used for wrap layout: the inner box width when wrapping, or unbounded for a
+* non-wrapping frame (`wrap:false`) so each paragraph lays out as a single line. A
+* non-wrapping frame's width constraint is enforced separately, against the widest
+* laid-out line — see {@link solveShrink}.
+*/
+function layoutWidthPt(box) {
+	return box.wrap === false ? Infinity : box.innerWidthPt;
+}
+function solveResize(paragraphs, box, resolve) {
+	const h = measureHeightPt(paragraphs, layoutWidthPt(box), resolve, 100, 0, WIDTH_SAFETY_FACTOR);
+	if (h === null) return { kind: "unmeasurable" };
+	return {
+		kind: "resize",
+		neededInnerHeightPt: h * HEIGHT_SAFETY_FACTOR
+	};
+}
+function solveShrink(paragraphs, box, resolve) {
+	const width = layoutWidthPt(box);
+	const noWrap = box.wrap === false;
+	const fits = (scale) => {
+		const layout = measureLayout(paragraphs, width, resolve, scale, 0, WIDTH_SAFETY_FACTOR);
+		if (layout === null) return null;
+		if (layout.heightPt * 1.04 > box.innerHeightPt) return false;
+		if (noWrap && layout.widestLineWidthPt > box.innerWidthPt) return false;
+		return true;
+	};
+	const at100 = fits(100);
+	if (at100 === null) return { kind: "unmeasurable" };
+	if (at100) return { kind: "fits" };
+	for (let scale = 97.5; scale >= 25; scale -= FONT_SCALE_STEP_PCT) if (fits(scale)) return {
+		kind: "shrink",
+		result: {
+			fontScalePct: scale,
+			lnSpcReductionPct: 0
+		}
+	};
+	return {
+		kind: "shrink",
+		result: {
+			fontScalePct: 25,
+			lnSpcReductionPct: 0
+		}
+	};
+}
+//#endregion
+//#region src/measure/paragraphs.ts
+/**
+* ts-pptx: turning a slide text object into the simulator's inputs
+*
+* The lower half of the measured-fit pass: normalize a text object's runs into `FitParagraph`s,
+* resolve its body insets and box, and work out how a height change is shared between `off.y` and
+* `ext.cy` for a given anchor. Everything here is about *reading* an authored object; the solving
+* and the rewriting live in the siblings (`table-fit.ts`, `fit.ts`).
+*/
+const DEF_INS_LR_EMU = 91440;
+const DEF_INS_TB_EMU = 45720;
+const CRLF_RE = /\r*\n/g;
+/** Normalize `slideObj.text` (string | TextProps | TextProps[]) to a run list. */
+function normalizeRuns(obj) {
+	const opts = obj.options ?? {};
+	const text = obj.text;
+	if (text == null) return [];
+	if (typeof text === "string" || typeof text === "number") return [{
+		text: String(text),
+		options: opts
+	}];
+	if (!Array.isArray(text) && typeof text === "object" && "text" in text) {
+		const t = text;
+		return [{
+			text: t.text,
+			options: t.options ?? opts
+		}];
+	}
+	if (Array.isArray(text)) return text.map((t) => ({
+		text: t.text,
+		options: t.options ?? opts
+	}));
+	return [];
+}
+/** Build a measurable `FitParagraph[]` from a text object, or null if not measurable. */
+function extractParagraphs(obj) {
+	const opts = obj.options ?? {};
+	const runs = normalizeRuns(obj);
+	if (runs.length === 0) return null;
+	return buildFitParagraphs(runs, opts);
+}
+/**
+* Convert a run list (+ box-level default options) into a measurable
+* `FitParagraph[]`, or null if empty. The single converter shared by the
+* export-time pass ({@link extractParagraphs}) and the public layout-time
+* `measureText` API, so a layout-time prediction and the baked export never drift.
+*/
+function buildFitParagraphs(runs, opts) {
+	if (runs.length === 0) return null;
+	const pieces = [];
+	for (const run of runs) {
+		const ro = run.options ?? opts;
+		const raw = String(run.text ?? "").replace(CRLF_RE, "\n");
+		if (raw.includes("\n")) {
+			const lines = raw.split("\n");
+			lines.forEach((line, i) => {
+				const isLast = i === lines.length - 1;
+				pieces.push({
+					text: line,
+					options: ro,
+					breakAfter: isLast ? !!ro.breakLine : true
+				});
+			});
+		} else pieces.push({
+			text: raw,
+			options: ro,
+			breakAfter: !!ro.breakLine
+		});
+	}
+	const toRun = (p) => {
+		const ro = p.options;
+		const sizePt = Number(ro.fontSize ?? opts.fontSize ?? 12);
+		return {
+			text: p.text,
+			sizePt: Number.isFinite(sizePt) && sizePt > 0 ? sizePt : 12,
+			bold: !!(ro.bold ?? opts.bold),
+			italic: !!(ro.italic ?? opts.italic),
+			fontFace: ro.fontFace ?? opts.fontFace,
+			charSpacingPt: (ro.charSpacing ?? opts.charSpacing) || void 0
+		};
+	};
+	const toPara = (runsForPara, paraOpts) => {
+		const lineSpacing = paraOpts.lineSpacing ?? opts.lineSpacing;
+		const lineSpacingMultiple = paraOpts.lineSpacingMultiple ?? opts.lineSpacingMultiple;
+		return {
+			runs: runsForPara,
+			lineSpacingPts: typeof lineSpacing === "number" && lineSpacing > 0 ? lineSpacing : void 0,
+			lineSpacingPct: typeof lineSpacingMultiple === "number" && lineSpacingMultiple > 0 ? lineSpacingMultiple * 100 : 100,
+			spaceBeforePts: Number(paraOpts.paraSpaceBefore ?? opts.paraSpaceBefore ?? 0) || 0,
+			spaceAfterPts: Number(paraOpts.paraSpaceAfter ?? opts.paraSpaceAfter ?? 0) || 0
+		};
+	};
+	const paras = [];
+	let cur = [];
+	let curParaOpts = opts;
+	for (const piece of pieces) {
+		cur.push(toRun(piece));
+		curParaOpts = piece.options;
+		if (piece.breakAfter) {
+			paras.push(toPara(cur, curParaOpts));
+			cur = [];
+		}
+	}
+	if (cur.length > 0) paras.push(toPara(cur, curParaOpts));
+	return paras.length > 0 ? paras : null;
+}
+/** Resolve text-frame insets (EMU): explicit `_bodyProp` (from `inset`) → `margin` → PowerPoint defaults. */
+function resolveInsetsEmu(opts) {
+	const bp = opts._bodyProp ?? {};
+	const margin = opts.margin;
+	let lIns = bp.lIns;
+	let rIns = bp.rIns;
+	let tIns = bp.tIns;
+	let bIns = bp.bIns;
+	if (lIns == null && rIns == null && tIns == null && bIns == null && margin != null) {
+		if (Array.isArray(margin)) {
+			tIns = marginToEmu(margin[0] ?? 0);
+			rIns = marginToEmu(margin[1] ?? 0);
+			bIns = marginToEmu(margin[2] ?? 0);
+			lIns = marginToEmu(margin[3] ?? 0);
+		} else if (typeof margin === "number") lIns = rIns = tIns = bIns = marginToEmu(margin);
+	}
+	return {
+		lIns: lIns ?? DEF_INS_LR_EMU,
+		rIns: rIns ?? DEF_INS_LR_EMU,
+		tIns: tIns ?? DEF_INS_TB_EMU,
+		bIns: bIns ?? DEF_INS_TB_EMU
+	};
+}
+/**
+* Resolve the inner box (shape minus insets) in points; null if degenerate.
+*
+* Reads the object's own `opts.w/h` with no ancestor walk — correct only because a group keeps an
+* identity child coordinate space (`chOff/chExt == off/ext`, see the `gen/slide/object.ts` group renderer and
+* `docs/groups.md`), so a group never scales its children and a grouped text box's authored w/h is its
+* true rendered size. `applyMeasuredFit` reaches here for grouped text via its explicit group descent
+* (`measureObject`). If `addGroup` ever authored a scaled group (non-identity `chExt`), this would need
+* the same ancestor-scale composition `Shape.absoluteFrame` performs on the read path.
+*/
+function computeBox(obj, presLayout) {
+	const opts = obj.options ?? {};
+	const wEmu = getSmartParseNumber(opts.w, "X", presLayout);
+	const hEmu = getSmartParseNumber(opts.h, "Y", presLayout);
+	if (!(wEmu > 0) || !(hEmu > 0)) return null;
+	const { lIns, rIns, tIns, bIns } = resolveInsetsEmu(opts);
+	const wrap = (opts._bodyProp ?? {}).wrap !== false;
+	const innerWidthPt = (wEmu - lIns - rIns) / EMU_PER_POINT;
+	const innerHeightPt = (hEmu - tIns - bIns) / EMU_PER_POINT;
+	if (!(innerHeightPt > 0)) return null;
+	if (!(innerWidthPt > 0)) return null;
+	return {
+		innerWidthPt,
+		innerHeightPt,
+		wrap
+	};
+}
+/** Vertical-anchor share of a height change that moves the box top up (`off.y` shift). */
+function anchorTopShareOfDelta(opts) {
+	const anchor = (opts._bodyProp ?? {}).anchor;
+	if (anchor === "t") return 0;
+	if (anchor === "b") return 1;
+	return .5;
+}
+/** Text/format options that a cell inherits from the table when it sets none itself (mirrors `gen/slide/objects/table.ts`). */
+//#endregion
+//#region src/measure/table-fit.ts
+/**
+* ts-pptx: measuring a table's row heights and cell fits
+*
+* A table is measured cell by cell against its resolved grid: each cell inherits the table's text
+* options where it sets none, gets its own margins resolved to EMU insets, and is laid out inside
+* the column span it actually occupies. A merged region is measured once, at its origin, across
+* the columns it covers — which is what `walkTableGrid` exists to hand out.
+*/
+const CELL_INHERIT_KEYS = [
+	"fontFace",
+	"fontSize",
+	"bold",
+	"italic",
+	"charSpacing",
+	"align",
+	"lineSpacing",
+	"lineSpacingMultiple",
+	"valign",
+	"margin"
+];
+/** Effective cell options: the cell's own values, with table-level values filled in where unset. */
+function effectiveCellOpts(cellOpts, tableOpts) {
+	const merged = { ...cellOpts };
+	for (const k of CELL_INHERIT_KEYS) if (merged[k] === void 0 && tableOpts[k] !== void 0) merged[k] = tableOpts[k];
+	return merged;
+}
+/** Resolve a cell's margins to EMU insets, mirroring `gen/slide/objects/table.ts` (array is `[T,R,B,L]`, inches; see `marginToEmu`). */
+function resolveCellInsetsEmu(margin) {
+	let m = margin === 0 || margin ? margin : DEF_CELL_MARGIN_IN;
+	if (typeof m === "number") m = [
+		m,
+		m,
+		m,
+		m
+	];
+	if (!Array.isArray(m) || m.length !== 4 || m.some((v) => typeof v !== "number" || !isFinite(v))) m = DEF_CELL_MARGIN_IN;
+	const arr = m;
+	return {
+		marT: marginToEmu(arr[0]),
+		marR: marginToEmu(arr[1]),
+		marB: marginToEmu(arr[2]),
+		marL: marginToEmu(arr[3])
+	};
+}
+/**
+* Bake a reduced font size onto a cell's runs by factor `f` (< 1). Clones every
+* options object before mutating: a plain-string cell shares the table's `opt`
+* object (`gen/define/`), so in-place mutation would corrupt every other such cell.
+*/
+function scaleCellFontSizes(cell, eff, f) {
+	const shrink = (sizePt) => Math.floor(sizePt * f * 10) / 10;
+	const baseSize = Number(eff.fontSize ?? 12);
+	cell.options = {
+		...cell.options,
+		fontSize: shrink(baseSize)
+	};
+	if (Array.isArray(cell.text)) cell.text = cell.text.map((run) => run && typeof run === "object" && typeof run.options?.fontSize === "number" ? {
+		...run,
+		options: {
+			...run.options,
+			fontSize: shrink(run.options.fontSize)
+		}
+	} : run);
+}
+/** Grid column count of a table (sums the first row's colspans), mirroring `gen/slide/objects/table.ts`. */
+function tableColCount(rows) {
+	const first = rows[0];
+	return first ? first.reduce((n, c) => n + (Number(c?.options?.colspan) || 1), 0) : 0;
+}
+/**
+* Walk a table's cell grid in row-major order, resolving each authored cell to its
+* grid origin (`row`/`col`) and clamped colspan/rowspan. Tracks rowspan occupancy so
+* a cell never lands beneath one spanned from above (grid build). This is
+* the single traversal shared by the measured-fit shrink pass and
+* {@link computeTableLayout}, so cell placement cannot drift between them.
+*/
+function* walkTableGrid(rows, numCols) {
+	const occupied = new Array(numCols).fill(0);
+	for (let r = 0; r < rows.length; r++) {
+		const row = rows[r];
+		if (!row) continue;
+		let col = 0;
+		for (const cell of row) {
+			while (col < numCols && (occupied[col] ?? 0) > 0) col++;
+			if (col >= numCols) break;
+			const colspan = Math.max(1, Number(cell?.options?.colspan) || 1);
+			const rowspan = Math.min(Math.max(1, Number(cell?.options?.rowspan) || 1), rows.length - r);
+			const colStart = col;
+			const colEnd = Math.min(colStart + colspan, numCols);
+			for (let c = colStart; c < colEnd; c++) occupied[c] = rowspan;
+			col = colEnd;
+			yield {
+				cell,
+				row: r,
+				col: colStart,
+				rowSpan: rowspan,
+				colSpan: colEnd - colStart
+			};
+		}
+		for (let c = 0; c < numCols; c++) {
+			const cur = occupied[c] ?? 0;
+			if (cur > 0) occupied[c] = cur - 1;
+		}
+	}
+}
+/**
+* Compute per-cell geometry (inches) for a table laid out at `opts.x`/`y`/`w` — the
+* engine behind `pptx.tableLayout()`. Column widths come from the same
+* {@link resolveTableColWidthsEmu} the writer uses, so cell x/width are exact. Row
+* heights are exact when pinned by `rowH` (array or scalar) or table `h`; otherwise
+* each auto-height row is estimated with the same conservative (tall) text model as
+* {@link measureText} and flagged `heightExact: false`. Single-slide only —
+* `autoPage` paging across slides is not modeled. Rowspan cells do not drive a row's
+* estimated height (mirrors `gen/table/autopage.ts`, which exempts them from line-height growth).
+*/
+function computeTableLayout(rows, opts, presLayout, registry) {
+	const empty = {
+		cells: [],
+		widthIn: 0,
+		heightIn: 0,
+		heightExact: true
+	};
+	if (!rows || rows.length === 0 || !rows[0]) return empty;
+	const numRows = rows.length;
+	const numCols = tableColCount(rows);
+	if (!(numCols > 0)) return empty;
+	const o = opts;
+	const tableXEmu = opts.x != null ? getSmartParseNumber(opts.x, "X", presLayout) : 0;
+	const tableYEmu = opts.y != null ? getSmartParseNumber(opts.y, "Y", presLayout) : 0;
+	const cxEmu = opts.w != null ? getSmartParseNumber(opts.w, "X", presLayout) : getSmartParseNumber("75%", "X", presLayout);
+	const colWidthsEmu = resolveTableColWidthsEmu(opts.colW, cxEmu, numCols);
+	const colXEmu = new Array(numCols + 1).fill(0);
+	for (let c = 0; c < numCols; c++) colXEmu[c + 1] = (colXEmu[c] ?? 0) + (colWidthsEmu[c] ?? 0);
+	const tableHeightEmu = opts.h != null ? getSmartParseNumber(opts.h, "Y", presLayout) : 0;
+	const explicitRowHEmu = (r) => {
+		if (Array.isArray(opts.rowH)) {
+			const v = opts.rowH[r];
+			if (typeof v === "number" && isFinite(v)) return inch2Emu(v);
+			return tableHeightEmu > 0 ? Math.round(tableHeightEmu / numRows) : null;
+		}
+		if (opts.rowH != null && !isNaN(Number(opts.rowH))) return inch2Emu(Number(opts.rowH));
+		if (tableHeightEmu > 0) return Math.round(tableHeightEmu / numRows);
+		return null;
+	};
+	const resolve = makeRegistryResolver(registry);
+	const defLineEmu = inch2Emu(12 * LINEH_MODIFIER / 100);
+	const estimateContentHeightEmu = (cell, eff, innerWidthPt) => {
+		const fontSizePt = Number(eff.fontSize ?? 12) || 12;
+		const oneLineEmu = inch2Emu(fontSizePt * LINEH_MODIFIER / 100);
+		if (!(innerWidthPt > 0)) return oneLineEmu;
+		const paragraphs = extractParagraphs({
+			text: cell.text,
+			options: eff
+		});
+		if (!paragraphs) return oneLineEmu;
+		const layout = measureLayout(paragraphs, innerWidthPt, resolve, 100, 0, WIDTH_SAFETY_FACTOR);
+		if (layout === null) return oneLineEmu;
+		return Math.max(Math.round(layout.heightPt * HEIGHT_SAFETY_FACTOR * EMU_PER_POINT), oneLineEmu);
+	};
+	const placed = [];
+	const rowHeightsEmu = new Array(numRows).fill(0);
+	const rowExact = new Array(numRows).fill(false);
+	for (let r = 0; r < numRows; r++) {
+		const ex = explicitRowHEmu(r);
+		if (ex != null) {
+			rowHeightsEmu[r] = ex;
+			rowExact[r] = true;
+		}
+	}
+	for (const p of walkTableGrid(rows, numCols)) {
+		const colStart = p.col;
+		const colEnd = p.col + p.colSpan;
+		placed.push({
+			p,
+			colStart,
+			colEnd
+		});
+		if (p.rowSpan === 1 && !rowExact[p.row]) {
+			let widthEmu = 0;
+			for (let c = colStart; c < colEnd; c++) widthEmu += colWidthsEmu[c] ?? 0;
+			const eff = effectiveCellOpts(p.cell?.options ?? {}, o);
+			const ins = resolveCellInsetsEmu(eff.margin);
+			const innerWidthPt = (widthEmu - ins.marL - ins.marR) / EMU_PER_POINT;
+			const contentEmu = estimateContentHeightEmu(p.cell, eff, innerWidthPt) + ins.marT + ins.marB;
+			if (contentEmu > (rowHeightsEmu[p.row] ?? 0)) rowHeightsEmu[p.row] = contentEmu;
+		}
+	}
+	for (let r = 0; r < numRows; r++) if ((rowHeightsEmu[r] ?? 0) <= 0) rowHeightsEmu[r] = defLineEmu;
+	const rowYEmu = new Array(numRows + 1).fill(0);
+	for (let r = 0; r < numRows; r++) rowYEmu[r + 1] = (rowYEmu[r] ?? 0) + (rowHeightsEmu[r] ?? 0);
+	return {
+		cells: placed.map(({ p, colStart, colEnd }) => {
+			const rowEnd = p.row + p.rowSpan;
+			let heightExact = true;
+			for (let rr = p.row; rr < rowEnd; rr++) if (!rowExact[rr]) heightExact = false;
+			return {
+				row: p.row,
+				col: p.col,
+				rowSpan: p.rowSpan,
+				colSpan: p.colSpan,
+				xIn: emuToInches(tableXEmu + (colXEmu[colStart] ?? 0)),
+				yIn: emuToInches(tableYEmu + (rowYEmu[p.row] ?? 0)),
+				wIn: emuToInches((colXEmu[colEnd] ?? 0) - (colXEmu[colStart] ?? 0)),
+				hIn: emuToInches((rowYEmu[rowEnd] ?? 0) - (rowYEmu[p.row] ?? 0)),
+				heightExact
+			};
+		}),
+		widthIn: emuToInches(colXEmu[numCols] ?? 0),
+		heightIn: emuToInches(rowYEmu[numRows] ?? 0),
+		heightExact: rowExact.every(Boolean)
+	};
+}
+/**
+* Build the `MetricsResolver` both the export pass and `measureText` use, so they
+* agree run-for-run: exact registered metrics → conservative heuristic for any
+* **named** face without exact metrics → `undefined` only for an unnamed
+* (theme-default) face that cannot be guessed. `onHeuristic` is called with each
+* named face that fell back to the heuristic (for the export pass's warn-once).
+*/
+//#endregion
+//#region src/measure/fit.ts
+/** Map the public {@link MeasureTextOptions} onto the internal run-option shape. */
+function measureOptsToRunOpts(opts) {
+	return {
+		fontSize: opts.fontSize,
+		fontFace: opts.fontFace,
+		bold: opts.bold,
+		italic: opts.italic,
+		charSpacing: opts.charSpacing,
+		lineSpacing: opts.lineSpacing,
+		lineSpacingMultiple: opts.lineSpacingMultiple,
+		paraSpaceBefore: opts.paraSpaceBefore,
+		paraSpaceAfter: opts.paraSpaceAfter
+	};
+}
+/** A fresh result each call: the arrays are caller-owned, so they cannot be shared. */
+const unmeasurable = () => ({
+	heightIn: 0,
+	lineCount: 0,
+	widestLineIn: 0,
+	measurable: false,
+	approximatedFaces: [],
+	uncoveredCodepoints: [],
+	fitsBox: () => false,
+	shrinkScaleFor: () => 100
+});
+/** Flatten a face → uncovered-code-point map into one sorted, deduplicated list. */
+function flattenCodepoints(byFace) {
+	const all = /* @__PURE__ */ new Set();
+	for (const cps of byFace.values()) for (const cp of cps) all.add(cp);
+	return [...all].sort((a, b) => a - b);
+}
+/**
+* Render uncovered code points for a warning as `U+XXXX`, capped so one bad run cannot
+* flood the console with a whole unsupported script.
+*/
+function formatCodepoints(cps) {
+	const all = [...cps].sort((a, b) => a - b);
+	const shown = all.slice(0, 8).map((cp) => `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`);
+	return all.length > shown.length ? `${shown.join(" ")} +${all.length - shown.length} more` : shown.join(" ");
+}
+/**
+* Layout-time text measurement against registered metrics — the public engine
+* behind `pptx.measureText()`. Uses the **same** calibrated wrap model, resolver
+* semantics, and conservative safety factors as the export-time bake
+* ({@link applyMeasuredFit} / {@link solveResize} / {@link solveShrink}), so a
+* layout-time prediction matches the value the export would bake **for any deck
+* that opted into measured fit (i.e. registered at least one face)**.
+*
+* With an **empty** registry the two intentionally diverge: {@link applyMeasuredFit}
+* treats "no metrics" as "not opted in" and bakes nothing, while this returns
+* heuristic numbers so the API is useful with zero setup. Check
+* `approximatedFaces` if that distinction matters.
+*
+* Synchronous: assumes metrics are pre-registered (lookup is sync). A named face
+* with no exact metrics silently uses the conservative heuristic (same as export)
+* and is reported in `approximatedFaces`; an unnamed theme-default face returns
+* `measurable: false`. Code points a *registered* face has no glyph for are reported
+* in `uncoveredCodepoints`, and are the one case where the height may come back short
+* rather than tall — there is no font fallback here, only the font's `.notdef` advance.
+*/
+function measureText(registry, text, opts) {
+	const paragraphs = buildFitParagraphs(typeof text === "string" || typeof text === "number" ? [{ text: String(text) }] : Array.isArray(text) ? text : [], measureOptsToRunOpts(opts));
+	if (!paragraphs) return unmeasurable();
+	const inset = opts.insetIn ?? 0;
+	const innerWidthPt = (opts.wIn - 2 * inset) * 72;
+	const heuristicFaces = /* @__PURE__ */ new Set();
+	const resolve = makeRegistryResolver(registry, (face) => heuristicFaces.add(face));
+	const uncoveredByFace = /* @__PURE__ */ new Map();
+	collectUncoveredCodepoints(paragraphs, registry, uncoveredByFace);
+	const layout = measureLayout(paragraphs, innerWidthPt, resolve, 100, 0, WIDTH_SAFETY_FACTOR);
+	if (layout === null) return unmeasurable();
+	const heightPt = layout.heightPt * HEIGHT_SAFETY_FACTOR;
+	return {
+		heightIn: heightPt / 72,
+		lineCount: layout.lineCount,
+		widestLineIn: layout.widestLineWidthPt / 72,
+		measurable: true,
+		approximatedFaces: [...heuristicFaces],
+		uncoveredCodepoints: flattenCodepoints(uncoveredByFace),
+		fitsBox: (hIn) => heightPt <= hIn * 72,
+		shrinkScaleFor: (hIn) => {
+			const box = {
+				innerWidthPt,
+				innerHeightPt: hIn * 72
+			};
+			const outcome = solveShrink(paragraphs, box, resolve);
+			if (outcome.kind === "shrink") return outcome.result.fontScalePct;
+			return 100;
+		}
+	};
+}
+/**
+* Apply measured fit across every slide. For each text box that opts in via
+* `fit:'shrink'` or `fit:'resize'` and whose font has registered metrics, this
+* bakes the computed result before the sync XML pass reads it:
+* - `'shrink'` → rewrites `options.fit` to the object form so `<a:normAutofit
+*   fontScale=…/>` is emitted (text renders pre-shrunk).
+* - `'resize'` → rewrites `options.h` (and `options.y` per vertical anchor) so the
+*   shape's `a:ext/@cy` is the height the text needs; the `<a:spAutoFit/>` marker is
+*   left in place (the renderer draws the baked `cy`).
+*
+* Safe to call with an empty registry (no-op). Warns once if any opted-in box could
+* not be measured (missing metrics), and once if one held code points its registered
+* face has no glyph for, so neither kind of overflow is silently ignored.
+*/
+function applyMeasuredFit(slides, registry) {
+	if (registry.size === 0) return;
+	const heuristicFaces = /* @__PURE__ */ new Set();
+	const resolve = makeRegistryResolver(registry, (face) => heuristicFaces.add(face));
+	const unmeasuredShrink = /* @__PURE__ */ new Set();
+	const unmeasuredResize = /* @__PURE__ */ new Set();
+	const uncoveredByFace = /* @__PURE__ */ new Map();
+	const collectUnmeasured = (paragraphs, into) => {
+		for (const para of paragraphs) for (const run of para.runs) if (!resolve(run)) into.add(run.fontFace ?? "(theme default)");
+	};
+	/** Audit every set of runs the pass is about to measure — see the warning below. */
+	const auditCoverage = (paragraphs) => collectUncoveredCodepoints(paragraphs, registry, uncoveredByFace);
+	/**
+	* Bake measured shrink into a table's cells. Walks the cell grid (accounting for
+	* colspan/rowspan) to size each cell's box from its column widths and row heights,
+	* then lowers the run font sizes of any `fit:'shrink'` cell that overflows. Cells
+	* in auto-height rows (no fixed `rowH`/table `h`) are skipped — the row grows instead.
+	*/
+	const measureTableCells = (tableObj, layout) => {
+		const rows = tableObj.arrTabRows;
+		if (!rows || rows.length === 0 || !rows[0]) return;
+		const tableOpts = tableObj.options ?? {};
+		const numRows = rows.length;
+		const numCols = tableColCount(rows);
+		if (!(numCols > 0)) return;
+		const cxEmu = tableOpts.w != null ? getSmartParseNumber(tableOpts.w, "X", layout) : getSmartParseNumber("75%", "X", layout);
+		const colWidthsEmu = resolveTableColWidthsEmu(tableOpts.colW, cxEmu, numCols);
+		const tableHeightEmu = tableOpts.h != null ? getSmartParseNumber(tableOpts.h, "Y", layout) : typeof tableOpts.cy === "number" ? tableOpts.cy : 0;
+		const rowHeightEmu = (rIdx) => {
+			if (Array.isArray(tableOpts.rowH) && tableOpts.rowH[rIdx]) return inch2Emu(Number(tableOpts.rowH[rIdx]));
+			if (tableOpts.rowH != null && !Array.isArray(tableOpts.rowH) && !isNaN(Number(tableOpts.rowH))) return inch2Emu(Number(tableOpts.rowH));
+			if (tableHeightEmu > 0) return Math.round(tableHeightEmu / numRows);
+			return 0;
+		};
+		for (const { cell, row: r, col: colStart, colSpan, rowSpan } of walkTableGrid(rows, numCols)) {
+			const colEnd = colStart + colSpan;
+			const cellOpts = cell?.options ?? {};
+			if ((cellOpts.fit ?? (tableOpts.fit === "shrink" ? "shrink" : void 0)) !== "shrink") continue;
+			let widthEmu = 0;
+			for (let c = colStart; c < colEnd; c++) widthEmu += colWidthsEmu[c] ?? 0;
+			let heightEmu = 0;
+			let autoHeight = false;
+			for (let rr = r; rr < r + rowSpan; rr++) {
+				const h = rowHeightEmu(rr);
+				if (h <= 0) {
+					autoHeight = true;
+					break;
+				}
+				heightEmu += h;
+			}
+			if (autoHeight) continue;
+			const eff = effectiveCellOpts(cellOpts, tableOpts);
+			const ins = resolveCellInsetsEmu(eff.margin);
+			const innerWidthPt = (widthEmu - ins.marL - ins.marR) / EMU_PER_POINT;
+			const innerHeightPt = (heightEmu - ins.marT - ins.marB) / EMU_PER_POINT;
+			if (!(innerWidthPt > 0) || !(innerHeightPt > 0)) continue;
+			const paragraphs = extractParagraphs({
+				text: cell.text,
+				options: eff
+			});
+			if (!paragraphs) continue;
+			auditCoverage(paragraphs);
+			const outcome = solveShrink(paragraphs, {
+				innerWidthPt,
+				innerHeightPt
+			}, resolve);
+			if (outcome.kind === "shrink") {
+				const f = outcome.result.fontScalePct / 100;
+				if (f < 1) scaleCellFontSizes(cell, eff, f);
+			} else if (outcome.kind === "unmeasurable") collectUnmeasured(paragraphs, unmeasuredShrink);
+		}
+	};
+	const measureObject = (obj, layout) => {
+		if (obj._type === "group") {
+			for (const child of obj._groupObjects ?? []) measureObject(child, layout);
+			return;
+		}
+		if (obj._type === "table") {
+			measureTableCells(obj, layout);
+			return;
+		}
+		if (obj._type !== "text") return;
+		const options = obj.options;
+		if (!options) return;
+		const fit = options.fit;
+		if (fit !== "shrink" && fit !== "resize") return;
+		const paragraphs = extractParagraphs(obj);
+		if (!paragraphs) return;
+		auditCoverage(paragraphs);
+		const box = computeBox(obj, layout);
+		if (!box) return;
+		if (fit === "shrink") {
+			const outcome = solveShrink(paragraphs, box, resolve);
+			if (outcome.kind === "shrink") {
+				const { fontScalePct, lnSpcReductionPct } = outcome.result;
+				options.fit = {
+					type: "shrink",
+					fontScale: fontScalePct,
+					lnSpcReduction: lnSpcReductionPct || void 0
+				};
+			} else if (outcome.kind === "unmeasurable") collectUnmeasured(paragraphs, unmeasuredShrink);
+		} else {
+			const outcome = solveResize(paragraphs, box, resolve);
+			if (outcome.kind === "resize") {
+				const opts = obj.options;
+				const { tIns, bIns } = resolveInsetsEmu(opts);
+				const oldHeightEmu = getSmartParseNumber(opts.h, "Y", layout);
+				const newHeightEmu = Math.round(outcome.neededInnerHeightPt * EMU_PER_POINT) + tIns + bIns;
+				const oldYEmu = getSmartParseNumber(opts.y, "Y", layout);
+				const shiftEmu = Math.round((newHeightEmu - oldHeightEmu) * anchorTopShareOfDelta(opts));
+				opts.h = `${newHeightEmu}emu`;
+				if (shiftEmu !== 0) opts.y = `${oldYEmu - shiftEmu}emu`;
+			} else collectUnmeasured(paragraphs, unmeasuredResize);
+		}
+	};
+	for (const slide of slides) for (const obj of slide._slideObjects ?? []) measureObject(obj, slide._presLayout);
+	if (unmeasuredShrink.size > 0) warn("measure/shrink-unmeasured", `fit:'shrink' could not be measured for font(s) [${[...unmeasuredShrink].join(", ")}] — no registered metrics. Emitting bare <a:normAutofit/> (text will not pre-shrink in headless renders). Call pptx.registerFontMetrics(face, fontFilePathOrBytes) to enable measured fit.`);
+	if (unmeasuredResize.size > 0) warn("measure/resize-unmeasured", `fit:'resize' could not be measured for font(s) [${[...unmeasuredResize].join(", ")}] — no registered metrics. Emitting bare <a:spAutoFit/> with the authored height (box will not auto-grow in headless renders). Call pptx.registerFontMetrics(face, fontFilePathOrBytes) to enable measured fit.`);
+	if (uncoveredByFace.size > 0) {
+		const perFace = [...uncoveredByFace].map(([face, cps]) => `${face} → ${formatCodepoints(cps)}`).join("; ");
+		warn("measure/uncovered-codepoints", `Measured fit charged the .notdef advance for code point(s) the registered face does not cover (${perFace}) — PowerPoint renders those from a substituted font, so the measured width can be wrong in EITHER direction. Too narrow drops a line and the text overflows the baked size, the one case measured fit does not err safe. Register a face that covers them, or set an explicit fontFace on those runs.`);
+	}
+	if (heuristicFaces.size > 0) warn("measure/heuristic-metrics", `Note: measured fit used a conservative average-advance estimate for font(s) [${[...heuristicFaces].join(", ")}] — no exact metrics registered. Fit is approximate (may shrink/grow more than necessary). Call pptx.registerFontMetrics(face, fontFilePathOrBytes) for an exact fit.`);
+}
+//#endregion
+export { parseFontMetrics as _, FONT_SCALE_STEP_PCT as a, SINGLE_LINE_PITCH as c, measureLayout as d, solveResize as f, makeRegistryResolver as g, getHeuristicFontMetrics as h, buildFitParagraphs as i, WIDTH_SAFETY_FACTOR as l, FontMetricsRegistry as m, measureText as n, HEIGHT_SAFETY_FACTOR as o, solveShrink as p, computeTableLayout as r, MIN_FONT_SCALE_PCT as s, applyMeasuredFit as t, measureHeightPt as u, isFontCollection as v, listFontFaces as y };
+
+//# sourceMappingURL=fit-BKs0zxMI.js.map