pptx-ts 3.7.0 → 4.0.1

package/dist/grid-DikTjFey.js

@@ -0,0 +1,187 @@
+import { l as warn } from "./errors-C4oENPcu.js";
+//#region src/gen/table/spans.ts
+/**
+* The largest `colspan`/`rowspan` this library will honour.
+*
+* Unlike the read side's point-cache ceiling there is no format number to borrow: `a:tc@gridSpan`
+* is a bare `xsd:int`. So this is a sanity bound rather than a schema one, and it is set an order
+* of magnitude past PowerPoint's own maximum table (its Insert Table dialog stops at 75 columns
+* and 75 rows), which is what makes it something no authored table can reach. What it stops is
+* the other end, where the allocation takes the host process with it.
+*/
+const MAX_TABLE_SPAN = 1e3;
+/**
+* Validate one cell's `colspan`/`rowspan`, warning and falling back to `1` when it is not a whole
+* number in `1..MAX_TABLE_SPAN`.
+*
+* `undefined` is the common case and means "no span" — it warns about nothing and returns `1`.
+* Everything else is caller error: `NaN`, a negative, a fraction and a span past the ceiling all
+* describe a table that cannot be built (a fractional span silently truncates, a negative one
+* shifts every column after it, an enormous one is the allocation above).
+*
+* The parameter is typed `unknown` because this is also **the** reading of a span for the six
+* sites that consume one after {@link withCheckedSpans} has run. Those had six different
+* coercions — `Number(x) ? … : 1`, `Math.max(1, Number(x) || 1)`, `x ?? 1` — which agreed only
+* on the values that were already valid, and one of them let a non-numeric span reach a grid
+* column count as `NaN`. Reading a span through one function is what stops them drifting apart
+* again if the up-front check is ever moved.
+* @param value - the raw option value, as the caller wrote it
+* @param kind - `'colspan'` or `'rowspan'`, for the diagnostic
+* @returns the span to use, at least 1
+*/
+function resolveSpan(value, kind) {
+	if (value === void 0 || value === null || value === "") return 1;
+	if (typeof value !== "number") {
+		warn("table/span-out-of-range", `table cell: ${kind} must be a whole number between 1 and ${MAX_TABLE_SPAN}; got ${String(value)}. Using 1.`);
+		return 1;
+	}
+	if (!Number.isInteger(value) || value < 1 || value > 1e3) {
+		warn("table/span-out-of-range", `table cell: ${kind} must be a whole number between 1 and ${MAX_TABLE_SPAN}; got ${String(value)}. Using 1.`);
+		return 1;
+	}
+	return value;
+}
+/**
+* Re-clone `rows` with every out-of-range `colspan`/`rowspan` corrected to `1`.
+*
+* Runs once, up front, so the column count, the `_hmerge`/`_vmerge` dummies, the auto-pager's
+* grid and the emitted `gridSpan`/`rowSpan` attributes all read the same number — checking at
+* each of those sites instead would warn several times per bad cell and could still disagree.
+*
+* A cell whose spans are fine is passed through by identity, not copied: `_spanOrigin` links the
+* merge dummies back to the origin *object*, and the all-valid path is every real table, which
+* must stay allocation-free and byte-identical.
+* @param rows - the rows to check; row arrays are never mutated
+* @returns the same rows with only the offending cells replaced
+*/
+function withCheckedSpans(rows) {
+	return rows.map((cells) => cells.map((cell) => {
+		const opts = cell?.options;
+		if (!opts) return cell;
+		const colspan = resolveSpan(opts.colspan, "colspan");
+		const rowspan = resolveSpan(opts.rowspan, "rowspan");
+		const colspanOk = opts.colspan === void 0 || opts.colspan === colspan;
+		const rowspanOk = opts.rowspan === void 0 || opts.rowspan === rowspan;
+		if (colspanOk && rowspanOk) return cell;
+		return {
+			...cell,
+			options: {
+				...opts,
+				...opts.colspan === void 0 ? {} : { colspan },
+				...opts.rowspan === void 0 ? {} : { rowspan }
+			}
+		};
+	}));
+}
+/**
+* Whether any cell in the grid carries a hyperlink — on the cell itself, or on any run of a
+* cell whose `text` is a run array.
+*
+* `addTable` uses this to decide whether to stand its black text default down: the default is
+* direct formatting on the table, so it would paint the words *after* a link black rather than
+* letting them follow the link colour. The test used to be
+* `JSON.stringify({ arrRows }).includes('hyperlink')`, which matched the literal word anywhere
+* in the grid's *content* — a cell reading "see the hyperlink docs" suppressed the default for
+* the whole table — and serialized every cell on every `addTable` to ask.
+* @param rows - the table's rows
+*/
+function tableHasHyperlink(rows) {
+	return rows.some((cells) => cells.some((cell) => {
+		if (!cell) return false;
+		if (cell.options?.hyperlink) return true;
+		if (!Array.isArray(cell.text)) return false;
+		return cell.text.some((run) => !!run?.options?.hyperlink);
+	}));
+}
+//#endregion
+//#region src/gen/table/grid.ts
+/**
+* How many grid columns a table has: the sum of the first row's colspans.
+*
+* The count cannot come from `rows[0].length` -- a colspan makes one cell occupy several
+* columns -- and it is read off the first row alone, which is the writer's standing rule: a
+* later row wider than the first is ragged input, and the grid it is measured, paged and
+* emitted against is the one `a:tblGrid` declares.
+*/
+function tableColCount(rows) {
+	const first = rows[0];
+	return first ? first.reduce((n, c) => n + resolveSpan(c?.options?.colspan, "colspan"), 0) : 0;
+}
+/**
+* The rowspan-occupancy rule, stated once.
+*
+* A row states only the cells it *starts*: a column held by a `rowspan` from above is filled
+* without the row mentioning it, so a cell's position in its row array is not its column. Tracking
+* that is three operations -- skip what is held, mark what this cell holds, age the holds by a row
+* -- and getting the ageing off by one silently shifts every column below.
+*
+* It has two callers asking different questions on different input. {@link walkTableGrid} places
+* authored `TableCell`s into a grid whose width `a:tblGrid` already declares; `measureGridColumns`
+* (`gen/table/html-dom.ts`) measures how wide an imported HTML table's grid *is*, reading spans off
+* HTML attributes, with no width known up front. Neither can be expressed as the other without
+* giving one of them a mode it does not want -- but the rule underneath is the same rule, and it is
+* here rather than in both.
+*
+* The array is sparse and unbounded on purpose: a caller that knows its width clamps what it
+* `hold`s, and then nothing past that width is ever held, so an unbounded `nextFree` returns the
+* same answer a bounded one would.
+*/
+function createRowSpanOccupancy() {
+	const held = [];
+	return {
+		nextFree(col) {
+			let free = col;
+			while ((held[free] ?? 0) > 0) free++;
+			return free;
+		},
+		hold(col, colSpan, rowSpan) {
+			for (let idx = 0; idx < colSpan; idx++) held[col + idx] = rowSpan;
+		},
+		endRow() {
+			for (let idx = 0; idx < held.length; idx++) {
+				const rows = held[idx] ?? 0;
+				if (rows > 0) held[idx] = rows - 1;
+			}
+		}
+	};
+}
+/**
+* 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. This is the single traversal the
+* auto-pager, the measured-fit shrink pass, {@link computeTableLayout} and the table emitter's
+* merge grid all read, so the table that is paged and measured is the table that is written.
+*
+* A cell that starts past the last grid column is not yielded: a row longer than the first is
+* ragged input, and the grid is the one `a:tblGrid` declares.
+*/
+function* walkTableGrid(rows, numCols) {
+	const occupancy = createRowSpanOccupancy();
+	for (let r = 0; r < rows.length; r++) {
+		const row = rows[r];
+		if (!row) continue;
+		let col = 0;
+		for (const cell of row) {
+			col = occupancy.nextFree(col);
+			if (col >= numCols) break;
+			const colspan = resolveSpan(cell?.options?.colspan, "colspan");
+			const rowspan = Math.min(resolveSpan(cell?.options?.rowspan, "rowspan"), rows.length - r);
+			const colStart = col;
+			const colEnd = Math.min(colStart + colspan, numCols);
+			occupancy.hold(colStart, colEnd - colStart, rowspan);
+			col = colEnd;
+			yield {
+				cell,
+				row: r,
+				col: colStart,
+				rowSpan: rowspan,
+				colSpan: colEnd - colStart
+			};
+		}
+		occupancy.endRow();
+	}
+}
+//#endregion
+export { resolveSpan as a, MAX_TABLE_SPAN as i, tableColCount as n, tableHasHyperlink as o, walkTableGrid as r, withCheckedSpans as s, createRowSpanOccupancy as t };
+
+//# sourceMappingURL=grid-DikTjFey.js.map

package/dist/grid-DikTjFey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-DikTjFey.js","names":[],"sources":["../src/gen/table/spans.ts","../src/gen/table/grid.ts"],"sourcesContent":["/**\n * ts-pptx: table `colspan`/`rowspan` range checking.\n *\n * The spans decide two allocations, on two different paths, and both used to trust the caller:\n * the merge grid's `new Array(colspan - 1)` in `gen/slide/objects/table.ts`, and the auto-pager's\n * per-column depth array, sized from a column count that is a sum of colspans\n * (`gen/table/autopage.ts`). `new Array(4294967294).fill(undefined)` is not a slow path — V8\n * aborts on the allocation and there is no exception to catch — so a table built with\n * `autoPage: true` and one without needed the same guard, which is why it lives here rather than\n * in either of them.\n *\n * This is the write side, so the bad number comes from the calling program rather than from a\n * hostile file, which makes it far less serious than the read-side twin in the chart point caches\n * (`read/oxml/point-cache.ts`, the model this copies). It is still the project's stated line: warn\n * on out-of-range input rather than emit a degenerate result.\n */\n\nimport type { TableCellInternal } from '../../types/internal.js'\nimport { warn } from '../../diagnostics.js'\n\n/**\n * The largest `colspan`/`rowspan` this library will honour.\n *\n * Unlike the read side's point-cache ceiling there is no format number to borrow: `a:tc@gridSpan`\n * is a bare `xsd:int`. So this is a sanity bound rather than a schema one, and it is set an order\n * of magnitude past PowerPoint's own maximum table (its Insert Table dialog stops at 75 columns\n * and 75 rows), which is what makes it something no authored table can reach. What it stops is\n * the other end, where the allocation takes the host process with it.\n */\nexport const MAX_TABLE_SPAN = 1000\n\n/**\n * Validate one cell's `colspan`/`rowspan`, warning and falling back to `1` when it is not a whole\n * number in `1..MAX_TABLE_SPAN`.\n *\n * `undefined` is the common case and means \"no span\" — it warns about nothing and returns `1`.\n * Everything else is caller error: `NaN`, a negative, a fraction and a span past the ceiling all\n * describe a table that cannot be built (a fractional span silently truncates, a negative one\n * shifts every column after it, an enormous one is the allocation above).\n *\n * The parameter is typed `unknown` because this is also **the** reading of a span for the six\n * sites that consume one after {@link withCheckedSpans} has run. Those had six different\n * coercions — `Number(x) ? … : 1`, `Math.max(1, Number(x) || 1)`, `x ?? 1` — which agreed only\n * on the values that were already valid, and one of them let a non-numeric span reach a grid\n * column count as `NaN`. Reading a span through one function is what stops them drifting apart\n * again if the up-front check is ever moved.\n * @param value - the raw option value, as the caller wrote it\n * @param kind - `'colspan'` or `'rowspan'`, for the diagnostic\n * @returns the span to use, at least 1\n */\nexport function resolveSpan(value: unknown, kind: 'colspan' | 'rowspan'): number {\n\tif (value === undefined || value === null || value === '') return 1\n\tif (typeof value !== 'number') {\n\t\twarn(\n\t\t\t'table/span-out-of-range',\n\t\t\t`table cell: ${kind} must be a whole number between 1 and ${MAX_TABLE_SPAN}; got ${String(value)}. Using 1.`\n\t\t)\n\t\treturn 1\n\t}\n\tif (!Number.isInteger(value) || value < 1 || value > MAX_TABLE_SPAN) {\n\t\twarn(\n\t\t\t'table/span-out-of-range',\n\t\t\t`table cell: ${kind} must be a whole number between 1 and ${MAX_TABLE_SPAN}; got ${String(value)}. Using 1.`\n\t\t)\n\t\treturn 1\n\t}\n\treturn value\n}\n\n/**\n * Re-clone `rows` with every out-of-range `colspan`/`rowspan` corrected to `1`.\n *\n * Runs once, up front, so the column count, the `_hmerge`/`_vmerge` dummies, the auto-pager's\n * grid and the emitted `gridSpan`/`rowSpan` attributes all read the same number — checking at\n * each of those sites instead would warn several times per bad cell and could still disagree.\n *\n * A cell whose spans are fine is passed through by identity, not copied: `_spanOrigin` links the\n * merge dummies back to the origin *object*, and the all-valid path is every real table, which\n * must stay allocation-free and byte-identical.\n * @param rows - the rows to check; row arrays are never mutated\n * @returns the same rows with only the offending cells replaced\n */\nexport function withCheckedSpans(rows: TableCellInternal[][]): TableCellInternal[][] {\n\treturn rows.map((cells) =>\n\t\tcells.map((cell) => {\n\t\t\tconst opts = cell?.options\n\t\t\tif (!opts) return cell\n\t\t\tconst colspan = resolveSpan(opts.colspan, 'colspan')\n\t\t\tconst rowspan = resolveSpan(opts.rowspan, 'rowspan')\n\t\t\tconst colspanOk = opts.colspan === undefined || opts.colspan === colspan\n\t\t\tconst rowspanOk = opts.rowspan === undefined || opts.rowspan === rowspan\n\t\t\tif (colspanOk && rowspanOk) return cell\n\t\t\treturn {\n\t\t\t\t...cell,\n\t\t\t\toptions: {\n\t\t\t\t\t...opts,\n\t\t\t\t\t...(opts.colspan === undefined ? {} : { colspan }),\n\t\t\t\t\t...(opts.rowspan === undefined ? {} : { rowspan }),\n\t\t\t\t},\n\t\t\t}\n\t\t})\n\t)\n}\n\n/**\n * Whether any cell in the grid carries a hyperlink — on the cell itself, or on any run of a\n * cell whose `text` is a run array.\n *\n * `addTable` uses this to decide whether to stand its black text default down: the default is\n * direct formatting on the table, so it would paint the words *after* a link black rather than\n * letting them follow the link colour. The test used to be\n * `JSON.stringify({ arrRows }).includes('hyperlink')`, which matched the literal word anywhere\n * in the grid's *content* — a cell reading \"see the hyperlink docs\" suppressed the default for\n * the whole table — and serialized every cell on every `addTable` to ask.\n * @param rows - the table's rows\n */\nexport function tableHasHyperlink(rows: TableCellInternal[][]): boolean {\n\treturn rows.some((cells) =>\n\t\tcells.some((cell) => {\n\t\t\tif (!cell) return false\n\t\t\tif (cell.options?.hyperlink) return true\n\t\t\tif (!Array.isArray(cell.text)) return false\n\t\t\treturn cell.text.some((run) => !!run?.options?.hyperlink)\n\t\t})\n\t)\n}\n","/**\n * ts-pptx: a table's cell grid.\n *\n * Rows arrive lopsided -- `row1: [A, B, C]`, `row2: [D]` when the first two columns are held by\n * a rowspan from above -- so a cell's position in its row array is not its column. Four places\n * needed to know where a cell actually lands (the auto-pager, twice, in one function; the\n * measured-fit pass; the table emitter) and each walked the grid itself, tracking rowspan\n * occupancy in its own array with its own off-by-one convention.\n *\n * This is that traversal, once. It lives beside {@link resolveSpan} rather than in `measure/`\n * because the grid is a fact about the authored table, not a measurement of it -- the pager and\n * the emitter want it as much as the fitter does, and `measure/table-fit.ts` was already\n * reaching into `gen/table/` for the span reader it is built on.\n */\n\nimport type { TableCellInternal } from '../../types/internal.js'\nimport { resolveSpan } from './spans.js'\n\n/**\n * How many grid columns a table has: the sum of the first row's colspans.\n *\n * The count cannot come from `rows[0].length` -- a colspan makes one cell occupy several\n * columns -- and it is read off the first row alone, which is the writer's standing rule: a\n * later row wider than the first is ragged input, and the grid it is measured, paged and\n * emitted against is the one `a:tblGrid` declares.\n */\nexport function tableColCount(rows: TableCellInternal[][]): number {\n\tconst first = rows[0]\n\treturn first ? first.reduce((n, c) => n + resolveSpan(c?.options?.colspan, 'colspan'), 0) : 0\n}\n\n/** The bookkeeping a row-major grid walk needs to route around rowspans; see {@link createRowSpanOccupancy}. */\ninterface RowSpanOccupancy {\n\t/** The first column at or after `col` that no rowspan from above is holding. */\n\tnextFree: (col: number) => number\n\t/** Record that `colSpan` columns from `col` are held for `rowSpan` rows, this one included. */\n\thold: (col: number, colSpan: number, rowSpan: number) => void\n\t/** Close the current row: every held column has one fewer row left to hold. */\n\tendRow: () => void\n}\n\n/**\n * The rowspan-occupancy rule, stated once.\n *\n * A row states only the cells it *starts*: a column held by a `rowspan` from above is filled\n * without the row mentioning it, so a cell's position in its row array is not its column. Tracking\n * that is three operations -- skip what is held, mark what this cell holds, age the holds by a row\n * -- and getting the ageing off by one silently shifts every column below.\n *\n * It has two callers asking different questions on different input. {@link walkTableGrid} places\n * authored `TableCell`s into a grid whose width `a:tblGrid` already declares; `measureGridColumns`\n * (`gen/table/html-dom.ts`) measures how wide an imported HTML table's grid *is*, reading spans off\n * HTML attributes, with no width known up front. Neither can be expressed as the other without\n * giving one of them a mode it does not want -- but the rule underneath is the same rule, and it is\n * here rather than in both.\n *\n * The array is sparse and unbounded on purpose: a caller that knows its width clamps what it\n * `hold`s, and then nothing past that width is ever held, so an unbounded `nextFree` returns the\n * same answer a bounded one would.\n */\nexport function createRowSpanOccupancy(): RowSpanOccupancy {\n\t// held[c] = rows still covered by a rowspan started at or above the current row.\n\tconst held: number[] = []\n\treturn {\n\t\tnextFree(col) {\n\t\t\tlet free = col\n\t\t\twhile ((held[free] ?? 0) > 0) free++\n\t\t\treturn free\n\t\t},\n\t\thold(col, colSpan, rowSpan) {\n\t\t\tfor (let idx = 0; idx < colSpan; idx++) held[col + idx] = rowSpan\n\t\t},\n\t\tendRow() {\n\t\t\tfor (let idx = 0; idx < held.length; idx++) {\n\t\t\t\tconst rows = held[idx] ?? 0\n\t\t\t\tif (rows > 0) held[idx] = rows - 1\n\t\t\t}\n\t\t},\n\t}\n}\n\n/** A placed (non-merged origin) cell yielded by {@link walkTableGrid}. */\nexport interface GridPlacement {\n\tcell: TableCellInternal\n\t/** Zero-based grid row of the cell's top-left origin. */\n\trow: number\n\t/** Zero-based grid column of the cell's top-left origin. */\n\tcol: number\n\t/** Rows spanned, clamped to the available rows. */\n\trowSpan: number\n\t/** Columns spanned, clamped to the grid width. */\n\tcolSpan: number\n}\n\n/**\n * Walk a table's cell grid in row-major order, resolving each authored cell to its\n * grid origin (`row`/`col`) and clamped colspan/rowspan. Tracks rowspan occupancy so\n * a cell never lands beneath one spanned from above. This is the single traversal the\n * auto-pager, the measured-fit shrink pass, {@link computeTableLayout} and the table emitter's\n * merge grid all read, so the table that is paged and measured is the table that is written.\n *\n * A cell that starts past the last grid column is not yielded: a row longer than the first is\n * ragged input, and the grid is the one `a:tblGrid` declares.\n */\nexport function* walkTableGrid(rows: TableCellInternal[][], numCols: number): Generator<GridPlacement> {\n\tconst occupancy = createRowSpanOccupancy()\n\tfor (let r = 0; r < rows.length; r++) {\n\t\tconst row = rows[r]\n\t\tif (!row) continue\n\t\tlet col = 0\n\t\tfor (const cell of row) {\n\t\t\tcol = occupancy.nextFree(col)\n\t\t\tif (col >= numCols) break\n\t\t\tconst colspan = resolveSpan(cell?.options?.colspan, 'colspan')\n\t\t\tconst rowspan = Math.min(resolveSpan(cell?.options?.rowspan, 'rowspan'), rows.length - r)\n\t\t\tconst colStart = col\n\t\t\t// Clamped to the declared width, which is also what keeps `nextFree` unbounded and still\n\t\t\t// correct: nothing past `numCols` is ever held, so it never has a reason to walk past it.\n\t\t\tconst colEnd = Math.min(colStart + colspan, numCols)\n\t\t\toccupancy.hold(colStart, colEnd - colStart, rowspan)\n\t\t\tcol = colEnd\n\t\t\tyield { cell, row: r, col: colStart, rowSpan: rowspan, colSpan: colEnd - colStart }\n\t\t}\n\t\toccupancy.endRow()\n\t}\n}\n"],"mappings":"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"}

package/dist/{html-dom-B0I0QSbU.js → html-dom-Iuog2wdK.js}

@@ -1,9 +1,28 @@
-import { r as EMU_PER_INCH, x as warn } from "./units-1kRzYShk.js";
-import { n as InvalidOptionError } from "./errors-Bvln0H-7.js";
-import { a as inch2Emu } from "./units-internal-Dg95w_YD.js";
-import { t as getSlidesForTableRows } from "./autopage-DkjYZUFD.js";
+import { l as warn, n as InvalidOptionError } from "./errors-C4oENPcu.js";
+import { C as usableTableWidthEmu, c as inch2Emu, s as getSmartParseNumber, 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, t as createRowSpanOccupancy } from "./grid-DikTjFey.js";
+import { t as getSlidesForTableRows } from "./autopage-odPz7zZO.js";
 //#region src/gen/table/html-dom.ts
 /**
+* CSS `text-align` / `vertical-align` values this converter can express as a table cell's own
+* alignment. The two logical values map onto the physical pair; everything else — `justify`,
+* `initial`, a value the browser did not resolve — is absent here and so leaves the cell's
+* alignment alone.
+*/
+const CSS_TEXT_ALIGN = {
+	left: "left",
+	center: "center",
+	right: "right",
+	start: "left",
+	end: "right"
+};
+const CSS_VERTICAL_ALIGN = {
+	top: "top",
+	middle: "middle",
+	bottom: "bottom"
+};
+/**
 * Stand-in for `getComputedStyle` on a document that has no view — a document produced by
 * parsing rather than by a browsing context has a `null` `defaultView` and therefore no
 * cascade to compute against. Every property reads as `''`, which every consumer below
@@ -82,18 +101,25 @@ function rgbToHex(r, g, b) {
 * Convert a computed CSS border (width string + color string) from `getComputedStyle` into a
 * pptx `BorderProps`.
 *
+* `StrokeProps.width` is in **points**, so the px magnitude is converted through
+* {@link htmlCssPxToPoints} rather than copied across: a `1px` CSS border is 0.75pt, not 1pt.
+* This was the third read in this file to make that mistake and the last one left — the font
+* size and the cell padding were each corrected against `DEFAULT_PX_PER_INCH` on their own, and
+* routing this one through the same converter is what stops a fourth from drifting apart again.
+*
 * Preserves *fractional* widths: a hairline CSS border such as `0.5px` must not be rounded to
 * `0pt` and silently vanish — the table serializer (`ptsToEmuLenient`) emits fractional points just
 * fine, so there is no reason to integer-round here. A
 * computed width of `0` (or a non-finite value) yields `{ type: 'none' }` so we never emit a
-* zero-width line.
+* zero-width line. `''`, `auto` and `3em` are non-finite for the same reason
+* {@link parseCssPx} says they are, and take the same exit.
 * @param {string} widthStr - computed `border-<side>-width`, e.g. `"0.5px"`
 * @param {string} colorStr - computed `border-<side>-color`, e.g. `"rgb(102, 102, 102)"`
 * @returns {BorderProps} border props for the cell side
 */
 function htmlBorderToProps(widthStr, colorStr) {
-	const pt = Number(String(widthStr).replace("px", ""));
-	if (!isFinite(pt) || pt <= 0) return { type: "none" };
+	const pt = htmlCssPxToPoints(widthStr);
+	if (!Number.isFinite(pt) || pt <= 0) return { type: "none" };
 	return {
 		width: pt,
 		color: cssColorToHex(colorStr) ?? "000000"
@@ -124,7 +150,7 @@ function cssColorToHex(value) {
 		const parts = (rgbMatch[1] ?? "").split(/[,/\s]+/).filter((part) => part.length > 0);
 		if (parts.length < 3) return void 0;
 		const channels = parts.slice(0, 3).map((part) => Number(part.replace("%", "")));
-		if (channels.some((channel) => !isFinite(channel))) return void 0;
+		if (channels.some((channel) => !Number.isFinite(channel))) return void 0;
 		if (parts.length > 3 && Number(parts[3]) === 0) return void 0;
 		const [r = 0, g = 0, b = 0] = channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))));
 		return rgbToHex(r, g, b);
@@ -150,9 +176,9 @@ function cssColorToHex(value) {
 * @returns {number} resolved column width
 */
 function resolveHtmlColWidth(calcWidth, setWidth, minWidth) {
-	const safeCalc = isFinite(calcWidth) ? calcWidth : 0;
-	if (isFinite(setWidth) && setWidth > 0) return setWidth;
-	return isFinite(minWidth) && minWidth > safeCalc ? minWidth : safeCalc;
+	const safeCalc = Number.isFinite(calcWidth) ? calcWidth : 0;
+	if (Number.isFinite(setWidth) && setWidth > 0) return setWidth;
+	return Number.isFinite(minWidth) && minWidth > safeCalc ? minWidth : safeCalc;
 }
 /** A CSS value that is a bare number, or a number with a `px`/`%` unit. Nothing else parses. */
 const CSS_LENGTH = /^\s*(-?(?:\d+\.?\d*|\.\d+))\s*(px|%)?\s*$/i;
@@ -174,6 +200,30 @@ function parseCssPx(value) {
 	return Number(match[1]);
 }
 /**
+* A computed CSS px length as the points every `pt`-measured table property is in, or `NaN` when
+* the value is not an absolute px length.
+*
+* This is the file's **one** px→pt conversion, and it is one because the same mistake was made
+* three separate times under the same stale "px to pt 1:1" note. A default `16px` cell emitted
+* `sz="1600"` — 16pt, a third larger than the 12pt the browser rendered; the cell padding read
+* a px magnitude as the inches `TableCellProps.margin` wants, until 2026-07-31; and a `1px`
+* border was emitted as 1pt, a third too thick. Each was found and corrected on its own, and
+* the next went on being wrong, because there was no shared converter for a sweep to land on.
+* Now there is, for the two properties measured in points. The padding is not one of them --
+* it resolves to inches -- so it divides by `DEFAULT_PX_PER_INCH` at its own site and this
+* comment is the link between them.
+*
+* CSS defines the reference pixel as 1/96in, so the conversion is the same density the `"<n>px"`
+* coordinate unit uses. An `em`, a `%` or a keyword has no absolute size here and comes back
+* `NaN`, which each caller reads as its own kind of absence — the font size is left off the
+* cell, and a border becomes `{ type: 'none' }`.
+* @param value - computed CSS value, e.g. `"16px"`
+* @returns the length in points, or `NaN` when the value is not an absolute px length
+*/
+function htmlCssPxToPoints(value) {
+	return parseCssPx(value) * 72 / 96;
+}
+/**
 * Parse a whole row of computed CSS widths into a column basis, or reject the set.
 *
 * The result is only ever used *proportionally* (each column's share of the total), so the
@@ -197,7 +247,7 @@ function parseCssWidthBasis(values) {
 		const match = CSS_LENGTH.exec(String(value ?? ""));
 		if (!match) return [];
 		const magnitude = Number(match[1]);
-		if (!isFinite(magnitude) || magnitude < 0) return [];
+		if (!Number.isFinite(magnitude) || magnitude < 0) return [];
 		const valueUnit = (match[2] ?? "px").toLowerCase();
 		if (!unit) unit = valueUnit;
 		else if (unit !== valueUnit) return [];
@@ -238,7 +288,7 @@ function parseCssWidthBasis(values) {
 * @returns {number[]} the basis vector to run the proportional calc on
 */
 function pickColWidthBasis(measured, cssWidths) {
-	const sum = (arr) => arr.reduce((acc, n) => acc + (isFinite(n) ? n : 0), 0);
+	const sum = (arr) => arr.reduce((acc, n) => acc + (Number.isFinite(n) ? n : 0), 0);
 	if (sum(measured) > 0) return [...measured];
 	if (cssWidths.length === measured.length && sum(cssWidths) > 0) return [...cssWidths];
 	return measured.map(() => 1);
@@ -253,9 +303,10 @@ function pickColWidthBasis(measured, cssWidths) {
 * @param {unknown} value - the raw attribute value
 * @returns {number} tracks covered, at least 1
 */
-function gridSpan(value) {
+function gridSpan(value, kind) {
 	const num = Math.floor(Number(value));
-	return isFinite(num) && num > 1 ? num : 1;
+	if (!Number.isFinite(num) || num <= 1) return 1;
+	return num > 1e3 ? resolveSpan(num, kind) : num;
 }
 /**
 * Measure the column grid a set of table rows actually occupies.
@@ -271,27 +322,26 @@ function gridSpan(value) {
 * the two is exactly the padding a ragged row needs; the merge cells for `colspan`/`rowspan` are
 * *not* padding — the table emitter synthesizes those itself, so they are counted as filled here.
 *
-* Spans are read through {@link gridSpan}, so a bad attribute cannot shift the whole grid.
+* Spans are read through {@link gridSpan}, so a bad attribute cannot shift the whole grid. The
+* occupancy bookkeeping underneath is {@link createRowSpanOccupancy}, shared with
+* `walkTableGrid` -- the same rowspan rule, asked a different question: that one places authored
+* cells into a grid whose width is already declared, this one measures how wide the grid *is*.
 * @param {readonly (readonly GridCellSpans[])[]} rows - per-row cell spans, in emission order
 * @returns {{ columns: number, filled: number[] }} grid width, and columns reached per row
 */
 function measureGridColumns(rows) {
-	const carry = [];
+	const occupancy = createRowSpanOccupancy();
 	const filled = [];
 	for (const row of rows) {
 		let col = 0;
 		for (const cell of row) {
-			while ((carry[col] ?? 0) > 0) col++;
-			const colspan = gridSpan(cell?.colspan);
-			for (let idx = 0; idx < colspan; idx++) carry[col + idx] = gridSpan(cell?.rowspan);
+			col = occupancy.nextFree(col);
+			const colspan = gridSpan(cell?.colspan, "colspan");
+			occupancy.hold(col, colspan, gridSpan(cell?.rowspan, "rowspan"));
 			col += colspan;
 		}
-		while ((carry[col] ?? 0) > 0) col++;
-		filled.push(col);
-		for (let idx = 0; idx < carry.length; idx++) {
-			const held = carry[idx] ?? 0;
-			if (held > 0) carry[idx] = held - 1;
-		}
+		filled.push(occupancy.nextFree(col));
+		occupancy.endRow();
 	}
 	return {
 		columns: filled.reduce((max, reached) => reached > max ? reached : max, 0),
@@ -312,7 +362,7 @@ function measureGridColumns(rows) {
 */
 function extendColBasis(basis, columns) {
 	const extended = [...basis];
-	const total = extended.reduce((acc, width) => acc + (isFinite(width) ? width : 0), 0);
+	const total = extended.reduce((acc, width) => acc + (Number.isFinite(width) ? width : 0), 0);
 	const share = extended.length > 0 && total > 0 ? total / extended.length : 1;
 	while (extended.length < columns) extended.push(share);
 	return extended;
@@ -463,10 +513,8 @@ function collectTableRows(table) {
 * @param {TableToSlidesProps} options - array of options (e.g.: tabsize)
 */
 function genTableToSlides(pptx, target, options = {}) {
-	const opts = options || {};
+	const opts = { ...options };
 	const masterSlide = resolveMasterSlide(pptx, opts.masterTitle);
-	opts.slideMargin = opts.slideMargin || opts.slideMargin === 0 ? opts.slideMargin : .5;
-	let emuSlideTabW = opts.w || pptx.presLayout.width;
 	const arrObjTabHeadRows = [];
 	const arrObjTabBodyRows = [];
 	const arrObjTabFootRows = [];
@@ -481,25 +529,9 @@ function genTableToSlides(pptx, target, options = {}) {
 	];
 	let intTabW = 0;
 	const ctx = resolveDomContext(target, opts);
-	if (masterSlide?._margin) {
-		if (Array.isArray(masterSlide._margin)) arrInchMargins = masterSlide._margin;
-		else if (!isNaN(masterSlide._margin)) arrInchMargins = [
-			masterSlide._margin,
-			masterSlide._margin,
-			masterSlide._margin,
-			masterSlide._margin
-		];
-		opts.slideMargin = arrInchMargins;
-	} else if (opts?.slideMargin) {
-		if (Array.isArray(opts.slideMargin)) arrInchMargins = opts.slideMargin;
-		else if (!isNaN(opts.slideMargin)) arrInchMargins = [
-			opts.slideMargin,
-			opts.slideMargin,
-			opts.slideMargin,
-			opts.slideMargin
-		];
-	}
-	emuSlideTabW = (opts.w ? inch2Emu(opts.w) : pptx.presLayout.width) - inch2Emu(arrInchMargins[1] + arrInchMargins[3]);
+	arrInchMargins = resolveSlideMarginsInches(masterSlide?._margin, opts.slideMargin);
+	const tableXEmu = opts.x === void 0 || opts.x === null ? inch2Emu(arrInchMargins[3]) : getSmartParseNumber(opts.x, "X", pptx.presLayout);
+	const emuSlideTabW = opts.w === void 0 || opts.w === null ? usableTableWidthEmu(pptx.presLayout, tableXEmu, arrInchMargins) : getSmartParseNumber(opts.w, "X", pptx.presLayout);
 	if (opts.verbose) {
 		console.log("[[VERBOSE MODE]]");
 		console.log("|-- `tableToSlides` ----------------------------------------------------|");
@@ -510,19 +542,28 @@ function genTableToSlides(pptx, target, options = {}) {
 		console.log(`| emuSlideTabW .................................... = ${(emuSlideTabW / EMU_PER_INCH).toFixed(1)}`);
 	}
 	const domRows = collectTableRows(ctx.table);
-	const { columns: intColCnt, filled: arrRowFilled } = measureGridColumns(domRows.map(({ row }) => rowCells(row).map((cell) => ({
-		colspan: Number(cell.getAttribute("colspan")),
-		rowspan: Number(cell.getAttribute("rowspan"))
-	}))));
+	const spansByCell = /* @__PURE__ */ new Map();
+	const spansOf = (cell) => {
+		let spans = spansByCell.get(cell);
+		if (!spans) {
+			spans = {
+				colspan: gridSpan(cell.getAttribute("colspan"), "colspan"),
+				rowspan: gridSpan(cell.getAttribute("rowspan"), "rowspan")
+			};
+			spansByCell.set(cell, spans);
+		}
+		return spans;
+	};
+	const { columns: intColCnt, filled: arrRowFilled } = measureGridColumns(domRows.map(({ row }) => rowCells(row).map(spansOf)));
 	const srcRow = domRows.find(({ row }) => rowCells(row).length > 0);
 	if (!srcRow) throw new InvalidOptionError("html/table-has-no-cells", "tableToSlides: the table has no cells to convert - expected at least one <tr> with a <td>/<th>.");
 	const arrColSrc = [];
 	const arrCellSpans = [];
 	rowCells(srcRow.row).forEach((cell) => {
 		const offsetW = Number(cell.offsetWidth);
-		const measured = isFinite(offsetW) ? offsetW : 0;
+		const measured = Number.isFinite(offsetW) ? offsetW : 0;
 		arrTabColCssW.push(ctx.getComputedStyle(cell).getPropertyValue("width"));
-		const span = gridSpan(cell.getAttribute("colspan"));
+		const span = spansOf(cell).colspan;
 		arrCellSpans.push(span);
 		for (let idxc = 0; idxc < span; idxc++) {
 			arrTabColW.push(Math.round(measured / span));
@@ -559,33 +600,19 @@ function genTableToSlides(pptx, target, options = {}) {
 			const cellOpts = {
 				bold: !!(style.getPropertyValue("font-weight") === "bold" || Number(style.getPropertyValue("font-weight")) >= 500),
 				color: textColor,
-				fill: { color: fillColor },
-				fontSize: Number(style.getPropertyValue("font-size").replace(/[a-z]/gi, ""))
+				fill: { color: fillColor }
 			};
+			const fontSizePt = htmlCssPxToPoints(style.getPropertyValue("font-size"));
+			if (Number.isFinite(fontSizePt)) cellOpts.fontSize = fontSizePt;
 			const fontFace = ((style.getPropertyValue("font-family") || "").split(",")[0] ?? "").replace(/"/g, "").replace("inherit", "").replace("initial", "");
-			const colspan = gridSpan(cell.getAttribute("colspan"));
-			const rowspan = gridSpan(cell.getAttribute("rowspan"));
+			const { colspan, rowspan } = spansOf(cell);
 			if (fontFace) cellOpts.fontFace = fontFace;
 			if (colspan > 1) cellOpts.colspan = colspan;
 			if (rowspan > 1) cellOpts.rowspan = rowspan;
-			if ([
-				"left",
-				"center",
-				"right",
-				"start",
-				"end"
-			].includes(style.getPropertyValue("text-align"))) {
-				const align = style.getPropertyValue("text-align").replace("start", "left").replace("end", "right");
-				cellOpts.align = align === "center" ? "center" : align === "left" ? "left" : align === "right" ? "right" : void 0;
-			}
-			if ([
-				"top",
-				"middle",
-				"bottom"
-			].includes(style.getPropertyValue("vertical-align"))) {
-				const valign = style.getPropertyValue("vertical-align");
-				cellOpts.valign = valign === "top" ? "top" : valign === "middle" ? "middle" : valign === "bottom" ? "bottom" : void 0;
-			}
+			const align = CSS_TEXT_ALIGN[style.getPropertyValue("text-align")];
+			if (align) cellOpts.align = align;
+			const valign = CSS_VERTICAL_ALIGN[style.getPropertyValue("vertical-align")];
+			if (valign) cellOpts.valign = valign;
 			if (style.getPropertyValue("padding-left")) {
 				const cellMargin = [
 					0,
@@ -600,7 +627,7 @@ function genTableToSlides(pptx, target, options = {}) {
 					"padding-left"
 				].forEach((val, idxs) => {
 					const pad = parseCssPx(style.getPropertyValue(val));
-					cellMargin[idxs] = isFinite(pad) ? pad / 96 : 0;
+					cellMargin[idxs] = Number.isFinite(pad) ? pad / 96 : 0;
 				});
 				cellOpts.margin = cellMargin;
 			}
@@ -642,29 +669,32 @@ function genTableToSlides(pptx, target, options = {}) {
 		...arrObjTabHeadRows,
 		...arrObjTabBodyRows,
 		...arrObjTabFootRows
-	], opts, pptx.presLayout, masterSlide).forEach((slide, idxTr) => {
-		const newSlide = pptx.addSlide({ masterTitle: opts.masterTitle || void 0 });
-		if (idxTr === 0) opts.y = opts.y || arrInchMargins[0];
-		if (idxTr > 0) opts.y = opts.autoPageSlideStartY || arrInchMargins[0];
+	], opts, pptx.presLayout, masterSlide).forEach((slide) => {
+		const newSlide = pptx.addSlide(opts.masterTitle ? { masterTitle: opts.masterTitle } : {});
+		if (slide.y !== void 0) opts.y = slide.y;
 		if (opts.verbose) console.log(`| opts.autoPageSlideStartY: ${opts.autoPageSlideStartY} / arrInchMargins[0]: ${arrInchMargins[0]} => opts.y = ${opts.y}`);
-		newSlide.addTable(slide.rows, {
-			x: opts.x || arrInchMargins[3],
-			y: opts.y,
+		const slideTableProps = {
+			x: opts.x ?? arrInchMargins[3],
 			w: Number(emuSlideTabW) / EMU_PER_INCH,
 			colW: arrColW,
 			autoPage: false
-		});
+		};
+		if (opts.y !== void 0) slideTableProps.y = opts.y;
+		newSlide.addTable(slide.rows, slideTableProps);
 		if (opts.addImage) {
 			opts.addImage.options = opts.addImage.options || {};
 			if (!opts.addImage.image || !opts.addImage.image.path && !opts.addImage.image.data) warn("html/image-missing-source", "tableToSlides.addImage requires either `path` or `data`");
 			else {
 				const imageProps = opts.addImage.image.path ? { path: opts.addImage.image.path } : { data: opts.addImage.image.data };
+				const imageOptions = opts.addImage.options;
+				const geometry = {};
+				if (imageOptions.x !== void 0) geometry.x = imageOptions.x;
+				if (imageOptions.y !== void 0) geometry.y = imageOptions.y;
+				if (imageOptions.w !== void 0) geometry.w = imageOptions.w;
+				if (imageOptions.h !== void 0) geometry.h = imageOptions.h;
 				newSlide.addImage({
 					...imageProps,
-					x: opts.addImage.options.x,
-					y: opts.addImage.options.y,
-					w: opts.addImage.options.w,
-					h: opts.addImage.options.h
+					...geometry
 				});
 			}
 		}
@@ -676,4 +706,4 @@ function genTableToSlides(pptx, target, options = {}) {
 //#endregion
 export { genTableToSlides as t };
 
-//# sourceMappingURL=html-dom-B0I0QSbU.js.map
+//# sourceMappingURL=html-dom-Iuog2wdK.js.map