pptx-ts 0.0.1 → 4.0.0

package/dist/autopage-odPz7zZO.js

@@ -0,0 +1,536 @@
+import { l as warn } from "./errors-C4oENPcu.js";
+import { C as usableTableWidthEmu, R as DEF_SLIDE_MARGIN_IN, _ as resolveCellMarginsInches, b as resolveTableColWidthsEmu, c as inch2Emu, d as marginToEmu, m as pinnedRowHeightInches, s as getSmartParseNumber, t as autoPageLineHeightEmu, y as resolveSlideMarginsInches } from "./units-internal-XJlf-hOl.js";
+import { F as EMU_PER_INCH } from "./table-cell-margins-EVg0EwxT.js";
+import { a as resolveSpan, n as tableColCount, r as walkTableGrid, s as withCheckedSpans } from "./grid-DikTjFey.js";
+//#region src/gen/table/autopage.ts
+/**
+* A cell for the pager's working grid, carrying the source cell's options only when it has some.
+*
+* Every one of these used to be an inline `{ …, options: cell.options }`, which put an `options`
+* key holding `undefined` on a cell whose source had none. Readers cannot see the difference —
+* they all go through `cell.options?.…` — but a `TableCellProps` bag *is* spread in
+* `gen/define/table.ts` (`{ ...colDef, ...headerRow, ...cell.options }`), where the two states
+* are not the same thing. So the model keeps one spelling of absent.
+* @param text - the cell's content, a string or the run list the pager is accumulating
+* @param options - the source cell's options, if it had any
+*/
+function workingCell(text, options) {
+	return options === void 0 ? {
+		_type: "tablecell",
+		text
+	} : {
+		_type: "tablecell",
+		text,
+		options
+	};
+}
+/**
+* Break cell text into lines based upon table column width (e.g.: Magic Happens Here(tm))
+*
+* `charWeight` arrives as an argument rather than being read off `cell.options` because the
+* caller used to *stamp* it there: the table's weight was written onto the caller's own cell
+* options bag, or `delete`d from it when the table stated none. That mutated caller input --
+* which the chart path has a dedicated guard against -- and it made the option's precedence
+* differ by call site: the row-height probe read the cell's own value while the main loop had
+* just overwritten it with the table's. Both callers now resolve it the same way, and the more
+* specific statement wins, as it does everywhere else in this codebase.
+*
+* `fontSizePt` arrives resolved for the same reason. This read `cell.options.fontSize` or the
+* library default and never the table's `fontSize`, while the row's line height and the emitted
+* `sz` both used the table's. A table of 24pt text was wrapped as if it were 12pt, so the pager
+* counted about half the lines and rows ran off the bottom of each page.
+* @param {TableCellInternal} cell - table cell
+* @param {number} colWidth - table column width (inches)
+* @param {number} fontSizePt - resolved font size: the cell's, else the table's, else the default
+* @param {number} charWeight - resolved `autoPageCharWeight`: the cell's, else the table's, else 0
+* @param {boolean} [verbose] - dump the four wrapping stages; carries `addTable({ verbose })`
+*   down, which is the only stage of the pager that flag did not reach
+* @return {TableRowInternal[]} - cell's text objects grouped into lines
+*/
+function parseTextToLines(cell, colWidth, fontSizePt, charWeight, verbose) {
+	const FOCO = 2.3 + charWeight;
+	const CPL = Math.floor(colWidth * 72) / (fontSizePt / FOCO);
+	if (verbose) console.log(`[0/4] colWidth=${colWidth}in fontSize=${fontSizePt} FOCO=${FOCO} CPL=${CPL}`);
+	const parsedLines = [];
+	let inputCells = [];
+	const inputLines1 = [];
+	const inputLines2 = [];
+	/**
+	* EX INPUTS: `cell.text`
+	* - string....: "Account Name Column"
+	* - object....: { text:"Account Name Column" }
+	* - object[]..: [{ text:"Account Name", options:{ bold:true } }, { text:" Column" }]
+	* - object[]..: [{ text:"Account Name", options:{ breakLine:true } }, { text:"Input" }]
+	*/
+	/**
+	* EX OUTPUTS:
+	* - string....: [{ text:"Account Name Column" }]
+	* - object....: [{ text:"Account Name Column" }]
+	* - object[]..: [{ text:"Account Name", options:{ breakLine:true } }, { text:"Input" }]
+	* - object[]..: [{ text:"Account Name", options:{ breakLine:true } }, { text:"Input" }]
+	*/
+	if (cell.text && cell.text.toString().trim().length === 0) inputCells.push({
+		_type: "tablecell",
+		text: " "
+	});
+	else if (typeof cell.text === "number" || typeof cell.text === "string") inputCells.push({
+		_type: "tablecell",
+		text: (cell.text || "").toString().trim()
+	});
+	else if (Array.isArray(cell.text)) inputCells = cell.text;
+	if (verbose) {
+		console.log("[1/4] inputCells");
+		inputCells.forEach((cell, idx) => console.log(`[1/4] [${idx + 1}] cell: ${JSON.stringify(cell)}`));
+	}
+	/**
+	* - EX: `[{ text:"Input Output" }, { text:"Extra" }]`                       == 1 line
+	* - EX: `[{ text:"Input" }, { text:"Output", options:{ breakLine:true } }]` == 1 line
+	* - EX: `[{ text:"Input\nOutput" }]`                                        == 2 lines
+	* - EX: `[{ text:"Input", options:{ breakLine:true } }, { text:"Output" }]` == 2 lines
+	*/
+	let newLine = [];
+	inputCells.forEach((cell) => {
+		if (typeof cell.text !== "string") return;
+		if (cell.text.includes("\n")) {
+			const parts = cell.text.split("\n");
+			parts.forEach((part, partIdx) => {
+				if (partIdx === parts.length - 1) newLine.push(workingCell(part, cell.options));
+				else {
+					newLine.push({
+						_type: "tablecell",
+						text: part,
+						options: {
+							...cell.options,
+							breakLine: true
+						}
+					});
+					inputLines1.push(newLine);
+					newLine = [];
+				}
+			});
+		} else newLine.push(workingCell(cell.text.trim(), cell.options));
+		if (cell.options?.breakLine) {
+			if (verbose) console.log(`inputCells: new line > ${JSON.stringify(newLine)}`);
+			inputLines1.push(newLine);
+			newLine = [];
+		}
+	});
+	if (newLine.length > 0) {
+		inputLines1.push(newLine);
+		newLine = [];
+	}
+	if (verbose) {
+		console.log(`[2/4] inputLines1 (${inputLines1.length})`);
+		inputLines1.forEach((line, idx) => console.log(`[2/4] [${idx + 1}] line: ${JSON.stringify(line)}`));
+	}
+	inputLines1.forEach((line) => {
+		const lineTokens = [];
+		line.forEach((cell) => {
+			const lineWords = String(cell.text).split(" ");
+			lineWords.forEach((word, idx) => {
+				const cellProps = { ...cell.options };
+				if (cellProps?.breakLine) cellProps.breakLine = idx + 1 === lineWords.length;
+				lineTokens.push({
+					_type: "tablecell",
+					text: word + (idx + 1 < lineWords.length ? " " : ""),
+					options: cellProps
+				});
+			});
+		});
+		inputLines2.push(lineTokens);
+	});
+	if (verbose) {
+		console.log(`[3/4] inputLines2 (${inputLines2.length})`);
+		inputLines2.forEach((line) => console.log(`[3/4] line: ${JSON.stringify(line)}`));
+	}
+	inputLines2.forEach((line) => {
+		let lineCells = [];
+		let strCurrLine = "";
+		line.forEach((word) => {
+			const wordText = String(word.text || "");
+			if (strCurrLine.length + wordText.length > CPL) {
+				if (lineCells.length > 0) parsedLines.push(lineCells);
+				lineCells = [];
+				strCurrLine = "";
+			}
+			lineCells.push(word);
+			strCurrLine += wordText;
+		});
+		if (lineCells.length > 0) parsedLines.push(lineCells);
+	});
+	if (verbose) {
+		console.log(`[4/4] parsedLines (${parsedLines.length})`);
+		parsedLines.forEach((line, idx) => console.log(`[4/4] [Line ${idx + 1}]:\n${JSON.stringify(line)}`));
+		console.log("...............................................\n\n");
+	}
+	return parsedLines;
+}
+/**
+* The font size in points one auto-paged cell is measured at: the cell's own `fontSize`,
+* else the table's, else the library default. Pass `null` for the cell to ask the same
+* question of the table alone.
+*/
+function resolveCellFontSize(cellOpts, tableOpts) {
+	const size = cellOpts?.fontSize ?? tableOpts.fontSize;
+	return typeof size === "number" ? size : 12;
+}
+/**
+* The `autoPageCharWeight` a cell wraps at: its own, else the table's, else none.
+*
+* The sibling of {@link resolveCellFontSize}, and named for the same reason -- the two call
+* sites of {@link parseTextToLines} had resolved this one differently. The row-height probe
+* read the cell's own value; the main loop stamped the table's over it first, and `delete`d the
+* cell's when the table stated none, so a weight set on a cell alone was accepted and dropped.
+* The precedence here is the one every other paired option in this codebase uses.
+* @param cellOpts - the cell's own options, if any
+* @param tableOpts - the table's options
+*/
+function resolveCellCharWeight(cellOpts, tableOpts) {
+	const weight = cellOpts?.autoPageCharWeight ?? tableOpts.autoPageCharWeight;
+	return typeof weight === "number" ? weight : 0;
+}
+/**
+* The largest top and bottom cell margin in one row, in EMU.
+*
+* A cell's own `margin` wins over the table's when it states one, and a stated `0` counts as
+* stating one. Both sites that read this gated on truthiness and on `Array.isArray`, so a cell
+* asking for `margin: [0, …]` fell through to the table's margin instead of taking its own, and
+* a scalar `margin: 0.2` was not seen at all -- while the emitter broadcasts a scalar to four
+* sides. `resolveCellMarginsInches` is the resolver the emitter itself reads.
+* @param row - the row's cells
+* @param tableProps - the table's options, for the fallback margin
+* @returns the row's top and bottom margin allowance in EMU
+*/
+function rowMarginsEmu(row, tableProps) {
+	let topEmu = 0;
+	let btmEmu = 0;
+	row.forEach((cell) => {
+		const stated = cell?.options?.margin ?? tableProps.margin;
+		if (stated === void 0 || stated === null) return;
+		const [top, , btm] = resolveCellMarginsInches(stated);
+		if (marginToEmu(top) > topEmu) topEmu = marginToEmu(top);
+		if (marginToEmu(btm) > btmEmu) btmEmu = marginToEmu(btm);
+	});
+	return {
+		topEmu,
+		btmEmu
+	};
+}
+/**
+* Takes an array of table rows and breaks into an array of slides, which contain the calculated amount of table rows that fit on that slide
+* @param {TableCellInternal[][]} tableRows - table rows
+* @param {TableToSlidesPropsInternal} tableProps - table2slides properties
+* @param {PresLayout} presLayout - presentation layout
+* @param {SlideLayoutInternal} masterSlide - master slide
+* @return {TableRowSlide[]} array of table rows
+*/
+function getSlidesForTableRows(rows = [], tableProps = {}, presLayout, masterSlide) {
+	const tableRows = withCheckedSpans(rows);
+	let arrInchMargins = DEF_SLIDE_MARGIN_IN;
+	let emuSlideTabW;
+	let colWidthsIn = [];
+	let emuSlideTabH = EMU_PER_INCH * 1;
+	let emuTabCurrH = 0;
+	let numCols = 0;
+	let warnedNoTabH = false;
+	const tableRowSlides = [];
+	const tablePropX = getSmartParseNumber(tableProps.x, "X", presLayout);
+	const tablePropY = getSmartParseNumber(tableProps.y, "Y", presLayout);
+	const tablePropW = getSmartParseNumber(tableProps.w, "X", presLayout);
+	const tablePropH = getSmartParseNumber(tableProps.h, "Y", presLayout);
+	let tableCalcW = tablePropW;
+	/**
+	* Where this page's table starts, in EMU from the top of the slide.
+	*
+	* There used to be three rules for two cases. The first page and "every page after it"
+	* were handled together, then a block gated on `tableRowSlides.length > 1` overrode the
+	* result -- so despite its own comment it began on the THIRD page, and its first arm
+	* recomputed exactly what had just been computed. Page 2 therefore got a different usable
+	* height from pages 3 and up: with `y` above the top margin and an explicit `h`, a
+	* 60-row table paged 9 / 7 / 9 / 9 / 9 / 9 / 8, which is the same "pages disagree about
+	* how many identical rows fit" symptom the margin-reset note in `calcSlideTabH` records.
+	*
+	* It is a function rather than two expressions because the too-small-height fallback in
+	* `calcSlideTabH` had spelled the continuation arm its own way and drifted the same way
+	* twice over: `autoPageSlideStartY || margin` discarded an explicit `0` that the main rule
+	* honoured, and the `Math.min` clause below was missing outright. Two readings of one rule
+	* is what the paragraph above is about; there is now one.
+	*/
+	function startYEmu() {
+		const statedY = tableProps.y !== void 0 && tableProps.y !== null;
+		if (tableRowSlides.length === 0) return statedY ? tablePropY : inch2Emu(arrInchMargins[0]);
+		if (typeof tableProps.autoPageSlideStartY === "number") return inch2Emu(tableProps.autoPageSlideStartY);
+		return inch2Emu(statedY ? Math.min(tablePropY / EMU_PER_INCH, arrInchMargins[0]) : arrInchMargins[0]);
+	}
+	function calcSlideTabH() {
+		const emuStartY = startYEmu();
+		emuSlideTabH = (tablePropH || presLayout.height) - emuStartY - inch2Emu(arrInchMargins[2]);
+		if (tablePropH && emuSlideTabH < tablePropH) emuSlideTabH = tablePropH;
+		const emuBaseLineH = autoPageLineHeightEmu(resolveCellFontSize(null, tableProps), tableProps.autoPageLineWeight || 0);
+		if (emuSlideTabH < emuBaseLineH) {
+			const fallbackH = presLayout.height - startYEmu() - inch2Emu(arrInchMargins[2]);
+			if (!warnedNoTabH) {
+				warn("table/autopage-height-too-small", "addTable/autoPage: the table height (`h`) leaves no room to paginate; ignoring it and using the slide height. Increase `h` or decrease `y`.");
+				warnedNoTabH = true;
+			}
+			emuSlideTabH = fallbackH > 0 ? fallbackH : presLayout.height;
+		}
+	}
+	if (tableProps.verbose) {
+		console.log("[[VERBOSE MODE]]");
+		console.log("|-- TABLE PROPS --------------------------------------------------------|");
+		console.log(`| presLayout.width ................................ = ${(presLayout.width / EMU_PER_INCH).toFixed(1)}`);
+		console.log(`| presLayout.height ............................... = ${(presLayout.height / EMU_PER_INCH).toFixed(1)}`);
+		console.log(`| tableProps.x .................................... = ${typeof tableProps.x === "number" ? (tableProps.x / EMU_PER_INCH).toFixed(1) : tableProps.x}`);
+		console.log(`| tableProps.y .................................... = ${typeof tableProps.y === "number" ? (tableProps.y / EMU_PER_INCH).toFixed(1) : tableProps.y}`);
+		console.log(`| tableProps.w .................................... = ${typeof tableProps.w === "number" ? (tableProps.w / EMU_PER_INCH).toFixed(1) : tableProps.w}`);
+		console.log(`| tableProps.h .................................... = ${typeof tableProps.h === "number" ? (tableProps.h / EMU_PER_INCH).toFixed(1) : tableProps.h}`);
+		console.log(`| tableProps.slideMargin .......................... = ${tableProps.slideMargin ? String(tableProps.slideMargin) : ""}`);
+		console.log(`| tableProps.margin ............................... = ${String(tableProps.margin)}`);
+		console.log(`| tableProps.colW ................................. = ${String(tableProps.colW)}`);
+		console.log(`| tableProps.autoPageSlideStartY .................. = ${tableProps.autoPageSlideStartY}`);
+		console.log(`| tableProps.autoPageCharWeight ................... = ${tableProps.autoPageCharWeight}`);
+		console.log("|-- CALCULATIONS -------------------------------------------------------|");
+		console.log(`| tablePropX ...................................... = ${tablePropX / EMU_PER_INCH}`);
+		console.log(`| tablePropY ...................................... = ${tablePropY / EMU_PER_INCH}`);
+		console.log(`| tablePropW ...................................... = ${tablePropW / EMU_PER_INCH}`);
+		console.log(`| tablePropH ...................................... = ${tablePropH / EMU_PER_INCH}`);
+		console.log(`| tableCalcW ...................................... = ${tableCalcW / EMU_PER_INCH}`);
+	}
+	arrInchMargins = resolveSlideMarginsInches(masterSlide?._margin, tableProps.slideMargin);
+	if (tableProps.verbose) console.log(`| arrInchMargins .................................. = [${arrInchMargins.join(", ")}]`);
+	numCols = tableColCount(tableRows);
+	if (tableProps.verbose) console.log(`| numCols ......................................... = ${numCols}`);
+	const placements = tableRows.map(() => []);
+	/**
+	* How many of each row's grid columns are held by a rowspan opened ABOVE it, accumulated as
+	* the placements arrive rather than searched for afterwards.
+	*
+	* The question used to be answered by scanning every placement in the table, once per row,
+	* which is quadratic in a table of any width. Two columns of short text and no spans at all:
+	* 1000 rows took 55ms, 2000 took 115ms, 4000 took 333ms and 8000 took 1036ms. The same four
+	* now take 24ms, 19ms, 40ms and 83ms -- so it was pure overhead, paid in full by the long
+	* report table that is the whole reason this code exists.
+	*
+	* Filling forward instead is bounded by the placement's own `rowSpan`, so the total work is
+	* the sum of all rowspans. That is safe to expand without a further check because
+	* `walkTableGrid` has already clamped each `rowSpan` to `rows.length - r`: a span cannot
+	* reach past the last row however large the caller wrote it, so the sum is bounded by the
+	* grid rather than by anything the caller states.
+	*
+	* The fill starts at `row + 1`. A `rowSpan` of 1 must contribute nothing -- starting at
+	* `row` would have every ordinary row counting itself as covered, and the
+	* `coveredFromAbove(iRow) === numCols` reader below would then fire on all of them.
+	*/
+	const coveredCols = Array.from({ length: tableRows.length }, () => 0);
+	for (const placement of walkTableGrid(tableRows, numCols)) {
+		placements[placement.row]?.push(placement);
+		const last = Math.min(placement.row + placement.rowSpan, coveredCols.length);
+		for (let r = placement.row + 1; r < last; r++) coveredCols[r] = (coveredCols[r] ?? 0) + placement.colSpan;
+	}
+	/** How many of `iRow`'s grid columns are held by a rowspan opened above it. */
+	const coveredFromAbove = (iRow) => coveredCols[iRow] ?? 0;
+	/** Whether a rowspan opened above `iRow` is still covering it. */
+	const spannedFromAbove = (iRow) => coveredFromAbove(iRow) > 0;
+	if (!tablePropW && Array.isArray(tableProps.colW)) {
+		tableCalcW = tableProps.colW.reduce((p, n) => p + n, 0) * EMU_PER_INCH;
+		if (tableProps.verbose) console.log(`| tableCalcW ...................................... = ${tableCalcW / EMU_PER_INCH}`);
+	}
+	emuSlideTabW = tableCalcW || usableTableWidthEmu(presLayout, tablePropX, arrInchMargins);
+	if (tableProps.verbose) console.log(`| emuSlideTabW .................................... = ${(emuSlideTabW / EMU_PER_INCH).toFixed(1)}`);
+	colWidthsIn = resolveTableColWidthsEmu(tableProps.colW, emuSlideTabW, numCols).map((emu) => emu / EMU_PER_INCH);
+	const resolveRowH = (origRowIdx) => Array.isArray(tableProps.rowH) ? pinnedRowHeightInches(tableProps.rowH[origRowIdx]) ?? void 0 : void 0;
+	/**
+	* Wrap each of row `iRow`'s cells against the grid columns it covers, and price the row.
+	*
+	* The one row measure. The repeated header rows used to be priced by a second copy of it with its
+	* own column cursor, which ignored the columns a rowspan holds -- the fault `walkTableGrid`
+	* fixed for the main loop -- and skipped the line-height exemption for a cell that spans rows,
+	* so a header row inside a rowspan was measured against the wrong columns.
+	* @param iRow - the row's index in `tableRows`
+	* @param verbose - dump the wrapping stages, as `addTable({ verbose })` asks
+	*/
+	function measureRow(iRow, verbose) {
+		const row = tableRows[iRow] ?? [];
+		const { topEmu, btmEmu } = rowMarginsEmu(row, tableProps);
+		const rowPlacements = placements[iRow] ?? [];
+		const cells = row.map((cell, iCell) => {
+			const placed = rowPlacements[iCell];
+			const colStart = placed ? placed.col : numCols;
+			const cellColspan = placed ? placed.colSpan : resolveSpan(cell.options?.colspan, "colspan");
+			const totalColW = colWidthsIn.slice(colStart, colStart + cellColspan).reduce((prev, curr) => prev + curr, 0);
+			const fontSizePt = resolveCellFontSize(cell.options, tableProps);
+			return {
+				_type: "tablecell",
+				_lines: parseTextToLines(cell, totalColW, fontSizePt, resolveCellCharWeight(cell.options, tableProps), verbose),
+				_lineHeight: placed && placed.rowSpan > 1 ? 0 : autoPageLineHeightEmu(fontSizePt, tableProps.autoPageLineWeight || 0),
+				text: [],
+				options: cell.options || {}
+			};
+		});
+		const lineHeightEmu = cells.reduce((max, cell) => Math.max(max, cell._lineHeight), 0);
+		const maxLines = cells.reduce((max, cell) => Math.max(max, cell._lines.length), 0);
+		const marginsEmu = topEmu + btmEmu;
+		return {
+			cells,
+			marginsEmu,
+			lineHeightEmu,
+			heightEmu: marginsEmu + maxLines * lineHeightEmu
+		};
+	}
+	const repeatHeaderRows = tableProps.autoPageRepeatHeader && tableProps._arrObjTabHeadRows ? tableProps._arrObjTabHeadRows : [];
+	const repeatHeaderHeightsEmu = repeatHeaderRows.map((_row, headIdx) => measureRow(headIdx).heightEmu);
+	/**
+	* The last row of the rowspan group that row `iRow` opens: the furthest row any of its spans
+	* reaches, extended by every span a covered row opens in turn. `walkTableGrid` has clamped each
+	* span to the table, so the walk ends inside it.
+	* @param iRow - the row that opens the group
+	*/
+	function rowSpanGroupEnd(iRow) {
+		let end = iRow;
+		for (let r = iRow; r <= end; r++) for (const placement of placements[r] ?? []) end = Math.max(end, r + placement.rowSpan - 1);
+		return end;
+	}
+	let newTableRowSlide = {
+		rows: [],
+		rowH: [],
+		colW: colWidthsIn,
+		y: startYEmu() / EMU_PER_INCH
+	};
+	/** Rows placed on the working page other than its repeated header rows. */
+	let bodyRowsOnPage = 0;
+	let warnedTallRowSpan = false;
+	/**
+	* Close the working page and open the next: push the page when it has rows, re-derive the page
+	* height, charge `chargedEmu` to the new page, then repeat the header rows onto it.
+	* @param chargedEmu - what the new page already owes before its header rows: the margins of a
+	*   row that is starting over here, or nothing
+	*/
+	function startNewPage(chargedEmu) {
+		if (newTableRowSlide.rows.length > 0) tableRowSlides.push(newTableRowSlide);
+		newTableRowSlide = {
+			rows: [],
+			rowH: [],
+			colW: colWidthsIn,
+			y: startYEmu() / EMU_PER_INCH
+		};
+		bodyRowsOnPage = 0;
+		calcSlideTabH();
+		emuTabCurrH = chargedEmu;
+		if (tableProps.verbose) console.log(`| SLIDE [${tableRowSlides.length}]: emuSlideTabH ...... = ${(emuSlideTabH / EMU_PER_INCH).toFixed(1)} `);
+		repeatHeaderRows.forEach((headRow, headIdx) => {
+			newTableRowSlide.rows.push([...headRow]);
+			newTableRowSlide.rowH?.push(resolveRowH(headIdx));
+			emuTabCurrH += repeatHeaderHeightsEmu[headIdx] ?? 0;
+		});
+	}
+	tableRows.forEach((row, iRow) => {
+		const hasActiveRowSpan = spannedFromAbove(iRow);
+		let currTableRow = [];
+		row.forEach((cell) => currTableRow.push(workingCell([], cell.options)));
+		calcSlideTabH();
+		if (tableProps.verbose && iRow === 0) console.log(`| SLIDE [${tableRowSlides.length}]: emuSlideTabH ...... = ${(emuSlideTabH / EMU_PER_INCH).toFixed(1)} `);
+		const startsRowSpan = !hasActiveRowSpan && (placements[iRow] ?? []).some((placement) => placement.rowSpan > 1);
+		if (startsRowSpan) {
+			let groupHeightEmu = 0;
+			for (let r = iRow; r <= rowSpanGroupEnd(iRow); r++) groupHeightEmu += measureRow(r).heightEmu;
+			if (bodyRowsOnPage > 0 && emuTabCurrH + groupHeightEmu > emuSlideTabH) startNewPage(0);
+			if (emuTabCurrH + groupHeightEmu > emuSlideTabH && !warnedTallRowSpan) {
+				warn("table/autopage-rowspan-too-tall", "addTable/autoPage: a group of rows joined by a rowspan is taller than a page; it is kept on one page and runs past its bottom. Reduce the span or the text in it.");
+				warnedTallRowSpan = true;
+			}
+		}
+		const keepRowTogether = hasActiveRowSpan || startsRowSpan;
+		const { cells: rowCellLines, marginsEmu: rowMarginsTotalEmu, lineHeightEmu: emuLineMaxH } = measureRow(iRow, tableProps.verbose);
+		emuTabCurrH += rowMarginsTotalEmu;
+		/** E: --==[[ PAGE DATA SET ]]==--
+		* Add text one-line-a-time to this row's cells until: lines are exhausted OR table height limit is hit
+		*
+		* Design:
+		* - Building cells L-to-R/loop style wont work as one could be 100 lines and another 1 line
+		* - Therefore, build the whole row, one-line-at-a-time, across each table columns
+		* - Then, when the vertical size limit is hit is by any of the cells, make a new slide and continue adding any remaining lines
+		*
+		* Implementation:
+		* - `rowCellLines` is an array of cells, one for each column in the table, with each cell containing an array of lines
+		*
+		* Sample Data:
+		* - `rowCellLines` ..: [ TableCellInternal, TableCellInternal, TableCellInternal ]
+		* - `TableCellInternal` .....: { _type: 'tablecell', _lines: TableCellInternal[], _lineHeight: 10 }
+		* - `_lines` ........: [ {_type: 'tablecell', text: 'cell-1,line-1', options: {…}}, {_type: 'tablecell', text: 'cell-1,line-2', options: {…}} }
+		* - `_lines` is TableCellInternal[] (the 1-N words in the line)
+		* {
+		*    _lines: [{ text:'cell-1,line-1' }, { text:'cell-1,line-2' }],                                                     // TOTAL-CELL-HEIGHT = 2
+		*    _lines: [{ text:'cell-2,line-1' }, { text:'cell-2,line-2' }],                                                     // TOTAL-CELL-HEIGHT = 2
+		*    _lines: [{ text:'cell-3,line-1' }, { text:'cell-3,line-2' }, { text:'cell-3,line-3' }, { text:'cell-3,line-4' }], // TOTAL-CELL-HEIGHT = 4
+		* }
+		*
+		* Example: 2 rows, with the firstrow overflowing onto a new slide
+		* SLIDE 1:
+		*  |--------|--------|--------|--------|
+		*  | line-1 | line-1 | line-1 | line-1 |
+		*  |        |        | line-2 |        |
+		*  |        |        | line-3 |        |
+		*  |--------|--------|--------|--------|
+		*
+		* SLIDE 2:
+		*  |--------|--------|--------|--------|
+		*  |        |        | line-4 |        |
+		*  |--------|--------|--------|--------|
+		*  | line-1 | line-1 | line-1 | line-1 |
+		*  |--------|--------|--------|--------|
+		*/
+		if (tableProps.verbose) console.log(`\n| SLIDE [${tableRowSlides.length}]: ROW [${iRow}]: START...`);
+		let currCellIdx = 0;
+		let isDone = false;
+		while (!isDone) {
+			const srcCell = rowCellLines[currCellIdx];
+			if (!srcCell) break;
+			let tgtCell = currTableRow[currCellIdx];
+			if (emuTabCurrH + emuLineMaxH > emuSlideTabH && !keepRowTogether) {
+				if (tableProps.verbose) {
+					console.log("\n|-----------------------------------------------------------------------|");
+					console.log(`|-- NEW SLIDE CREATED (currTabH+currLineH > maxH) => ${(emuTabCurrH / EMU_PER_INCH).toFixed(2)} + ${(srcCell._lineHeight / EMU_PER_INCH).toFixed(2)} > ${emuSlideTabH / EMU_PER_INCH}`);
+					console.log("|-----------------------------------------------------------------------|\n\n");
+				}
+				if (currTableRow.length > 0 && currTableRow.map((cell) => Array.isArray(cell.text) ? cell.text.length : 0).reduce((p, n) => p + n) > 0) {
+					newTableRowSlide.rows.push(currTableRow);
+					newTableRowSlide.rowH?.push(resolveRowH(iRow));
+				}
+				startNewPage(rowMarginsTotalEmu);
+				currTableRow = [];
+				row.forEach((cell) => currTableRow.push(workingCell([], cell.options)));
+				tgtCell = currTableRow[currCellIdx];
+			}
+			const currLine = srcCell._lines.shift();
+			if (tgtCell && Array.isArray(tgtCell.text)) {
+				if (currLine) tgtCell.text = tgtCell.text.concat(currLine);
+				else if (tgtCell.text.length === 0) tgtCell.text = tgtCell.text.concat({
+					_type: "tablecell",
+					text: ""
+				});
+			}
+			if (currCellIdx === rowCellLines.length - 1) emuTabCurrH += emuLineMaxH;
+			currCellIdx = currCellIdx < rowCellLines.length - 1 ? currCellIdx + 1 : 0;
+			if (rowCellLines.map((cell) => cell._lines.length).reduce((prev, next) => prev + next) === 0) isDone = true;
+		}
+		if (currTableRow.length > 0 || row.length === 0 && coveredFromAbove(iRow) === numCols) {
+			newTableRowSlide.rows.push(currTableRow);
+			newTableRowSlide.rowH?.push(resolveRowH(iRow));
+			bodyRowsOnPage++;
+		}
+		if (tableProps.verbose) console.log(`- SLIDE [${tableRowSlides.length}]: ROW [${iRow}]: ...COMPLETE ...... emuTabCurrH = ${(emuTabCurrH / EMU_PER_INCH).toFixed(2)} ( emuSlideTabH = ${(emuSlideTabH / EMU_PER_INCH).toFixed(2)} )`);
+	});
+	if (newTableRowSlide.rows.length > 0 || tableRowSlides.length === 0) tableRowSlides.push(newTableRowSlide);
+	if (tableProps.verbose) {
+		console.log("\n|================================================|");
+		console.log(`| FINAL: tableRowSlides.length = ${tableRowSlides.length}`);
+		tableRowSlides.forEach((slide) => console.log(slide));
+		console.log("|================================================|\n\n");
+	}
+	return tableRowSlides;
+}
+//#endregion
+export { getSlidesForTableRows as t };
+
+//# sourceMappingURL=autopage-odPz7zZO.js.map