pptx-ts 3.7.0 → 4.0.1

package/dist/{fit-BKs0zxMI.js → fit-Cb7naFj6.js}

@@ -1,6 +1,9 @@
-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";
+import { l as warn, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError } from "./errors-C4oENPcu.js";
+import { _ as resolveCellMarginsInches, b as resolveTableColWidthsEmu, d as marginToEmu, s as getSmartParseNumber, t as autoPageLineHeightEmu, v as resolveInsetsEmu, x as resolveTableRowHeightEmu } from "./units-internal-XJlf-hOl.js";
+import { D as emuToInches, I as EMU_PER_POINT } from "./table-cell-margins-EVg0EwxT.js";
+import { t as pickDefined } from "./options-internal-WqgMf720.js";
+import { t as BODY_INSET_DEFAULTS_EMU } from "./body-insets-Dw_BeWD_.js";
+import { n as tableColCount, r as walkTableGrid } from "./grid-DikTjFey.js";
 //#region src/measure/font-collection.ts
 /**
 * Font **collection** (`.ttc` / `.otc`) support for the write-side metrics.
@@ -272,7 +275,7 @@ function extractFontFace(data, index) {
 * 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").
+* overflow). See `docs/contributing/design/text-fit.md` ("Font metrics provider").
 */
 var OpentypeFontMetrics = class {
 	font;
@@ -342,7 +345,7 @@ 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
+* Approximate but conservative — see `heuristicCharRatio`. A deck with no
 * registered metrics at all does not engage measured fit, so this never fires there.
 */
 function getHeuristicFontMetrics() {
@@ -386,6 +389,7 @@ var FontMetricsRegistry = class {
 		return `${face.toLowerCase()}\0${bold ? 1 : 0}\0${italic ? 1 : 0}`;
 	}
 	set(face, metrics, opts) {
+		if (typeof face !== "string" || face.trim() === "") throw new InvalidOptionError("font/missing-typeface", `registerFontMetrics: \`face\` must be the non-empty family name your fontFace options use, got ${JSON.stringify(face)}.`);
 		this.map.set(this.key(face, !!opts?.bold, !!opts?.italic), metrics);
 	}
 	/** True if any variant of `face` has registered metrics. */
@@ -446,9 +450,9 @@ function makeRegistryResolver(registry, onHeuristic) {
 * 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
+* glyph over-reports (a phantom line, which is 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").
+* surfaced rather than absorbed. See `docs/contributing/design/text-fit.md` ("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
@@ -481,12 +485,13 @@ function collectUncoveredCodepoints(paragraphs, registry, into) {
 * 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.
+* agree to ≤ 0.041 pt. See "Findings behind the constants" in
+* `docs/contributing/design/text-fit.md`.
 */
 const SINGLE_LINE_PITCH = 1.2117;
-/** PowerPoint's `fontScale` search grid: discrete 2.5% steps (Findings #3). */
+/** PowerPoint's `fontScale` search grid: discrete 2.5% steps (`docs/contributing/design/text-fit.md`). */
 const FONT_SCALE_STEP_PCT = 2.5;
-/** Floor for the shrink search (see `docs/measured-text-fit.md` → Solvers). */
+/** Floor for the shrink search (see `docs/contributing/design/text-fit.md` → Wrap simulator and solvers). */
 const MIN_FONT_SCALE_PCT = 25;
 /**
 * Conservative safety factors applied by the shrink solver (not by the pure
@@ -526,7 +531,7 @@ const isWhitespace = (ch) => ch === " " || ch === "	" || ch === "\xA0" || /\s/.t
 * 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.
+* `docs/contributing/design/text-fit.md` records it.
 */
 function isCjkBreakCharacter(ch) {
 	const cp = ch.codePointAt(0) ?? 0;
@@ -593,8 +598,9 @@ function tokenizeParagraph(para, resolve, fontScalePct, widthSafety) {
 * 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.
+* toward width, as PowerPoint counts it, which slightly over-reports — the
+* conservative direction, consistent with the wrap model erring wide. The
+* PowerPoint behaviour this follows is tabled in `docs/contributing/design/text-fit.md`.
 */
 function countLines(tokens, innerWidthPt) {
 	let lines = 1;
@@ -637,7 +643,7 @@ function countLines(tokens, innerWidthPt) {
 		maxLineWidthPt
 	};
 }
-/** Max run size in a paragraph (line height follows the tallest run — Findings #7). */
+/** Max run size in a paragraph (PowerPoint's line height follows the tallest run). */
 function maxRunSizePt(para) {
 	let max = 0;
 	for (const run of para.runs) if (run.sizePt > max) max = run.sizePt;
@@ -651,7 +657,7 @@ function maxRunSizePt(para) {
 * and the public layout-time measure API.
 */
 function measureLayout(paragraphs, innerWidthPt, resolve, fontScalePct, lnSpcReductionPct, widthSafety = 1) {
-	if (innerWidthPt <= 0) return null;
+	if (!(innerWidthPt > 0)) return null;
 	let total = 0;
 	let lineCount = 0;
 	let widestLineWidthPt = 0;
@@ -681,14 +687,6 @@ function measureHeightPt(paragraphs, innerWidthPt, resolve, fontScalePct, lnSpcR
 	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
@@ -697,6 +695,14 @@ function measureHeightPt(paragraphs, innerWidthPt, resolve, fontScalePct, lnSpcR
 function layoutWidthPt(box) {
 	return box.wrap === false ? Infinity : box.innerWidthPt;
 }
+/**
+* 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.
+*/
 function solveResize(paragraphs, box, resolve) {
 	const h = measureHeightPt(paragraphs, layoutWidthPt(box), resolve, 100, 0, WIDTH_SAFETY_FACTOR);
 	if (h === null) return { kind: "unmeasurable" };
@@ -705,6 +711,16 @@ function solveResize(paragraphs, box, resolve) {
 		neededInnerHeightPt: h * HEIGHT_SAFETY_FACTOR
 	};
 }
+/**
+* Largest `fontScale` (on PowerPoint's 2.5% grid) at which the text fits the box.
+* Width and height both re-measured per scale. Conservative: because the model
+* over-estimates, the returned scale is ≤ PowerPoint's and the text never overflows.
+*
+* `lnSpcReduction` is left at 0 — dropping `fontScale` alone is provably
+* conservative (PowerPoint trades line-spacing reduction to keep the font *larger*,
+* so a reduction-free fit is always ≤ PowerPoint's scale). The reduction ramp
+* PowerPoint applies is recorded in `docs/contributing/design/text-fit.md`.
+*/
 function solveShrink(paragraphs, box, resolve) {
 	const width = layoutWidthPt(box);
 	const noWrap = box.wrap === false;
@@ -743,8 +759,6 @@ function solveShrink(paragraphs, box, resolve) {
 * `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) {
@@ -758,12 +772,12 @@ function normalizeRuns(obj) {
 	if (!Array.isArray(text) && typeof text === "object" && "text" in text) {
 		const t = text;
 		return [{
-			text: t.text,
+			...pickDefined(t, ["text"]),
 			options: t.options ?? opts
 		}];
 	}
 	if (Array.isArray(text)) return text.map((t) => ({
-		text: t.text,
+		...pickDefined(t, ["text"]),
 		options: t.options ?? opts
 	}));
 	return [];
@@ -778,7 +792,7 @@ function extractParagraphs(obj) {
 /**
 * 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
+* export-time pass (`extractParagraphs`) and the public layout-time
 * `measureText` API, so a layout-time prediction and the baked export never drift.
 */
 function buildFitParagraphs(runs, opts) {
@@ -840,27 +854,35 @@ function buildFitParagraphs(runs, opts) {
 	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) {
+/**
+* Resolve a text frame's insets (EMU): explicit `_bodyProp` (from `inset`) → `margin` →
+* PowerPoint's defaults.
+*
+* Named for the question it answers, which is not the one `units-internal.resolveInsetsEmu`
+* answers: that one takes a `margin` alone and returns `null` when the caller stated none, so
+* an emitter can leave the attributes off. This one takes the whole option bag, consults
+* `_bodyProp` first, and always produces four numbers, because a solver has to measure against
+* something. Two exported functions with one name, imported from two places, was a coin-flip
+* for anyone reading a call site.
+*
+* The `[T, R, B, L]` shuffle and the defaults both come from the modules that own them rather
+* than being spelled again here.
+*/
+function resolveBodyInsetsEmu(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);
+	if (lIns == null && rIns == null && tIns == null && bIns == null) {
+		const insets = resolveInsetsEmu(opts.margin);
+		if (insets) ({l: lIns, r: rIns, t: tIns, b: bIns} = insets);
 	}
 	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
+		lIns: lIns ?? BODY_INSET_DEFAULTS_EMU.left,
+		rIns: rIns ?? BODY_INSET_DEFAULTS_EMU.right,
+		tIns: tIns ?? BODY_INSET_DEFAULTS_EMU.top,
+		bIns: bIns ?? BODY_INSET_DEFAULTS_EMU.bottom
 	};
 }
 /**
@@ -878,7 +900,7 @@ function computeBox(obj, presLayout) {
 	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 { lIns, rIns, tIns, bIns } = resolveBodyInsetsEmu(opts);
 	const wrap = (opts._bodyProp ?? {}).wrap !== false;
 	const innerWidthPt = (wEmu - lIns - rIns) / EMU_PER_POINT;
 	const innerHeightPt = (hEmu - tIns - bIns) / EMU_PER_POINT;
@@ -897,46 +919,85 @@ function anchorTopShareOfDelta(opts) {
 	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
+//#region src/gen/table/cell-inherit.ts
 /**
-* ts-pptx: measuring a table's row heights and cell fits
+* ts-pptx: what a table cell inherits from its table.
 *
-* 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.
+* A cell that states nothing takes the table's value, and two paths resolve that: the emitter,
+* building the bag it hands to the text-body writer, and the measured-fit pass, building the
+* effective text it lays out. They inherited **different lists** -- the measure side named
+* `italic`, `charSpacing`, `lineSpacing` and `lineSpacingMultiple` that the emitter did not,
+* while its docstring claimed to mirror the emitter's -- so a table-level `italic` was measured
+* with italic metrics and emitted upright, and on `fit: 'shrink'` a table-level line spacing
+* made the solver compute a taller layout and bake a smaller font that the cell then rendered
+* at default spacing. `pptx.tableLayout()` reported geometry the file disagreed with.
+*
+* So the text keys are one list, shared. The second list is the emitter's alone, and is a
+* statement rather than an omission: those keys either paint (`fill`, `color`, `border`,
+* `underline`) or are not modelled by the fitter (`textDirection`, which does change how text
+* lays out -- the measured-fit pass does not read it on a cell either way, and widening the
+* fitter to handle vertical cell text is its own change).
+*/
+/**
+* The keys both paths inherit: everything that decides how a cell's text is laid out.
+*
+* `margin` and `valign` are here rather than below because the fitter reads them -- insets
+* shrink the box the text has to fit, and the anchor decides where a short line sits in it.
 */
-const CELL_INHERIT_KEYS = [
+const CELL_INHERITED_TEXT_KEYS = [
+	"align",
+	"bold",
+	"charSpacing",
 	"fontFace",
 	"fontSize",
-	"bold",
 	"italic",
-	"charSpacing",
-	"align",
 	"lineSpacing",
 	"lineSpacingMultiple",
-	"valign",
-	"margin"
+	"margin",
+	"valign"
+];
+/** The keys only the emitter inherits: they paint, or the fitter does not model them. */
+const CELL_INHERITED_EMIT_KEYS = [
+	"border",
+	"color",
+	"fill",
+	"textDirection",
+	"underline"
 ];
-/** Effective cell options: the cell's own values, with table-level values filled in where unset. */
+/** Every key the emitter inherits from the table onto a cell. */
+const CELL_INHERITED_KEYS = [...CELL_INHERITED_TEXT_KEYS, ...CELL_INHERITED_EMIT_KEYS];
+//#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.
+*/
+/**
+* Effective cell options: the cell's own values, with table-level values filled in where unset.
+*
+* The keys are `CELL_INHERITED_TEXT_KEYS` (`gen/table/cell-inherit.ts`), the half of the
+* emitter's list that decides how text lays out. This used to be its own list, claiming in its
+* docstring to mirror the emitter's while naming four keys the emitter did not.
+*
+* PowerPoint has no text-autofit for a table cell — `a:tcPr` carries no autofit, and the app
+* ignores a `normAutofit` inside one; rows auto-grow instead. So a cell's `fit: 'shrink'` is
+* honoured by baking a *reduced literal font size* onto its runs, which both PowerPoint and
+* LibreOffice render identically with no edit or resize. That is what makes these options worth
+* resolving here: the shrink is computed against the cell's effective text, not the table's.
+*/
 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];
+	for (const k of CELL_INHERITED_TEXT_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;
+	const arr = resolveCellMarginsInches(margin);
 	return {
 		marT: marginToEmu(arr[0]),
 		marR: marginToEmu(arr[1]),
@@ -945,12 +1006,17 @@ function resolveCellInsetsEmu(margin) {
 	};
 }
 /**
-* 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.
+* Bake a reduced font size onto a cell's runs by factor `f` (< 1). The cell's options and runs are
+* replaced with scaled copies, never edited in place. The cell itself is the stored slide model,
+* so `applyMeasuredFit` puts the authored options and runs back once the write is built.
+*
+* The shrunk size never goes below {@link MIN_FONT_SIZE_PT}, the emitter's own bound. It used to
+* have no minimum, so a 1pt cell taken to the 25% scale floor was baked as 0.2pt and
+* `clampFontSizeSz` then warned that "fontSize 0.2 is outside the valid range" -- a value the
+* caller never stated and cannot act on. Their input was valid; only our scaling was out of range.
 */
 function scaleCellFontSizes(cell, eff, f) {
-	const shrink = (sizePt) => Math.floor(sizePt * f * 10) / 10;
+	const shrink = (sizePt) => Math.max(1, Math.floor(sizePt * f * 10) / 10);
 	const baseSize = Number(eff.fontSize ?? 12);
 	cell.options = {
 		...cell.options,
@@ -964,46 +1030,33 @@ function scaleCellFontSizes(cell, eff, f) {
 		}
 	} : 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.
+* Resolve a table's grid the one way every consumer has to see it.
+*
+* Three sites derived these four things: `pptx.tableLayout()`, the export-time measured-fit
+* pass, and the table emitter (the height alone). They already disagreed — only the fit pass
+* read `cy`, the EMU height the auto-pager and the fit pass itself stamp onto the options, so
+* `addTable(rows, { cy })` with no `h` gave a file whose rows are pinned and a
+* `pptx.tableLayout()` that reported every row auto-height. That is the same drift the one
+* reading of `rowH` closed, arriving through a second option, which is why the answer is a
+* shared resolver rather than a third correction.
+*
+* `w` defaults to `75%` of the slide, matching what the emitter falls back to.
+* @param rows - the table's authored rows
+* @param opts - the table's options
+* @param presLayout - the presentation layout, for resolving percentages
 */
-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;
-		}
-	}
+function resolveTableGridEmu(rows, opts, presLayout) {
+	const numRows = rows.length;
+	const numCols = tableColCount(rows);
+	const cxEmu = opts.w != null ? getSmartParseNumber(opts.w, "X", presLayout) : getSmartParseNumber("75%", "X", presLayout);
+	const tableHeightEmu = opts.h != null ? getSmartParseNumber(opts.h, "Y", presLayout) : typeof opts.cy === "number" ? opts.cy : 0;
+	return {
+		numCols,
+		colWidthsEmu: resolveTableColWidthsEmu(opts.colW, cxEmu, numCols),
+		tableHeightEmu,
+		rowHeightEmu: (rowIndex) => resolveTableRowHeightEmu(opts.rowH, rowIndex, tableHeightEmu, numRows)
+	};
 }
 /**
 * Compute per-cell geometry (inches) for a table laid out at `opts.x`/`y`/`w` — the
@@ -1024,31 +1077,21 @@ function computeTableLayout(rows, opts, presLayout, registry) {
 	};
 	if (!rows || rows.length === 0 || !rows[0]) return empty;
 	const numRows = rows.length;
-	const numCols = tableColCount(rows);
+	const grid = resolveTableGridEmu(rows, opts, presLayout);
+	const numCols = grid.numCols;
 	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 colWidthsEmu = grid.colWidthsEmu;
 	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 explicitRowHEmu = grid.rowHeightEmu;
 	const resolve = makeRegistryResolver(registry);
-	const defLineEmu = inch2Emu(12 * LINEH_MODIFIER / 100);
+	const defLineEmu = autoPageLineHeightEmu(12);
 	const estimateContentHeightEmu = (cell, eff, innerWidthPt) => {
 		const fontSizePt = Number(eff.fontSize ?? 12) || 12;
-		const oneLineEmu = inch2Emu(fontSizePt * LINEH_MODIFIER / 100);
+		const oneLineEmu = autoPageLineHeightEmu(fontSizePt);
 		if (!(innerWidthPt > 0)) return oneLineEmu;
 		const paragraphs = extractParagraphs({
 			text: cell.text,
@@ -1087,7 +1130,10 @@ function computeTableLayout(rows, opts, presLayout, registry) {
 			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;
+	for (let r = 0; r < numRows; r++) if ((rowHeightsEmu[r] ?? 0) <= 0) {
+		rowHeightsEmu[r] = defLineEmu;
+		rowExact[r] = false;
+	}
 	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 {
@@ -1112,28 +1158,21 @@ function computeTableLayout(rows, opts, presLayout, registry) {
 		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
-	};
+	return pickDefined(opts, [
+		"fontSize",
+		"fontFace",
+		"bold",
+		"italic",
+		"charSpacing",
+		"lineSpacing",
+		"lineSpacingMultiple",
+		"paraSpaceBefore",
+		"paraSpaceAfter"
+	]);
 }
 /** A fresh result each call: the arrays are caller-owned, so they cannot be shared. */
 const unmeasurable = () => ({
@@ -1165,11 +1204,11 @@ function formatCodepoints(cps) {
 * 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
+* (`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}
+* With an **empty** registry the two intentionally diverge: `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.
@@ -1182,9 +1221,13 @@ function formatCodepoints(cps) {
 * rather than tall — there is no font fallback here, only the font's `.notdef` advance.
 */
 function measureText(registry, text, opts) {
+	const inset = opts.insetIn ?? 0;
+	requireFiniteInches(opts.wIn, "wIn", "measureText");
+	requireFiniteInches(inset, "insetIn", "measureText");
+	if (opts.fontSize !== void 0 && !(Number.isFinite(opts.fontSize) && opts.fontSize > 0)) throw new InvalidOptionError("font/size-not-positive", `measureText: \`fontSize\` must be a positive number of points, got ${String(opts.fontSize)}.`);
+	if (!(opts.wIn > 2 * inset)) throw new InvalidOptionError("coord/not-positive", `measureText: \`wIn\` ${opts.wIn} leaves no width inside an inset of ${inset} on each side.`);
 	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));
@@ -1200,8 +1243,12 @@ function measureText(registry, text, opts) {
 		measurable: true,
 		approximatedFaces: [...heuristicFaces],
 		uncoveredCodepoints: flattenCodepoints(uncoveredByFace),
-		fitsBox: (hIn) => heightPt <= hIn * 72,
+		fitsBox: (hIn) => {
+			requireBoxHeight(hIn, "fitsBox");
+			return heightPt <= hIn * 72;
+		},
 		shrinkScaleFor: (hIn) => {
+			requireBoxHeight(hIn, "shrinkScaleFor");
 			const box = {
 				innerWidthPt,
 				innerHeightPt: hIn * 72
@@ -1212,6 +1259,20 @@ function measureText(registry, text, opts) {
 		}
 	};
 }
+/** Refuse a measure that is not a finite number of inches, naming the option and the call. */
+function requireFiniteInches(value, name, call) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new InvalidOptionError("coord/non-finite", `${call}: \`${name}\` must be a finite number of inches; got ${String(value)}.`);
+}
+/**
+* Refuse a box height a fit cannot be tested against: not a finite number, or not above 0. A `NaN`
+* height made `fitsBox` answer `false` and `shrinkScaleFor` answer `100`, both as if measured.
+* @param hIn - the caller's inner box height, in inches
+* @param call - the method it was passed to, opening the message
+*/
+function requireBoxHeight(hIn, call) {
+	requireFiniteInches(hIn, "hIn", call);
+	if (!(hIn > 0)) throw new InvalidOptionError("coord/not-positive", `${call}: \`hIn\` must be greater than 0; got ${String(hIn)}.`);
+}
 /**
 * 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
@@ -1225,9 +1286,20 @@ function measureText(registry, text, opts) {
 * 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.
+*
+* Every rewrite lands on the stored slide model, because that is what the emitters read.
+* The returned function puts each authored value back; call it once the XML is built. Left
+* baked, a second write found a text box's object-form `fit` and skipped it, and measured a
+* resized box or a shrunk cell from this write's result, so metrics registered in between
+* never reached those shapes.
+* @returns the step that restores every value this pass rewrote
 */
 function applyMeasuredFit(slides, registry) {
-	if (registry.size === 0) return;
+	const restores = [];
+	const restore = () => {
+		for (const undo of restores.splice(0).reverse()) undo();
+	};
+	if (registry.size === 0) return restore;
 	const heuristicFaces = /* @__PURE__ */ new Set();
 	const resolve = makeRegistryResolver(registry, (face) => heuristicFaces.add(face));
 	const unmeasuredShrink = /* @__PURE__ */ new Set();
@@ -1248,18 +1320,9 @@ function applyMeasuredFit(slides, registry) {
 		const rows = tableObj.arrTabRows;
 		if (!rows || rows.length === 0 || !rows[0]) return;
 		const tableOpts = tableObj.options ?? {};
-		const numRows = rows.length;
-		const numCols = tableColCount(rows);
+		const { numCols, colWidthsEmu, rowHeightEmu: pinnedRowHeightEmu } = resolveTableGridEmu(rows, tableOpts, layout);
 		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;
-		};
+		const rowHeightEmu = (rIdx) => pinnedRowHeightEmu(rIdx) ?? 0;
 		for (const { cell, row: r, col: colStart, colSpan, rowSpan } of walkTableGrid(rows, numCols)) {
 			const colEnd = colStart + colSpan;
 			const cellOpts = cell?.options ?? {};
@@ -1294,7 +1357,10 @@ function applyMeasuredFit(slides, registry) {
 			}, resolve);
 			if (outcome.kind === "shrink") {
 				const f = outcome.result.fontScalePct / 100;
-				if (f < 1) scaleCellFontSizes(cell, eff, f);
+				if (f < 1) {
+					restores.push(restorer(cell, "options"), restorer(cell, "text"));
+					scaleCellFontSizes(cell, eff, f);
+				}
 			} else if (outcome.kind === "unmeasurable") collectUnmeasured(paragraphs, unmeasuredShrink);
 		}
 	};
@@ -1321,21 +1387,24 @@ function applyMeasuredFit(slides, registry) {
 			const outcome = solveShrink(paragraphs, box, resolve);
 			if (outcome.kind === "shrink") {
 				const { fontScalePct, lnSpcReductionPct } = outcome.result;
-				options.fit = {
+				const shrink = {
 					type: "shrink",
-					fontScale: fontScalePct,
-					lnSpcReduction: lnSpcReductionPct || void 0
+					fontScale: fontScalePct
 				};
+				if (lnSpcReductionPct) shrink.lnSpcReduction = lnSpcReductionPct;
+				restores.push(restorer(options, "fit"));
+				options.fit = shrink;
 			} 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 { tIns, bIns } = resolveBodyInsetsEmu(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));
+				restores.push(restorer(opts, "h"), restorer(opts, "y"));
 				opts.h = `${newHeightEmu}emu`;
 				if (shiftEmu !== 0) opts.y = `${oldYEmu - shiftEmu}emu`;
 			} else collectUnmeasured(paragraphs, unmeasuredResize);
@@ -1349,8 +1418,21 @@ function applyMeasuredFit(slides, registry) {
 		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.`);
+	return restore;
+}
+/**
+* The step that puts `target[key]` back as it stands now, an absent key included, so a restored
+* option bag is the authored one rather than one holding an `undefined` the caller never wrote.
+*/
+function restorer(target, key) {
+	const had = Object.hasOwn(target, key);
+	const value = target[key];
+	return () => {
+		if (had) target[key] = value;
+		else delete target[key];
+	};
 }
 //#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 };
+export { getHeuristicFontMetrics as _, CELL_INHERITED_KEYS as a, isFontCollection as b, HEIGHT_SAFETY_FACTOR as c, WIDTH_SAFETY_FACTOR as d, measureHeightPt as f, FontMetricsRegistry as g, solveShrink as h, computeTableLayout as i, MIN_FONT_SCALE_PCT as l, solveResize as m, measureText as n, buildFitParagraphs as o, measureLayout as p, requireBoxHeight as r, FONT_SCALE_STEP_PCT as s, applyMeasuredFit as t, SINGLE_LINE_PITCH as u, makeRegistryResolver as v, listFontFaces as x, parseFontMetrics as y };
 
-//# sourceMappingURL=fit-BKs0zxMI.js.map
+//# sourceMappingURL=fit-Cb7naFj6.js.map