@shbernal/ts-pptx 0.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2022 Brent Ely
+Copyright (c) 2026 shbernal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,238 @@
+# ts-pptx
+
+[![npm](https://img.shields.io/npm/v/@shbernal/ts-pptx)](https://www.npmjs.com/package/@shbernal/ts-pptx)
+[![CI](https://github.com/shbernal/ts-pptx/actions/workflows/ci.yml/badge.svg)](https://github.com/shbernal/ts-pptx/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+ts-pptx generates PowerPoint `.pptx` files from TypeScript and modern
+JavaScript. This project targets ESM package consumers, typed application code,
+reproducible package verification, and agent-assisted OOXML development.
+
+> **Lineage.** ts-pptx descends from [gitbrent/PptxGenJS](https://github.com/gitbrent/PptxGenJS)
+> (MIT), detached at its v6.0.0 (June 2025) and developed independently since. It
+> does not track, merge from, or mirror the original project, and pursues its own
+> Node-first direction (see _Project Target_). The original work remains under its
+> MIT license — see _License_ below.
+
+## Project Target
+
+- Generate standards-based PowerPoint `.pptx` packages without requiring
+  PowerPoint at runtime.
+- Support TypeScript-first workflows with checked declarations and modern
+  bundler resolution.
+- Ship a small, explicit ESM package boundary for Node.js, Vite, React,
+  Angular, Electron, and similar modern toolchains.
+- Keep OOXML changes grounded in fixtures, schema validation, and PowerPoint
+  compatibility evidence.
+- Make the repository practical for human and agent-driven maintenance.
+
+## Install
+
+```bash
+pnpm add @shbernal/ts-pptx
+```
+
+```bash
+npm install @shbernal/ts-pptx
+```
+
+```bash
+yarn add @shbernal/ts-pptx
+```
+
+## Quick Start
+
+```ts
+import TsPptx from "@shbernal/ts-pptx"
+
+const pptx = new TsPptx()
+const slide = pptx.addSlide()
+
+slide.addText("Hello from ts-pptx", {
+  x: 1,
+  y: 1,
+  w: 8,
+  h: 1,
+  fontSize: 24,
+  color: "363636",
+})
+
+await pptx.writeFile({ fileName: "example.pptx" })
+```
+
+## What It Can Generate
+
+- Slides, layouts, masters, sections, notes, and metadata.
+- Text, tables, shapes, images, SVGs, charts, and media.
+- Browser-downloadable, streamed, buffered, Blob, base64, or file outputs,
+  depending on the runtime.
+- OOXML that is intended to open cleanly in Microsoft PowerPoint and other
+  `.pptx` consumers such as Keynote, LibreOffice Impress, and Google Slides
+  import.
+
+## Scope And Contributions
+
+This project is **Node-first**: it generates and is tested without a browser or any
+office application. Two areas are out of *active* maintenance scope — not because
+they lack merit, but because there is no in-house use case driving them, so the
+maintainer generally will not pick up bugs or feature requests there:
+
+- **Live-DOM / browser-layout features** — anything whose answer comes from a
+  *rendered* page: real `offsetWidth` after layout, the resolved cascade, fonts as
+  the browser actually chose them. (Converting an HTML `<table>` is *not* in this
+  category — see [HTML tables → slides](#html-tables--slides) below. Only real
+  measurement needs a browser.)
+- **Third-party office-suite interop quirks** that appear only after a file is
+  round-tripped through another application (for example, copy/paste inside WPS
+  Office, then opening in PowerPoint) when the generated package is itself valid
+  OOXML. The supported bar is that output opens cleanly in Microsoft PowerPoint.
+
+**Contributions in these areas are welcome** — issues and pull requests are
+encouraged even though the maintainer is not actively developing them. See
+[`docs/project-target.md`](docs/project-target.md) for the full scope statement
+and suggested testing approaches.
+
+## Runtime And Package Support
+
+The package is ESM-only.
+
+Supported package surface:
+
+- `import TsPptx, { ShapeType } from "@shbernal/ts-pptx"` (enums, shared types, and
+  layout helpers ship from the main entry)
+- `import { inspectPptx } from "@shbernal/ts-pptx/inspect"`
+- `import { measureText } from "@shbernal/ts-pptx/measure"`
+- `import { Presentation } from "@shbernal/ts-pptx/read"`
+- `import { latexToOmml } from "@shbernal/ts-pptx/math"`
+- `import { tableToSlides } from "@shbernal/ts-pptx/html"`
+- `import TsPptx from "@shbernal/ts-pptx/node"`
+- `import TsPptx from "@shbernal/ts-pptx/browser"`
+  — the bare specifier resolves to one of these two by export condition, so Node
+  and bundled browser apps get the right build without naming it. A runtime that
+  sets neither (Deno, Bun, edge workers) gets a runtime-agnostic build that
+  authors and exports bytes normally but has no `writeFile` destination; see
+  [Runtime And Package Support](docs/runtime-and-package-support.md#which-build-the-bare-import-gives-you).
+- generated runtime and declaration artifacts under `dist/`
+- Node.js `>=24`
+- modern bundlers and module-aware app frameworks
+
+Deliberately not supported:
+
+- No CommonJS: no `require("@shbernal/ts-pptx")`, no CJS export condition, and no
+  `.cjs` artifact. Modern Node.js may provide `require()` interop for ESM, but it
+  is not a maintained API.
+- No IIFE/global browser bundle: no classic-script global, no `dist/*.bundle.js`,
+  and no `dist/*.min.js`.
+
+Use the package exports rather than direct `dist/` artifact paths.
+
+See [runtime and package support](docs/runtime-and-package-support.md) for the
+complete support contract.
+
+## HTML Tables → Slides
+
+`@shbernal/ts-pptx/html` reproduces an existing HTML `<table>` as a PowerPoint
+table, auto-paging across as many slides as its rows need. It works in the
+browser and under Node with any DOM implementation, from one artifact.
+
+```ts
+import { TsPptx } from '@shbernal/ts-pptx'
+import { tableToSlides } from '@shbernal/ts-pptx/html'
+import { Window } from 'happy-dom'
+
+const win = new Window()
+win.document.body.innerHTML = '<table id="report">…</table>'
+
+const pptx = new TsPptx()
+tableToSlides(pptx, win.document.getElementById('report'))
+await pptx.writeFile({ fileName: 'report.pptx' })
+```
+
+Pass the element itself and no global DOM is consulted at all. To pass a string
+id instead, say which document it belongs to:
+
+```ts
+tableToSlides(pptx, 'report', { document: win.document })
+```
+
+In a browser, `options.document` defaults to the global `document`, so
+`tableToSlides(pptx, 'report')` is enough. The equivalent method form,
+`pptx.tableToSlides('report', options)`, remains on the browser build and
+delegates to the same implementation.
+
+**Column widths need a layout engine.** In a browser the columns are sized from
+each cell's rendered `offsetWidth`, reproducing the table's real proportions.
+Nothing outside a browser lays a table out, so `offsetWidth` is `0` there and
+the conversion degrades in two steps: it uses the computed CSS `width`s when the
+stylesheet states them for every column in one unit (all `px` or all `%`), and
+an equal split when it does not.
+
+To pin widths regardless of runtime, annotate the `<thead>` header cells — these
+win outright on every path:
+
+```html
+<thead>
+  <tr>
+    <th data-pptx-width="2.5">Name</th>
+    <th data-pptx-min-width="1">Qty</th>
+  </tr>
+</thead>
+```
+
+Everything else behaves the same wherever it runs: cell text (with `<br>` kept
+as a line break), `colspan`/`rowspan`, computed colors, weight, alignment,
+padding and borders, and auto-paging.
+
+## Documentation
+
+The full documentation site is published at
+**<https://shbernal.github.io/ts-pptx/>**, including the generated API reference.
+
+- [Documentation index](docs/README.md)
+- [Project target](docs/project-target.md)
+- [Runtime and package support](docs/runtime-and-package-support.md)
+- [Development guide](docs/development.md)
+- [Testing guide](docs/testing.md)
+- [Agent development guide](docs/agent-development.md)
+- [OOXML agent context](docs/ooxml-agent-context.md)
+- [Backlog workflow](docs/backlog-workflow.md)
+
+## Repository Development
+
+This repository uses `pnpm` and requires Node.js `>=24`.
+
+```bash
+pnpm install
+pnpm run verify
+```
+
+OOXML serialization changes should also add or update a schema fixture in
+`test/schema-cases.js`. The schema suite needs the validator installed once:
+
+```bash
+./tools/ooxml-validator/install.sh
+```
+
+Package-boundary changes should run:
+
+```bash
+pnpm run check:package
+```
+
+## Demos
+
+- `demos/node` exercises Node.js ESM generation and stream output.
+- `demos/vite-demo` exercises a modern React, TypeScript, and Vite app.
+
+## Relationship To Upstream
+
+ts-pptx builds on the original work of Brent Ely and the gitbrent/PptxGenJS
+contributors. The modernized package target is intentionally narrower than the
+original in order to simplify the runtime contract and keep maintenance focused.
+
+## License
+
+Copyright (c) 2015-2022 Brent Ely.
+Modifications copyright (c) 2026 shbernal.
+
+[MIT](LICENSE)

package/dist/autopage-tmfjRzL4.js

@@ -0,0 +1,420 @@
+import { n as warn } from "./diagnostics-DYQC7xLV.js";
+import { i as EMU_PER_POINT, r as EMU_PER_INCH } from "./units-B-JUKwCS.js";
+import { E as DEF_SLIDE_MARGIN_IN, P as LINEH_MODIFIER, i as inch2Emu, o as marginToEmu, r as getSmartParseNumber } from "./units-internal-7JcMfYti.js";
+//#region src/gen/table/autopage.ts
+/**
+* Break cell text into lines based upon table column width (e.g.: Magic Happens Here(tm))
+* @param {TableCell} cell - table cell
+* @param {number} colWidth - table column width (inches)
+* @return {TableRow[]} - cell's text objects grouped into lines
+*/
+function parseTextToLines(cell, colWidth, verbose) {
+	const FOCO = 2.3 + (cell.options?.autoPageCharWeight ? cell.options.autoPageCharWeight : 0);
+	const CPL = Math.floor(colWidth / EMU_PER_POINT * EMU_PER_INCH) / ((cell.options?.fontSize ? cell.options.fontSize : 12) / FOCO);
+	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({
+					_type: "tablecell",
+					text: part,
+					options: cell.options
+				});
+				else {
+					newLine.push({
+						_type: "tablecell",
+						text: part,
+						options: {
+							...cell.options,
+							breakLine: true
+						}
+					});
+					inputLines1.push(newLine);
+					newLine = [];
+				}
+			});
+		} else newLine.push({
+			_type: "tablecell",
+			text: cell.text.trim(),
+			options: 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) {
+				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;
+}
+/**
+* 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 {TableCell[][]} tableRows - table rows
+* @param {TableToSlidesProps} tableProps - table2slides properties
+* @param {PresLayout} presLayout - presentation layout
+* @param {SlideLayoutInternal} masterSlide - master slide
+* @return {TableRowSlide[]} array of table rows
+*/
+function getSlidesForTableRows(tableRows = [], tableProps = {}, presLayout, masterSlide) {
+	let arrInchMargins = DEF_SLIDE_MARGIN_IN;
+	let emuSlideTabW;
+	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;
+	function calcSlideTabH() {
+		let emuStartY = 0;
+		if (tableRowSlides.length === 0) emuStartY = tablePropY || inch2Emu(arrInchMargins[0]);
+		if (tableRowSlides.length > 0) emuStartY = inch2Emu(tableProps.autoPageSlideStartY || arrInchMargins[0]);
+		emuSlideTabH = (tablePropH || presLayout.height) - emuStartY - inch2Emu(arrInchMargins[2]);
+		if (tableRowSlides.length === 0 && tablePropH && emuSlideTabH < tablePropH) emuSlideTabH = tablePropH;
+		if (tableRowSlides.length > 1) {
+			if (typeof tableProps.autoPageSlideStartY === "number") emuSlideTabH = (tablePropH || presLayout.height) - inch2Emu(tableProps.autoPageSlideStartY + arrInchMargins[2]);
+			else if (tablePropY) {
+				emuSlideTabH = (tablePropH || presLayout.height) - inch2Emu((tablePropY / 914400 < arrInchMargins[0] ? tablePropY / EMU_PER_INCH : arrInchMargins[0]) + arrInchMargins[2]);
+				if (emuSlideTabH < tablePropH) emuSlideTabH = tablePropH;
+			}
+		}
+		const emuBaseLineH = inch2Emu((typeof tableProps.fontSize === "number" ? tableProps.fontSize : 12) * (LINEH_MODIFIER + (tableProps.autoPageLineWeight || 0)) / 100);
+		if (emuSlideTabH < emuBaseLineH) {
+			const emuStartY = tableRowSlides.length === 0 ? tablePropY || inch2Emu(arrInchMargins[0]) : inch2Emu(tableProps.autoPageSlideStartY || arrInchMargins[0]);
+			const fallbackH = presLayout.height - emuStartY - 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}`);
+	}
+	if (!tableProps.slideMargin && tableProps.slideMargin !== 0) tableProps.slideMargin = DEF_SLIDE_MARGIN_IN[0];
+	if (masterSlide && typeof masterSlide._margin !== "undefined") {
+		if (Array.isArray(masterSlide._margin)) arrInchMargins = masterSlide._margin;
+		else if (!isNaN(Number(masterSlide._margin))) arrInchMargins = [
+			Number(masterSlide._margin),
+			Number(masterSlide._margin),
+			Number(masterSlide._margin),
+			Number(masterSlide._margin)
+		];
+	} else if (tableProps.slideMargin || tableProps.slideMargin === 0) {
+		if (Array.isArray(tableProps.slideMargin)) arrInchMargins = tableProps.slideMargin;
+		else if (!isNaN(tableProps.slideMargin)) arrInchMargins = [
+			tableProps.slideMargin,
+			tableProps.slideMargin,
+			tableProps.slideMargin,
+			tableProps.slideMargin
+		];
+	}
+	if (tableProps.verbose) console.log(`| arrInchMargins .................................. = [${arrInchMargins.join(", ")}]`);
+	(tableRows[0] || []).forEach((cell) => {
+		if (!cell) cell = { _type: "tablecell" };
+		const cellOpts = cell.options || null;
+		numCols += Number(cellOpts?.colspan ? cellOpts.colspan : 1);
+	});
+	if (tableProps.verbose) console.log(`| numCols ......................................... = ${numCols}`);
+	const colSpanDepths = new Array(numCols).fill(0);
+	if (!tablePropW && tableProps.colW) {
+		tableCalcW = Array.isArray(tableProps.colW) ? tableProps.colW.reduce((p, n) => p + n) * EMU_PER_INCH : tableProps.colW * numCols || 0;
+		if (tableProps.verbose) console.log(`| tableCalcW ...................................... = ${tableCalcW / EMU_PER_INCH}`);
+	}
+	emuSlideTabW = tableCalcW || inch2Emu((tablePropX ? tablePropX / 914400 : arrInchMargins[1]) + arrInchMargins[3]);
+	if (tableProps.verbose) console.log(`| emuSlideTabW .................................... = ${(emuSlideTabW / EMU_PER_INCH).toFixed(1)}`);
+	if (!tableProps.colW || !Array.isArray(tableProps.colW)) if (tableProps.colW && !isNaN(Number(tableProps.colW))) {
+		const arrColW = [];
+		const colW = Number(tableProps.colW);
+		(tableRows[0] || []).forEach(() => arrColW.push(colW));
+		tableProps.colW = [];
+		arrColW.forEach((val) => {
+			if (Array.isArray(tableProps.colW)) tableProps.colW.push(val);
+		});
+	} else {
+		tableProps.colW = [];
+		for (let iCol = 0; iCol < numCols; iCol++) tableProps.colW.push(emuSlideTabW / EMU_PER_INCH / numCols);
+	}
+	const resolveRowH = (origRowIdx) => Array.isArray(tableProps.rowH) && typeof tableProps.rowH[origRowIdx] === "number" ? tableProps.rowH[origRowIdx] : void 0;
+	let newTableRowSlide = {
+		rows: [],
+		rowH: []
+	};
+	tableRows.forEach((row, iRow) => {
+		const hasActiveRowSpan = colSpanDepths.some((d) => d > 0);
+		const rowCellLines = [];
+		let maxCellMarTopEmu = 0;
+		let maxCellMarBtmEmu = 0;
+		let currTableRow = [];
+		row.forEach((cell) => {
+			currTableRow.push({
+				_type: "tablecell",
+				text: [],
+				options: cell.options
+			});
+			const cellMargin = Array.isArray(cell.options?.margin) ? cell.options.margin : void 0;
+			const tableMargin = Array.isArray(tableProps.margin) ? tableProps.margin : null;
+			if (cellMargin?.[0] && marginToEmu(cellMargin[0]) > maxCellMarTopEmu) maxCellMarTopEmu = marginToEmu(cellMargin[0]);
+			else if (tableMargin?.[0] && marginToEmu(tableMargin[0]) > maxCellMarTopEmu) maxCellMarTopEmu = marginToEmu(tableMargin[0]);
+			if (cellMargin?.[2] && marginToEmu(cellMargin[2]) > maxCellMarBtmEmu) maxCellMarBtmEmu = marginToEmu(cellMargin[2]);
+			else if (tableMargin?.[2] && marginToEmu(tableMargin[2]) > maxCellMarBtmEmu) maxCellMarBtmEmu = marginToEmu(tableMargin[2]);
+		});
+		calcSlideTabH();
+		emuTabCurrH += maxCellMarTopEmu + maxCellMarBtmEmu;
+		if (tableProps.verbose && iRow === 0) console.log(`| SLIDE [${tableRowSlides.length}]: emuSlideTabH ...... = ${(emuSlideTabH / EMU_PER_INCH).toFixed(1)} `);
+		row.forEach((cell, iCell) => {
+			const newCellOptions = cell.options || {};
+			const newCell = {
+				_type: "tablecell",
+				_lines: [],
+				_lineHeight: inch2Emu((cell.options?.fontSize ? cell.options.fontSize : tableProps.fontSize ? tableProps.fontSize : 12) * (LINEH_MODIFIER + (tableProps.autoPageLineWeight ? tableProps.autoPageLineWeight : 0)) / 100),
+				text: [],
+				options: newCellOptions
+			};
+			if (newCellOptions.rowspan) newCell._lineHeight = 0;
+			newCellOptions.autoPageCharWeight = tableProps.autoPageCharWeight || void 0;
+			const tableColW = Array.isArray(tableProps.colW) ? tableProps.colW : [];
+			let totalColW = tableColW[iCell] ?? 0;
+			const cellColspan = cell.options?.colspan;
+			if (cellColspan) totalColW = tableColW.filter((_cell, idx) => idx >= iCell && idx < idx + cellColspan).reduce((prev, curr) => prev + curr);
+			newCell._lines = parseTextToLines(cell, totalColW, false);
+			rowCellLines.push(newCell);
+		});
+		/** 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` ..: [ TableCell, TableCell, TableCell ]
+		* - `TableCell` .....: { _type: 'tablecell', _lines: TableCell[], _lineHeight: 10 }
+		* - `_lines` ........: [ {_type: 'tablecell', text: 'cell-1,line-1', options: {…}}, {_type: 'tablecell', text: 'cell-1,line-2', options: {…}} }
+		* - `_lines` is TableCell[] (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 emuLineMaxH = 0;
+		let isDone = false;
+		while (!isDone) {
+			const srcCell = rowCellLines[currCellIdx];
+			if (!srcCell) break;
+			let tgtCell = currTableRow[currCellIdx];
+			rowCellLines.forEach((cell) => {
+				if (cell._lineHeight >= emuLineMaxH) emuLineMaxH = cell._lineHeight;
+			});
+			if (emuTabCurrH + emuLineMaxH > emuSlideTabH && !hasActiveRowSpan) {
+				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));
+				}
+				if (newTableRowSlide.rows.length > 0) tableRowSlides.push(newTableRowSlide);
+				newTableRowSlide = {
+					rows: [],
+					rowH: []
+				};
+				currTableRow = [];
+				row.forEach((cell) => currTableRow.push({
+					_type: "tablecell",
+					text: [],
+					options: cell.options
+				}));
+				calcSlideTabH();
+				emuTabCurrH += maxCellMarTopEmu + maxCellMarBtmEmu;
+				if (tableProps.verbose) console.log(`| SLIDE [${tableRowSlides.length}]: emuSlideTabH ...... = ${(emuSlideTabH / EMU_PER_INCH).toFixed(1)} `);
+				emuTabCurrH = 0;
+				if (tableProps.autoPageRepeatHeader && tableProps._arrObjTabHeadRows) tableProps._arrObjTabHeadRows.forEach((row, headIdx) => {
+					const newHeadRow = [];
+					let maxLineHeight = 0;
+					row.forEach((cell) => {
+						newHeadRow.push(cell);
+						if ((cell._lineHeight || 0) > maxLineHeight) maxLineHeight = cell._lineHeight || 0;
+					});
+					newTableRowSlide.rows.push(newHeadRow);
+					newTableRowSlide.rowH?.push(resolveRowH(headIdx));
+					emuTabCurrH += maxLineHeight;
+				});
+				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) {
+			newTableRowSlide.rows.push(currTableRow);
+			newTableRowSlide.rowH?.push(resolveRowH(iRow));
+		}
+		const occupiedBefore = [...colSpanDepths];
+		let colCursor = 0;
+		row.forEach((cell) => {
+			while (colCursor < numCols && (occupiedBefore[colCursor] ?? 0) > 0) colCursor++;
+			const cellColspan = cell.options?.colspan ?? 1;
+			const cellRowspan = cell.options?.rowspan ?? 1;
+			if (cellRowspan > 1) for (let c = 0; c < cellColspan && colCursor + c < numCols; c++) colSpanDepths[colCursor + c] = cellRowspan;
+			colCursor += cellColspan;
+		});
+		for (let c = 0; c < numCols; c++) {
+			const depth = colSpanDepths[c] ?? 0;
+			if (depth > 0) colSpanDepths[c] = depth - 1;
+		}
+		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-tmfjRzL4.js.map