@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/layout-bridge/engine/selectionRects.js

@@ -0,0 +1,485 @@
+import { measureRun } from "../../layout-engine/measure/measureProvider.js";
+import { buildRunFontStyle } from "../../layout-engine/measure/measureHelpers.js";
+import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
+import { measuredLineContentOffset } from "../../layout-engine/lineFlow.js";
+import { measureParagraph } from "../../layout-engine/measure/measureParagraph.js";
+import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "../../layout-engine/measure/tableCellFloating.js";
+import { getHeaderRowsHeight } from "../../layout-engine/index.js";
+import { getPageTop } from "./hitTest.js";
+//#region src/layout-bridge/engine/selectionRects.ts
+/**
+* Selection Rectangles
+*
+* Converts ProseMirror selection ranges into screen rectangles for rendering
+* selection highlights and the caret cursor.
+*
+* The main function `selectionToRects` takes a PM range and returns an array
+* of rectangles that cover the selected text across all pages and fragments.
+*/
+/**
+* Width (px) of the highlight sliver painted for an empty paragraph the
+* selection spans. A genuinely empty paragraph has a zero-length line, so the
+* normal run-span overlap produces no rect; a fixed sliver keeps drag-selection
+* across blank lines visible (eigenpal/docx-editor#836).
+*/
+const EMPTY_PARAGRAPH_SLIVER_WIDTH = 4;
+const DEFAULT_TABLE_CELL_PADDING_LEFT = 7;
+const DEFAULT_TABLE_CELL_PADDING_TOP = 1;
+/**
+* Extract FontStyle from a run for measurement.
+*/
+function runToFontStyle(run) {
+	return buildRunFontStyle(run, "Arial", 12);
+}
+function mathRunToFontStyle(run) {
+	return {
+		fontFamily: run.fontFamily ?? "Cambria Math",
+		fontSize: run.fontSize ?? 11,
+		...run.bold !== void 0 ? { bold: run.bold } : {},
+		...run.italic !== void 0 ? { italic: run.italic } : {},
+		...run.letterSpacing !== void 0 ? { letterSpacing: run.letterSpacing } : {},
+		...run.horizontalScale !== void 0 ? { horizontalScale: run.horizontalScale } : {}
+	};
+}
+/**
+* Find a block by its ID.
+*/
+function findBlockById(blocks, blockId) {
+	return blocks.findIndex((block) => block.id === blockId);
+}
+function getCellContentOffsetY(cell, cellMeasure, rowHeight) {
+	const padTop = cell.padding?.top ?? DEFAULT_TABLE_CELL_PADDING_TOP;
+	const spareHeight = Math.max(0, rowHeight - cellMeasure.height);
+	if (cell.verticalAlign === "bottom") return padTop + spareHeight;
+	if (cell.verticalAlign === "center") return padTop + spareHeight / 2;
+	return padTop;
+}
+function getCellContentOffsetX(cell) {
+	return cell.padding?.left ?? DEFAULT_TABLE_CELL_PADDING_LEFT;
+}
+function getMeasuredBlockHeight(measure) {
+	if (!measure) return 0;
+	if ("totalHeight" in measure) return measure.totalHeight;
+	if ("height" in measure) return measure.height;
+	return 0;
+}
+/** Clamp a projected PM position to the run's own end position. */
+function clampToRunPmEnd(run, position) {
+	return run.pmEnd === void 0 ? position : Math.min(position, run.pmEnd);
+}
+/**
+* Calculate the PM range for a line.
+* Note: ProseMirror positions include node boundaries:
+* - blockPmStart is the position of the paragraph node itself
+* - The actual text content starts at blockPmStart + 1 (after the opening tag)
+*
+* Prefers the runs' own PM metadata over cumulative character counting:
+* template-preview value runs carry the source marker's PM range with a
+* different text length, so the one-PM-position-per-character assumption
+* the char-counting fallback makes does not hold for them.
+*/
+function computeLinePmRange(block, line) {
+	const fromRun = block.runs[line.fromRun];
+	const toRun = block.runs[line.toRun];
+	if (fromRun?.pmStart !== void 0 && toRun?.pmStart !== void 0) return {
+		pmStart: fromRun.kind === "text" ? clampToRunPmEnd(fromRun, fromRun.pmStart + line.fromChar) : fromRun.pmStart,
+		pmEnd: toRun.kind === "text" ? clampToRunPmEnd(toRun, toRun.pmStart + line.toChar) : toRun.pmEnd ?? toRun.pmStart + 1
+	};
+	const contentStart = (block.pmStart ?? 0) + 1;
+	let charOffset = 0;
+	let pmStart;
+	for (let runIndex = 0; runIndex < block.runs.length && runIndex <= line.toRun; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run) continue;
+		if (runIndex < line.fromRun) if (run.kind === "text") charOffset += run.text.length;
+		else charOffset += 1;
+		else if (runIndex === line.fromRun) {
+			charOffset += line.fromChar;
+			pmStart = contentStart + charOffset;
+			break;
+		}
+	}
+	if (pmStart === void 0) pmStart = contentStart;
+	let lineLength = 0;
+	for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run) continue;
+		if (run.kind === "text") {
+			const text = run.text;
+			const start = runIndex === line.fromRun ? line.fromChar : 0;
+			const end = runIndex === line.toRun ? line.toChar : text.length;
+			lineLength += end - start;
+		} else lineLength += 1;
+	}
+	const pmEnd = pmStart + lineLength;
+	return {
+		pmStart,
+		pmEnd
+	};
+}
+/**
+* Find lines in a paragraph that intersect with a PM range.
+*/
+function findLinesInRange(block, measure, from, to) {
+	const result = [];
+	for (let i = 0; i < measure.lines.length; i++) {
+		const line = measure.lines[i];
+		const range = computeLinePmRange(block, line);
+		if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+		if (range.pmStart === range.pmEnd ? from < to && range.pmStart >= from && range.pmStart <= to : range.pmEnd > from && range.pmStart < to) result.push({
+			line,
+			index: i
+		});
+	}
+	return result;
+}
+/**
+* Convert a PM position to a character offset within a line.
+*
+* Walks the line's runs and maps through each run's own PM range, so runs
+* whose text length differs from their PM span (template-preview value
+* runs) keep the rest of the line aligned: positions inside the marker
+* clamp to the value text, positions after it land after the value. Falls
+* back to the legacy whole-line subtraction when a run lacks PM metadata.
+*/
+function pmPosToCharOffset(block, line, pmPos) {
+	let charOffset = 0;
+	for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run) continue;
+		if (run.pmStart === void 0) {
+			const range = computeLinePmRange(block, line);
+			if (range.pmStart === void 0) return 0;
+			return Math.max(0, pmPos - range.pmStart);
+		}
+		if (run.kind === "text") {
+			const startChar = runIndex === line.fromRun ? line.fromChar : 0;
+			const endChar = runIndex === line.toRun ? line.toChar : run.text.length;
+			const sliceLength = Math.max(0, endChar - startChar);
+			const slicePmStart = clampToRunPmEnd(run, run.pmStart + startChar);
+			const slicePmEnd = clampToRunPmEnd(run, run.pmStart + endChar);
+			if (pmPos <= slicePmStart) return charOffset;
+			if (pmPos < slicePmEnd) return charOffset + Math.min(pmPos - slicePmStart, sliceLength);
+			charOffset += sliceLength;
+			continue;
+		}
+		if (pmPos <= run.pmStart) return charOffset;
+		charOffset += 1;
+	}
+	return charOffset;
+}
+/**
+* Get the X coordinate for a character offset within a line.
+*/
+function charOffsetToX(block, line, charOffset, _availableWidth) {
+	let x = 0;
+	let charsProcessed = 0;
+	for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run) continue;
+		if (run.kind === "tab") {
+			const tabWidth = run.width ?? 48;
+			if (charsProcessed + 1 >= charOffset) {
+				if (charOffset <= charsProcessed) return x;
+				return x + tabWidth;
+			}
+			x += tabWidth;
+			charsProcessed += 1;
+			continue;
+		}
+		if (run.kind === "image") {
+			const imageWidth = inlineImageBoundingBox(run).width;
+			if (charsProcessed + 1 >= charOffset) {
+				if (charOffset <= charsProcessed) return x;
+				return x + imageWidth;
+			}
+			x += imageWidth;
+			charsProcessed += 1;
+			continue;
+		}
+		if (run.kind === "lineBreak") {
+			if (charOffset <= charsProcessed) return x;
+			charsProcessed += 1;
+			continue;
+		}
+		if (run.kind === "math") {
+			const mathWidth = measureRun(run.plainText, mathRunToFontStyle(run)).width;
+			if (charsProcessed + 1 >= charOffset) {
+				if (charOffset <= charsProcessed) return x;
+				return x + mathWidth;
+			}
+			x += mathWidth;
+			charsProcessed += 1;
+			continue;
+		}
+		if (run.kind === "text") {
+			const text = run.text;
+			const isFirstRun = runIndex === line.fromRun;
+			const isLastRun = runIndex === line.toRun;
+			const start = isFirstRun ? line.fromChar : 0;
+			const end = isLastRun ? line.toChar : text.length;
+			const lineText = text.slice(start, end);
+			if (charsProcessed + lineText.length >= charOffset) {
+				const charInRun = charOffset - charsProcessed;
+				const style = runToFontStyle(run);
+				const measurement = measureRun(lineText.slice(0, charInRun), style);
+				return x + measurement.width;
+			}
+			const measurement = measureRun(lineText, runToFontStyle(run));
+			x += measurement.width;
+			charsProcessed += lineText.length;
+		}
+	}
+	return x;
+}
+/**
+* Convert a ProseMirror selection range to screen rectangles.
+*
+* @param layout - The document layout.
+* @param blocks - All flow blocks.
+* @param measures - All measurements.
+* @param from - Start PM position.
+* @param to - End PM position.
+* @returns Array of rectangles covering the selection.
+*/
+function selectionToRects(layout, blocks, measures, from, to) {
+	if (from === to) return [];
+	const selFrom = Math.min(from, to);
+	const selTo = Math.max(from, to);
+	const rects = [];
+	for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
+		const page = layout.pages[pageIndex];
+		const pageTopY = getPageTop(layout, pageIndex);
+		for (const fragment of page.fragments) {
+			if (fragment.kind === "paragraph") {
+				const blockIndex = findBlockById(blocks, fragment.blockId);
+				if (blockIndex === -1) continue;
+				const block = blocks[blockIndex];
+				const measure = measures[blockIndex];
+				if (!block || block.kind !== "paragraph") continue;
+				if (!measure || measure.kind !== "paragraph") continue;
+				const paragraphBlock = block;
+				const paragraphMeasure = measure;
+				const paragraphFragment = fragment;
+				const intersectingLines = findLinesInRange(paragraphBlock, paragraphMeasure, selFrom, selTo);
+				for (const { line, index } of intersectingLines) {
+					if (index < paragraphFragment.fromLine || index >= paragraphFragment.toLine) continue;
+					const range = computeLinePmRange(paragraphBlock, line);
+					if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+					const isTrailingBreakRow = paragraphBlock.runs.length > 0 && line.fromRun >= paragraphBlock.runs.length;
+					const isEmptyLine = range.pmStart === range.pmEnd && !isTrailingBreakRow;
+					const sliceFrom = Math.max(range.pmStart, selFrom);
+					const sliceTo = Math.min(range.pmEnd, selTo);
+					if (!isEmptyLine && sliceFrom >= sliceTo) continue;
+					const charOffsetFrom = pmPosToCharOffset(paragraphBlock, line, sliceFrom);
+					const charOffsetTo = pmPosToCharOffset(paragraphBlock, line, sliceTo);
+					const indent = paragraphBlock.attrs?.indent;
+					const indentLeft = indent?.left ?? 0;
+					const indentRight = indent?.right ?? 0;
+					const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
+					const startX = charOffsetToX(paragraphBlock, line, charOffsetFrom, availableWidth);
+					const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, availableWidth);
+					const alignment = paragraphBlock.attrs?.alignment ?? "left";
+					let alignmentOffset = 0;
+					if (alignment === "center") alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
+					else if (alignment === "right") alignmentOffset = Math.max(0, availableWidth - line.width);
+					const lineOffset = measuredLineContentOffset(paragraphMeasure.lines, paragraphFragment.fromLine, index);
+					const rectX = fragment.x + indentLeft + alignmentOffset + Math.min(startX, endX);
+					const rectWidth = isEmptyLine ? EMPTY_PARAGRAPH_SLIVER_WIDTH : Math.max(1, Math.abs(endX - startX));
+					const rectY = fragment.y + lineOffset;
+					rects.push({
+						x: rectX,
+						y: rectY + pageTopY,
+						width: rectWidth,
+						height: line.lineHeight,
+						pageIndex
+					});
+				}
+			}
+			if (fragment.kind === "table") {
+				const blockIndex = findBlockById(blocks, fragment.blockId);
+				if (blockIndex === -1) continue;
+				const block = blocks[blockIndex];
+				const measure = measures[blockIndex];
+				if (!block || block.kind !== "table") continue;
+				if (!measure || measure.kind !== "table") continue;
+				const tableBlock = block;
+				const tableMeasure = measure;
+				const tableFragment = fragment;
+				const hdrCount = tableFragment.headerRowCount ?? 0;
+				let rowY = hdrCount > 0 && tableFragment.continuesFromPrev ? getHeaderRowsHeight(tableMeasure, hdrCount) : 0;
+				for (let rowIndex = tableFragment.fromRow; rowIndex < tableFragment.toRow && rowIndex < tableBlock.rows.length; rowIndex++) {
+					const row = tableBlock.rows[rowIndex];
+					const rowMeasure = tableMeasure.rows[rowIndex];
+					if (!row || !rowMeasure) continue;
+					const clipTop = tableFragment.topClip ?? 0;
+					const clipBottom = tableFragment.bottomClip ?? rowMeasure.height;
+					let cellX = 0;
+					for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
+						const cell = row.cells[cellIndex];
+						const cellMeasure = rowMeasure.cells[cellIndex];
+						if (!cell || !cellMeasure) continue;
+						const contentWidth = getTableCellContentWidth(cell, cellMeasure);
+						const floatingZones = buildTableCellFloatingZones(getTableCellFloatingImages(cell, cellMeasure, contentWidth), contentWidth);
+						const contentOffsetX = getCellContentOffsetX(cell);
+						const contentOffsetY = getCellContentOffsetY(cell, cellMeasure, rowMeasure.height);
+						let blockY = 0;
+						for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
+							const cellBlock = cell.blocks[blockIdx];
+							const cellBlockMeasure = cellMeasure.blocks[blockIdx];
+							if (!cellBlock || cellBlock.kind !== "paragraph") {
+								blockY += getMeasuredBlockHeight(cellBlockMeasure);
+								continue;
+							}
+							if (!cellBlockMeasure || cellBlockMeasure.kind !== "paragraph") {
+								blockY += getMeasuredBlockHeight(cellBlockMeasure);
+								continue;
+							}
+							const paragraphBlock = cellBlock;
+							let paragraphMeasure = cellBlockMeasure;
+							if (floatingZones.length > 0) paragraphMeasure = measureParagraph(paragraphBlock, contentWidth, {
+								floatingZones,
+								paragraphYOffset: blockY
+							});
+							const intersectingLines = findLinesInRange(paragraphBlock, paragraphMeasure, selFrom, selTo);
+							for (const { line, index } of intersectingLines) {
+								const range = computeLinePmRange(paragraphBlock, line);
+								if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+								const isTrailingBreakRow = paragraphBlock.runs.length > 0 && line.fromRun >= paragraphBlock.runs.length;
+								const isEmptyLine = range.pmStart === range.pmEnd && !isTrailingBreakRow;
+								const sliceFrom = Math.max(range.pmStart, selFrom);
+								const sliceTo = Math.min(range.pmEnd, selTo);
+								if (!isEmptyLine && sliceFrom >= sliceTo) continue;
+								const charOffsetFrom = pmPosToCharOffset(paragraphBlock, line, sliceFrom);
+								const charOffsetTo = pmPosToCharOffset(paragraphBlock, line, sliceTo);
+								const startX = charOffsetToX(paragraphBlock, line, charOffsetFrom, contentWidth);
+								const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, contentWidth);
+								const lineY = measuredLineContentOffset(paragraphMeasure.lines, 0, index);
+								const clippedLineY = contentOffsetY + blockY + lineY;
+								if (clippedLineY + line.lineHeight <= clipTop || clippedLineY >= clipBottom) continue;
+								rects.push({
+									x: tableFragment.x + cellX + contentOffsetX + Math.min(startX, endX),
+									y: tableFragment.y + rowY + clippedLineY - clipTop + pageTopY,
+									width: isEmptyLine ? EMPTY_PARAGRAPH_SLIVER_WIDTH : Math.max(1, Math.abs(endX - startX)),
+									height: line.lineHeight,
+									pageIndex
+								});
+							}
+							blockY += paragraphMeasure.totalHeight;
+						}
+						cellX += cellMeasure.width;
+					}
+					rowY += rowMeasure.height;
+				}
+			}
+			if (fragment.kind === "image") {
+				const blockPmStart = fragment.pmStart ?? 0;
+				if ((fragment.pmEnd ?? blockPmStart + 1) > selFrom && blockPmStart < selTo) rects.push({
+					x: fragment.x,
+					y: fragment.y + pageTopY,
+					width: fragment.width,
+					height: fragment.height,
+					pageIndex
+				});
+			}
+		}
+	}
+	return rects;
+}
+/**
+* Get caret position for a collapsed selection.
+*
+* @param layout - The document layout.
+* @param blocks - All flow blocks.
+* @param measures - All measurements.
+* @param pmPosition - The PM position.
+* @returns Caret position, or null if not found.
+*/
+function getCaretPosition(layout, blocks, measures, pmPosition) {
+	for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
+		const page = layout.pages[pageIndex];
+		const pageTopY = getPageTop(layout, pageIndex);
+		for (const fragment of page.fragments) {
+			if (fragment.kind === "paragraph") {
+				const blockIndex = findBlockById(blocks, fragment.blockId);
+				if (blockIndex === -1) continue;
+				const block = blocks[blockIndex];
+				const measure = measures[blockIndex];
+				if (!block || block.kind !== "paragraph") continue;
+				if (!measure || measure.kind !== "paragraph") continue;
+				const paragraphBlock = block;
+				const paragraphMeasure = measure;
+				const paragraphFragment = fragment;
+				const blockPmStart = paragraphBlock.pmStart ?? 0;
+				const blockPmEnd = paragraphBlock.pmEnd ?? blockPmStart;
+				if (pmPosition < blockPmStart || pmPosition > blockPmEnd) continue;
+				for (let lineIndex = paragraphFragment.fromLine; lineIndex < paragraphFragment.toLine; lineIndex++) {
+					const line = paragraphMeasure.lines[lineIndex];
+					if (!line) continue;
+					const range = computeLinePmRange(paragraphBlock, line);
+					if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
+					if (pmPosition >= range.pmStart && pmPosition <= range.pmEnd) {
+						const charOffset = pmPosToCharOffset(paragraphBlock, line, pmPosition);
+						const indent = paragraphBlock.attrs?.indent;
+						const indentLeft = indent?.left ?? 0;
+						const indentRight = indent?.right ?? 0;
+						const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
+						const x = charOffsetToX(paragraphBlock, line, charOffset, availableWidth);
+						const alignment = paragraphBlock.attrs?.alignment ?? "left";
+						let alignmentOffset = 0;
+						if (alignment === "center") alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
+						else if (alignment === "right") alignmentOffset = Math.max(0, availableWidth - line.width);
+						const lineOffset = measuredLineContentOffset(paragraphMeasure.lines, paragraphFragment.fromLine, lineIndex);
+						return {
+							x: fragment.x + indentLeft + alignmentOffset + x,
+							y: fragment.y + lineOffset + pageTopY,
+							height: line.lineHeight,
+							pageIndex
+						};
+					}
+				}
+			}
+			if (fragment.kind === "image") {
+				const fragPmStart = fragment.pmStart ?? 0;
+				const fragPmEnd = fragment.pmEnd ?? fragPmStart + 1;
+				if (pmPosition >= fragPmStart && pmPosition <= fragPmEnd) {
+					const xOffset = pmPosition === fragPmStart ? 0 : fragment.width;
+					return {
+						x: fragment.x + xOffset,
+						y: fragment.y + pageTopY,
+						height: fragment.height,
+						pageIndex
+					};
+				}
+			}
+		}
+	}
+	return null;
+}
+/**
+* Check if a selection spans multiple pages.
+*
+* @param rects - Selection rectangles.
+* @returns True if selection spans multiple pages.
+*/
+function isMultiPageSelection(rects) {
+	if (rects.length <= 1) return false;
+	return new Set(rects.map((r) => r.pageIndex)).size > 1;
+}
+/**
+* Get selection rectangles grouped by page.
+*
+* @param rects - Selection rectangles.
+* @returns Map of page index to rectangles on that page.
+*/
+function groupRectsByPage(rects) {
+	const map = /* @__PURE__ */ new Map();
+	for (const rect of rects) {
+		const pageRects = map.get(rect.pageIndex) ?? [];
+		pageRects.push(rect);
+		map.set(rect.pageIndex, pageRects);
+	}
+	return map;
+}
+//#endregion
+export { getCaretPosition, groupRectsByPage, isMultiPageSelection, selectionToRects };

package/dist/layout-bridge/engine/tableWidthUtils.d.ts

@@ -0,0 +1,7 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/layout-bridge/engine/tableWidthUtils.d.ts
+declare function resolveTableWidthPx(width: number | undefined, widthType: document_d_exports.TableWidthType | undefined, containerWidth: number): number | undefined;
+declare function normalizeTableColumnWidths(widths: number[], columnCount: number, targetWidth: number): number[];
+//#endregion
+export { normalizeTableColumnWidths, resolveTableWidthPx };

package/dist/layout-bridge/engine/tableWidthUtils.js

@@ -0,0 +1,25 @@
+//#region src/layout-bridge/engine/tableWidthUtils.ts
+const TWIPS_PER_INCH = 1440;
+const PX_PER_INCH = 96;
+const PCT_DENOMINATOR = 5e3;
+const twipsToPixels = (twips) => twips / TWIPS_PER_INCH * PX_PER_INCH;
+function resolveTableWidthPx(width, widthType, containerWidth) {
+	if (width === void 0 || width <= 0) return;
+	if (widthType === "dxa") return twipsToPixels(width);
+	if (widthType === "pct") return width / PCT_DENOMINATOR * containerWidth;
+}
+function normalizeTableColumnWidths(widths, columnCount, targetWidth) {
+	if (columnCount <= 0) return [];
+	if (widths.length === 0) return Array.from({ length: columnCount }, () => targetWidth / columnCount);
+	const normalized = widths.slice(0, columnCount);
+	const positives = normalized.filter((width) => width > 0);
+	const fallback = positives.length > 0 ? positives.reduce((sum, width) => sum + width, 0) / positives.length : targetWidth / columnCount;
+	while (normalized.length < columnCount) normalized.push(fallback);
+	let fixedTotal = 0;
+	for (const width of normalized) if (width > 0) fixedTotal += width;
+	const missingCount = normalized.filter((width) => width <= 0).length;
+	const missingWidth = missingCount > 0 ? Math.max(0, targetWidth - fixedTotal) / missingCount : 0;
+	return normalized.map((width) => width > 0 ? width : missingWidth);
+}
+//#endregion
+export { normalizeTableColumnWidths, resolveTableWidthPx };

package/dist/layout-engine/index.d.ts

@@ -0,0 +1,44 @@
+import { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun } from "./types.js";
+import { PageState, Paginator, PaginatorOptions, createPaginator } from "./paginator.js";
+import { KeepNextChain, calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
+import { BreakDecision, SectionState, applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak } from "./section-breaks.js";
+
+//#region src/layout-engine/index.d.ts
+type SectionLayoutConfig = {
+  pageSize: {
+    w: number;
+    h: number;
+  };
+  margins: PageMargins;
+  columns?: ColumnLayout;
+};
+declare function collectSectionConfigs(blocks: FlowBlock[], initialConfig: SectionLayoutConfig, finalConfig: SectionLayoutConfig): {
+  configs: SectionLayoutConfig[];
+  breakIndices: number[];
+};
+/**
+ * Apply contextual spacing suppression (OOXML §17.3.1.9).
+ *
+ * When two consecutive paragraph blocks both have `contextualSpacing: true`
+ * and share the same `styleId`, the spaceAfter of the first paragraph and
+ * the spaceBefore of the second paragraph are suppressed (set to 0).
+ *
+ * This mutates the block attrs in-place before layout runs.
+ */
+declare function applyContextualSpacing(blocks: FlowBlock[]): void;
+/**
+ * Layout a document: convert blocks + measures into pages with positioned fragments.
+ *
+ * Algorithm:
+ * 1. Walk blocks in order with their corresponding measures
+ * 2. For each block, create appropriate fragment(s)
+ * 3. Use paginator to manage page/column state
+ * 4. Handle page breaks, section breaks, and keepNext chains
+ */
+declare function layoutDocument(blocks: FlowBlock[], measures: Measure[], options: LayoutOptions): Layout;
+/**
+ * Calculate total height of header rows from their measures.
+ */
+declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
+//#endregion
+export { BlockId, BorderStyle, type BreakDecision, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, applyContextualSpacing, applyPendingToActive, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak };