documents.js 1.61.0 → 1.63.0

package/dist/layout/reconstruct.js

@@ -1,5 +1,8 @@
 import { flipY } from "../model/geometry.js";
+import { buildDrawingBlock } from "../model/embedded-drawing.js";
 import { throwIfAborted } from "../ports/abort.js";
+import { inferCellValue } from "./cell-typing.js";
+import { detectGridLattice, findColumnIndex, findRowIndex } from "./lattice.js";
 import { CONTENT_FORMAT_VERSION } from "document-schema.js";
 import { STANDARD_METRICS, resolveStandardFont } from "pdf-codec";
 //#region src/layout/reconstruct.ts
@@ -134,7 +137,9 @@ function buildSection(pages, images) {
 	};
 }
 function reconstructPageBlocks(page, images) {
-	const textItems = page.items.filter((i) => i.kind === "text");
+	const recoveredTable = recoverTable(page);
+	const consumedText = recoveredTable?.consumedText;
+	const textItems = page.items.filter((i) => i.kind === "text" && consumedText?.has(i) !== true);
 	const imageItems = page.items.filter((i) => i.kind === "image");
 	const paragraphs = clusterIntoParagraphs(clusterIntoLines(textItems));
 	const positioned = [];
@@ -155,6 +160,15 @@ function reconstructPageBlocks(page, images) {
 			}
 		});
 	}
+	if (recoveredTable !== void 0) positioned.push({
+		yPt: recoveredTable.topYPt,
+		block: recoveredTable.table
+	});
+	const recoveredVectors = recoverPageVectors(page, recoveredTable?.latticeItems ?? NO_ITEMS);
+	if (recoveredVectors !== void 0) positioned.push({
+		yPt: recoveredVectors.topYPt,
+		block: recoveredVectors.block
+	});
 	positioned.sort((a, b) => b.yPt - a.yPt);
 	return positioned.map((p) => p.block);
 }
@@ -212,7 +226,9 @@ function reconstructPresentation(doc, options) {
 	};
 }
 function reconstructSlide(page, images) {
-	const textItems = page.items.filter((i) => i.kind === "text");
+	const recoveredTable = recoverTable(page);
+	const consumedText = recoveredTable?.consumedText;
+	const textItems = page.items.filter((i) => i.kind === "text" && consumedText?.has(i) !== true);
 	const imageItems = page.items.filter((i) => i.kind === "image");
 	const textShapes = clusterIntoBlocks(clusterIntoLines(textItems)).map((block) => blockToShape(block, page.heightPt));
 	const imageShapes = [];
@@ -220,15 +236,38 @@ function reconstructSlide(page, images) {
 		const shape = imageToShape(img, page.heightPt, images);
 		if (shape !== void 0) imageShapes.push(shape);
 	}
+	const recoveredVectors = recoverPageVectors(page, recoveredTable?.latticeItems ?? NO_ITEMS);
+	const vectorShapes = recoveredVectors === void 0 ? [] : [wrapBlockInShape(recoveredVectors.block, {
+		xPt: 0,
+		yPt: 0,
+		widthPt: page.widthPt,
+		heightPt: page.heightPt
+	})];
+	const tableShapes = recoveredTable === void 0 ? [] : [wrapBlockInShape(recoveredTable.table, recoveredTable.frame)];
 	return {
 		size: {
 			widthPt: page.widthPt,
 			heightPt: page.heightPt
 		},
-		shapes: [...imageShapes, ...textShapes],
+		shapes: [
+			...vectorShapes,
+			...imageShapes,
+			...tableShapes,
+			...textShapes
+		],
 		notes: page.notes ?? ""
 	};
 }
+function wrapBlockInShape(block, frame) {
+	return {
+		frame,
+		insetLeftPt: 0,
+		insetTopPt: 0,
+		insetRightPt: 0,
+		insetBottomPt: 0,
+		blocks: [block]
+	};
+}
 function splitLineByLargeGaps(line) {
 	const segments = [];
 	let current = [];
@@ -352,14 +391,27 @@ function reconstructDrawing(doc, options) {
 function reconstructDrawPage(page, images) {
 	const vectors = [];
 	const shapes = [];
-	for (const item of page.items) if (item.kind === "rect") vectors.push(layoutRectToVector(item, page.heightPt));
-	else if (item.kind === "ellipse") vectors.push(layoutEllipseToVector(item, page.heightPt));
-	else if (item.kind === "line") vectors.push(layoutLineToVector(item, page.heightPt));
-	else if (item.kind === "path") vectors.push(layoutPathToVector(item, page.heightPt));
-	else if (item.kind === "text") shapes.push(layoutTextToShape(item, page.heightPt));
-	else if (item.kind === "image") {
-		const shape = imageToShape(item, page.heightPt, images);
-		if (shape !== void 0) shapes.push(shape);
+	let paintOrder = 0;
+	for (const item of page.items) {
+		const vector = layoutItemToVector(item, page.heightPt);
+		if (vector !== void 0) {
+			vectors.push({
+				...vector,
+				paintOrder: paintOrder++
+			});
+			continue;
+		}
+		if (item.kind === "text") shapes.push({
+			...layoutTextToShape(item, page.heightPt),
+			paintOrder: paintOrder++
+		});
+		else if (item.kind === "image") {
+			const shape = imageToShape(item, page.heightPt, images);
+			if (shape !== void 0) shapes.push({
+				...shape,
+				paintOrder: paintOrder++
+			});
+		}
 	}
 	return {
 		size: {
@@ -370,6 +422,12 @@ function reconstructDrawPage(page, images) {
 		vectors
 	};
 }
+function layoutItemToVector(item, pageHeightPt) {
+	if (item.kind === "rect") return layoutRectToVector(item, pageHeightPt);
+	if (item.kind === "ellipse") return layoutEllipseToVector(item, pageHeightPt);
+	if (item.kind === "line") return layoutLineToVector(item, pageHeightPt);
+	if (item.kind === "path") return layoutPathToVector(item, pageHeightPt);
+}
 function layoutRectToVector(item, pageHeightPt) {
 	return {
 		kind: "rect",
@@ -532,99 +590,82 @@ function layoutTextToShape(item, pageHeightPt) {
 		}]
 	};
 }
-function extractLineCandidates(items) {
-	const segments = [];
-	for (const item of items) {
-		if (item.kind === "line") {
-			segments.push({
-				x1Pt: item.x1Pt,
-				y1Pt: item.y1Pt,
-				x2Pt: item.x2Pt,
-				y2Pt: item.y2Pt
-			});
-			continue;
-		}
-		if (item.kind === "path" && item.stroke !== void 0 && item.subpaths.length === 1) {
-			const subpath = item.subpaths[0];
-			if (subpath.segments.length === 1 && subpath.segments[0].kind === "line") {
-				const segment = subpath.segments[0];
-				segments.push({
-					x1Pt: subpath.startXPt,
-					y1Pt: subpath.startYPt,
-					x2Pt: segment.xPt,
-					y2Pt: segment.yPt
-				});
-			}
-		}
-	}
-	return segments;
+function vectorTopYDownPt(vector) {
+	return vector.kind === "line" ? Math.min(vector.from.yPt, vector.to.yPt) : vector.frame.yPt;
 }
-const AXIS_ALIGNMENT_TOLERANCE_PT = .5;
-const MIN_GRIDLINE_LENGTH_PT = 4;
-function classifyAxisLine(seg) {
-	const dx = Math.abs(seg.x2Pt - seg.x1Pt);
-	const dy = Math.abs(seg.y2Pt - seg.y1Pt);
-	if (dy <= AXIS_ALIGNMENT_TOLERANCE_PT && dx >= MIN_GRIDLINE_LENGTH_PT) return {
-		axis: "horizontal",
-		position: (seg.y1Pt + seg.y2Pt) / 2,
-		spanPt: dx
-	};
-	if (dx <= AXIS_ALIGNMENT_TOLERANCE_PT && dy >= MIN_GRIDLINE_LENGTH_PT) return {
-		axis: "vertical",
-		position: (seg.x1Pt + seg.x2Pt) / 2,
-		spanPt: dy
-	};
-}
-const POSITION_DEDUPE_TOLERANCE_PT = .5;
-function dedupeAxisLines(lines, descending) {
-	const sorted = [...lines].sort((a, b) => descending ? b.position - a.position : a.position - b.position);
-	const result = [];
-	for (const candidate of sorted) {
-		const last = result[result.length - 1];
-		if (last !== void 0 && Math.abs(candidate.position - last.position) <= POSITION_DEDUPE_TOLERANCE_PT) last.spanPt = Math.max(last.spanPt, candidate.spanPt);
-		else result.push({
-			position: candidate.position,
-			spanPt: candidate.spanPt
+function recoverPageVectors(page, excluded) {
+	const vectors = [];
+	for (const item of page.items) {
+		if (excluded.has(item)) continue;
+		const vector = layoutItemToVector(item, page.heightPt);
+		if (vector !== void 0) vectors.push({
+			...vector,
+			paintOrder: vectors.length
 		});
 	}
-	return result;
-}
-const MIN_GRIDLINE_COUNT_PER_AXIS = 3;
-const GRID_SPAN_CONSISTENCY_RATIO = .9;
-function isRegularLattice(lines) {
-	if (lines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return false;
-	const maxSpanPt = Math.max(...lines.map((l) => l.spanPt));
-	return lines.filter((l) => l.spanPt >= maxSpanPt * GRID_SPAN_CONSISTENCY_RATIO).length >= MIN_GRIDLINE_COUNT_PER_AXIS;
-}
-function detectGridLattice(items) {
-	const horizontal = [];
-	const vertical = [];
-	for (const seg of extractLineCandidates(items)) {
-		const classified = classifyAxisLine(seg);
-		if (classified === void 0) continue;
-		(classified.axis === "horizontal" ? horizontal : vertical).push(classified);
-	}
-	const rowBoundaries = dedupeAxisLines(horizontal, true);
-	const columnBoundaries = dedupeAxisLines(vertical, false);
-	if (!isRegularLattice(rowBoundaries) || !isRegularLattice(columnBoundaries)) return;
+	if (vectors.length === 0) return;
+	const topYDownPt = Math.min(...vectors.map(vectorTopYDownPt));
 	return {
-		rowBoundariesDescPt: rowBoundaries.map((l) => l.position),
-		columnBoundariesAscPt: columnBoundaries.map((l) => l.position)
+		block: buildDrawingBlock({
+			widthPt: page.widthPt,
+			heightPt: page.heightPt
+		}, vectors),
+		topYPt: page.heightPt - topYDownPt
 	};
 }
-const OUTER_EDGE_TOLERANCE_PT = 3;
-function findRowIndex(rowBoundariesDescPt, yPt) {
-	const lastIndex = rowBoundariesDescPt.length - 1;
-	if (yPt > rowBoundariesDescPt[0] + OUTER_EDGE_TOLERANCE_PT || yPt < rowBoundariesDescPt[lastIndex] - OUTER_EDGE_TOLERANCE_PT) return;
-	for (let i = 0; i < lastIndex; i++) if (yPt > rowBoundariesDescPt[i + 1]) return i;
-	return lastIndex - 1;
+function cellBlocksFromItems(items) {
+	return clusterIntoLines(items).map(lineToParagraph);
 }
-function findColumnIndex(columnBoundariesAscPt, xPt) {
-	const lastIndex = columnBoundariesAscPt.length - 1;
-	if (xPt < columnBoundariesAscPt[0] - OUTER_EDGE_TOLERANCE_PT || xPt > columnBoundariesAscPt[lastIndex] + OUTER_EDGE_TOLERANCE_PT) return;
-	for (let j = 0; j < lastIndex; j++) if (xPt < columnBoundariesAscPt[j + 1]) return j;
-	return lastIndex - 1;
+function recoverTable(page) {
+	const lattice = detectGridLattice(page.items);
+	if (lattice === void 0) return;
+	const rowCount = lattice.rowBoundariesDescPt.length - 1;
+	const columnCount = lattice.columnBoundariesAscPt.length - 1;
+	const groups = /* @__PURE__ */ new Map();
+	const consumedText = /* @__PURE__ */ new Set();
+	for (const item of page.items) {
+		if (item.kind !== "text") continue;
+		const row = findRowIndex(lattice.rowBoundariesDescPt, item.yPt);
+		const column = findColumnIndex(lattice.columnBoundariesAscPt, item.xPt);
+		if (row === void 0 || column === void 0) continue;
+		addToGroup(groups, row, column, item);
+		consumedText.add(item);
+	}
+	if (consumedText.size === 0) return;
+	const columnWidthsPt = [];
+	for (let j = 0; j < columnCount; j++) columnWidthsPt.push(lattice.columnBoundariesAscPt[j + 1] - lattice.columnBoundariesAscPt[j]);
+	const rows = [];
+	for (let i = 0; i < rowCount; i++) {
+		const cells = [];
+		for (let j = 0; j < columnCount; j++) cells.push({ blocks: cellBlocksFromItems(groups.get(groupKey(i, j)) ?? []) });
+		rows.push({
+			cells,
+			heightPt: lattice.rowBoundariesDescPt[i] - lattice.rowBoundariesDescPt[i + 1]
+		});
+	}
+	const leftXPt = lattice.columnBoundariesAscPt[0];
+	const rightXPt = lattice.columnBoundariesAscPt[columnCount];
+	const topYPt = lattice.rowBoundariesDescPt[0];
+	const bottomYPt = lattice.rowBoundariesDescPt[rowCount];
+	const frame = flipY({
+		xPt: leftXPt,
+		yPt: bottomYPt,
+		widthPt: rightXPt - leftXPt,
+		heightPt: topYPt - bottomYPt
+	}, page.heightPt);
+	return {
+		table: {
+			kind: "table",
+			rows,
+			columnWidthsPt
+		},
+		frame,
+		topYPt,
+		consumedText,
+		latticeItems: lattice.sourceItems
+	};
 }
+const NO_ITEMS = /* @__PURE__ */ new Set();
 function joinCellText(items) {
 	const sorted = [...items].sort((a, b) => a.xPt - b.xPt);
 	let text = "";
@@ -646,26 +687,44 @@ function addToGroup(groups, row, column, item) {
 	if (existing === void 0) groups.set(key, [item]);
 	else existing.push(item);
 }
-function buildCellsFromGroups(groups) {
+function buildCellsFromGroups(groups, context) {
 	const cells = [];
 	for (const [key, items] of groups) {
 		const displayText = joinCellText(items);
 		if (displayText.length === 0) continue;
 		const [rowPart, columnPart] = key.split(",");
+		const row = Number(rowPart);
+		const column = Number(columnPart);
 		cells.push({
-			row: Number(rowPart),
-			column: Number(columnPart),
-			value: {
-				kind: "string",
-				value: displayText
-			},
+			row,
+			column,
+			value: inferredCellValue(displayText, row, column, context),
 			displayText
 		});
 	}
 	cells.sort((a, b) => a.row - b.row || a.column - b.column);
 	return cells;
 }
-function buildGridFromLattice(textItems, lattice) {
+function inferredCellValue(displayText, row, column, context) {
+	const inference = inferCellValue(displayText);
+	if (inference === void 0) return {
+		kind: "string",
+		value: displayText
+	};
+	const reported = {
+		sheetIndex: context.sheetIndex,
+		row,
+		column,
+		displayText,
+		...inference
+	};
+	context.sink?.(reported);
+	return inference.outcome === "retyped" ? inference.value : {
+		kind: "string",
+		value: displayText
+	};
+}
+function buildGridFromLattice(textItems, lattice, context) {
 	const groups = /* @__PURE__ */ new Map();
 	for (const item of textItems) {
 		const row = findRowIndex(lattice.rowBoundariesDescPt, item.yPt);
@@ -684,7 +743,7 @@ function buildGridFromLattice(textItems, lattice) {
 		heightPt: lattice.rowBoundariesDescPt[i] - lattice.rowBoundariesDescPt[i + 1]
 	});
 	return {
-		cells: buildCellsFromGroups(groups),
+		cells: buildCellsFromGroups(groups, context),
 		columns,
 		rows,
 		gridlines: true
@@ -723,7 +782,7 @@ function lastColumnWidthPt(groups, columnIndex, anchorXPt) {
 	}
 	return maxWidthPt > 0 ? maxWidthPt : DEFAULT_COLUMN_WIDTH_FALLBACK_PT;
 }
-function buildGridFromTextClustering(textItems) {
+function buildGridFromTextClustering(textItems, context) {
 	const lines = clusterIntoLines(textItems);
 	if (lines.length === 0) return {
 		cells: [],
@@ -759,16 +818,20 @@ function buildGridFromTextClustering(textItems) {
 		};
 	});
 	return {
-		cells: buildCellsFromGroups(groups),
+		cells: buildCellsFromGroups(groups, context),
 		columns,
 		rows,
 		gridlines: false
 	};
 }
-function reconstructSheet(page, pageIndex) {
+function reconstructSheet(page, pageIndex, sink) {
 	const textItems = page.items.filter((i) => i.kind === "text");
 	const lattice = detectGridLattice(page.items);
-	const grid = lattice !== void 0 ? buildGridFromLattice(textItems, lattice) : buildGridFromTextClustering(textItems);
+	const context = {
+		sheetIndex: pageIndex,
+		sink
+	};
+	const grid = lattice !== void 0 ? buildGridFromLattice(textItems, lattice, context) : buildGridFromTextClustering(textItems, context);
 	const printSettings = {
 		pageSize: {
 			widthPt: page.widthPt,
@@ -792,7 +855,7 @@ function reconstructSpreadsheet(doc, options) {
 	const signal = options?.signal;
 	const sheets = doc.pages.map((page, index) => {
 		throwIfAborted(signal);
-		return reconstructSheet(page, index);
+		return reconstructSheet(page, index, options?.onCellTypeInference);
 	});
 	return {
 		kind: "spreadsheet",

package/dist/layout/shared.cjs

@@ -43,6 +43,56 @@ function alignmentOffsetPt(alignment, contentWidthPt, lineWidthPt) {
 	if (alignment === "right") return Math.max(0, contentWidthPt - lineWidthPt);
 	return 0;
 }
+const GAP_DETECTION_EPSILON_PT = .01;
+function justifyLineGapsPt(line, targetWidthPt, measurer) {
+	const fragments = line.fragments;
+	const extrasPt = new Array(fragments.length).fill(0);
+	if (fragments.length < 2) return extrasPt;
+	const gapIndices = [];
+	for (let i = 0; i < fragments.length - 1; i++) {
+		const fragment = fragments[i];
+		const next = fragments[i + 1];
+		const naturalEndPt = fragment.xOffsetPt + measurer.widthOfTextAtSize(fragment.text, fragment.font, fragment.sizePt);
+		if (next.xOffsetPt - naturalEndPt > GAP_DETECTION_EPSILON_PT) gapIndices.push(i);
+	}
+	if (gapIndices.length === 0) return extrasPt;
+	const slackPt = targetWidthPt - line.widthPt;
+	if (slackPt <= 0) return extrasPt;
+	const extraPerGapPt = slackPt / gapIndices.length;
+	let cumulativePt = 0;
+	let gapPointer = 0;
+	for (let i = 0; i < fragments.length; i++) {
+		extrasPt[i] = cumulativePt;
+		if (gapPointer < gapIndices.length && gapIndices[gapPointer] === i) {
+			cumulativePt += extraPerGapPt;
+			gapPointer++;
+		}
+	}
+	return extrasPt;
+}
+function pushBorderLine(border, x1Pt, y1Pt, x2Pt, y2Pt, sourcePath, out) {
+	if (border === void 0) return;
+	out.push({
+		kind: "line",
+		x1Pt,
+		y1Pt,
+		x2Pt,
+		y2Pt,
+		color: border.color,
+		widthPt: border.widthPt,
+		sourcePath
+	});
+}
+function pushCellBorderLines(borders, frameYDown, pageHeightPt, sourcePath, out) {
+	const leftXPt = frameYDown.xPt;
+	const rightXPt = frameYDown.xPt + frameYDown.widthPt;
+	const topYPt = pageHeightPt - frameYDown.yPt;
+	const bottomYPt = pageHeightPt - (frameYDown.yPt + frameYDown.heightPt);
+	pushBorderLine(borders.top, leftXPt, topYPt, rightXPt, topYPt, sourcePath, out);
+	pushBorderLine(borders.bottom, leftXPt, bottomYPt, rightXPt, bottomYPt, sourcePath, out);
+	pushBorderLine(borders.left, leftXPt, topYPt, leftXPt, bottomYPt, sourcePath, out);
+	pushBorderLine(borders.right, rightXPt, topYPt, rightXPt, bottomYPt, sourcePath, out);
+}
 function decodeImageDimensions(format, bytes) {
 	if (format === "jpeg") {
 		const info = (0, pdf_codec.readJpegInfo)(bytes);
@@ -97,7 +147,9 @@ exports.NOMINAL_TEXT_SIZE_PT = NOMINAL_TEXT_SIZE_PT;
 exports.alignmentOffsetPt = alignmentOffsetPt;
 exports.effectiveStyledRuns = effectiveStyledRuns;
 exports.estimateRowHeightPt = estimateRowHeightPt;
+exports.justifyLineGapsPt = justifyLineGapsPt;
 exports.lineNaturalHeightPt = lineNaturalHeightPt;
+exports.pushCellBorderLines = pushCellBorderLines;
 exports.registerImage = registerImage;
 exports.runFont = runFont;
 exports.sumColumnWidthsPt = sumColumnWidthsPt;

package/dist/layout/shared.d.cts

@@ -1,5 +1,5 @@
 import { i as LayoutFont, t as Alignment } from "../style-DkamR3aY.cjs";
-import { ContentImageBlock, ContentRun, ContentTableRow, LayoutImageAsset } from "document-schema.js";
+import { Box, ContentCellBorders, ContentImageBlock, ContentRun, ContentTableRow, LayoutImageAsset, LayoutItem } from "document-schema.js";
 import { StyledRun, TextMeasurer, WrappedLine } from "pdf-codec";
 //#region src/layout/shared.d.ts
 declare const NOMINAL_TEXT_SIZE_PT = 18;
@@ -8,8 +8,10 @@ declare function toStyledRuns(runs: readonly ContentRun[], fontScale?: number):
 declare function effectiveStyledRuns(runs: readonly ContentRun[], fontScale?: number): StyledRun[];
 declare function lineNaturalHeightPt(line: WrappedLine, measurer: TextMeasurer, fallback: StyledRun): number;
 declare function alignmentOffsetPt(alignment: Alignment | undefined, contentWidthPt: number, lineWidthPt: number): number;
+declare function justifyLineGapsPt(line: WrappedLine, targetWidthPt: number, measurer: TextMeasurer): readonly number[];
+declare function pushCellBorderLines(borders: ContentCellBorders, frameYDown: Box, pageHeightPt: number, sourcePath: string | undefined, out: LayoutItem[]): void;
 declare function registerImage(block: ContentImageBlock, images: Record<string, LayoutImageAsset>): string;
 declare function sumColumnWidthsPt(columnWidthsPt: readonly number[], startIndex: number, span: number): number;
 declare function estimateRowHeightPt(row: ContentTableRow, measurer: TextMeasurer, columnWidthsPt: readonly number[], scale: number): number;
 //#endregion
-export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };
+export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, justifyLineGapsPt, lineNaturalHeightPt, pushCellBorderLines, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };

package/dist/layout/shared.d.ts

@@ -1,5 +1,5 @@
 import { i as LayoutFont, t as Alignment } from "../style-DkamR3aY.js";
-import { ContentImageBlock, ContentRun, ContentTableRow, LayoutImageAsset } from "document-schema.js";
+import { Box, ContentCellBorders, ContentImageBlock, ContentRun, ContentTableRow, LayoutImageAsset, LayoutItem } from "document-schema.js";
 import { StyledRun, TextMeasurer, WrappedLine } from "pdf-codec";
 //#region src/layout/shared.d.ts
 declare const NOMINAL_TEXT_SIZE_PT = 18;
@@ -8,8 +8,10 @@ declare function toStyledRuns(runs: readonly ContentRun[], fontScale?: number):
 declare function effectiveStyledRuns(runs: readonly ContentRun[], fontScale?: number): StyledRun[];
 declare function lineNaturalHeightPt(line: WrappedLine, measurer: TextMeasurer, fallback: StyledRun): number;
 declare function alignmentOffsetPt(alignment: Alignment | undefined, contentWidthPt: number, lineWidthPt: number): number;
+declare function justifyLineGapsPt(line: WrappedLine, targetWidthPt: number, measurer: TextMeasurer): readonly number[];
+declare function pushCellBorderLines(borders: ContentCellBorders, frameYDown: Box, pageHeightPt: number, sourcePath: string | undefined, out: LayoutItem[]): void;
 declare function registerImage(block: ContentImageBlock, images: Record<string, LayoutImageAsset>): string;
 declare function sumColumnWidthsPt(columnWidthsPt: readonly number[], startIndex: number, span: number): number;
 declare function estimateRowHeightPt(row: ContentTableRow, measurer: TextMeasurer, columnWidthsPt: readonly number[], scale: number): number;
 //#endregion
-export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };
+export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, justifyLineGapsPt, lineNaturalHeightPt, pushCellBorderLines, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };

package/dist/layout/shared.js

@@ -43,6 +43,56 @@ function alignmentOffsetPt(alignment, contentWidthPt, lineWidthPt) {
 	if (alignment === "right") return Math.max(0, contentWidthPt - lineWidthPt);
 	return 0;
 }
+const GAP_DETECTION_EPSILON_PT = .01;
+function justifyLineGapsPt(line, targetWidthPt, measurer) {
+	const fragments = line.fragments;
+	const extrasPt = new Array(fragments.length).fill(0);
+	if (fragments.length < 2) return extrasPt;
+	const gapIndices = [];
+	for (let i = 0; i < fragments.length - 1; i++) {
+		const fragment = fragments[i];
+		const next = fragments[i + 1];
+		const naturalEndPt = fragment.xOffsetPt + measurer.widthOfTextAtSize(fragment.text, fragment.font, fragment.sizePt);
+		if (next.xOffsetPt - naturalEndPt > GAP_DETECTION_EPSILON_PT) gapIndices.push(i);
+	}
+	if (gapIndices.length === 0) return extrasPt;
+	const slackPt = targetWidthPt - line.widthPt;
+	if (slackPt <= 0) return extrasPt;
+	const extraPerGapPt = slackPt / gapIndices.length;
+	let cumulativePt = 0;
+	let gapPointer = 0;
+	for (let i = 0; i < fragments.length; i++) {
+		extrasPt[i] = cumulativePt;
+		if (gapPointer < gapIndices.length && gapIndices[gapPointer] === i) {
+			cumulativePt += extraPerGapPt;
+			gapPointer++;
+		}
+	}
+	return extrasPt;
+}
+function pushBorderLine(border, x1Pt, y1Pt, x2Pt, y2Pt, sourcePath, out) {
+	if (border === void 0) return;
+	out.push({
+		kind: "line",
+		x1Pt,
+		y1Pt,
+		x2Pt,
+		y2Pt,
+		color: border.color,
+		widthPt: border.widthPt,
+		sourcePath
+	});
+}
+function pushCellBorderLines(borders, frameYDown, pageHeightPt, sourcePath, out) {
+	const leftXPt = frameYDown.xPt;
+	const rightXPt = frameYDown.xPt + frameYDown.widthPt;
+	const topYPt = pageHeightPt - frameYDown.yPt;
+	const bottomYPt = pageHeightPt - (frameYDown.yPt + frameYDown.heightPt);
+	pushBorderLine(borders.top, leftXPt, topYPt, rightXPt, topYPt, sourcePath, out);
+	pushBorderLine(borders.bottom, leftXPt, bottomYPt, rightXPt, bottomYPt, sourcePath, out);
+	pushBorderLine(borders.left, leftXPt, topYPt, leftXPt, bottomYPt, sourcePath, out);
+	pushBorderLine(borders.right, rightXPt, topYPt, rightXPt, bottomYPt, sourcePath, out);
+}
 function decodeImageDimensions(format, bytes) {
 	if (format === "jpeg") {
 		const info = readJpegInfo(bytes);
@@ -93,4 +143,4 @@ function estimateRowHeightPt(row, measurer, columnWidthsPt, scale) {
 	return max;
 }
 //#endregion
-export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };
+export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, justifyLineGapsPt, lineNaturalHeightPt, pushCellBorderLines, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };

package/dist/layout/sheets.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_geometry = require("../model/geometry.cjs");
 const require_layout_shared = require("./shared.cjs");
 const require_ports_abort = require("../ports/abort.cjs");
 let document_schema_js = require("document-schema.js");
@@ -182,15 +183,39 @@ function axisSpanSizePt(axis, startIndex, span) {
 	if (startPosition === void 0) return 0;
 	return require_layout_shared.sumColumnWidthsPt(axis.sizesPt, startPosition, span);
 }
-function renderCellText(cell, rowCells, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageHeightPt, measurer, out) {
+function resolveCellFrame(cell, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt) {
 	const columnPosition = columnAxis.positionByIndex.get(cell.column);
 	const rowPosition = rowAxis.positionByIndex.get(cell.row);
 	if (columnPosition === void 0 || rowPosition === void 0) return;
-	const ownWidthPt = axisSpanSizePt(columnAxis, cell.column, cell.colSpan ?? 1);
-	const heightPt = axisSpanSizePt(rowAxis, cell.row, cell.rowSpan ?? 1);
-	const xLeftPt = gridLeftXPt + columnAxis.offsetsPt[columnPosition];
-	const yTopDownPt = gridTopYDownPt + rowAxis.offsetsPt[rowPosition];
-	const alignment = defaultAlignmentForValue(cell.value.kind);
+	return {
+		xPt: gridLeftXPt + columnAxis.offsetsPt[columnPosition],
+		yPt: gridTopYDownPt + rowAxis.offsetsPt[rowPosition],
+		widthPt: axisSpanSizePt(columnAxis, cell.column, cell.colSpan ?? 1),
+		heightPt: axisSpanSizePt(rowAxis, cell.row, cell.rowSpan ?? 1)
+	};
+}
+function renderCellBackground(cell, frameYDown, pageHeightPt, out) {
+	if (cell.background === void 0) return;
+	const flipped = require_model_geometry.flipY(frameYDown, pageHeightPt);
+	out.push({
+		kind: "rect",
+		xPt: flipped.xPt,
+		yPt: flipped.yPt,
+		widthPt: flipped.widthPt,
+		heightPt: flipped.heightPt,
+		fill: cell.background,
+		sourcePath: cell.sourcePath
+	});
+}
+const DEFAULT_CELL_VERTICAL_ALIGNMENT = "bottom";
+function verticalLineTopYDownPt(verticalAlignment, cellTopYDownPt, cellHeightPt, lineHeightPt) {
+	if (verticalAlignment === "top") return cellTopYDownPt + CELL_TEXT_PADDING_PT;
+	if (verticalAlignment === "middle") return cellTopYDownPt + Math.max(CELL_TEXT_PADDING_PT, (cellHeightPt - lineHeightPt) / 2);
+	return cellTopYDownPt + Math.max(CELL_TEXT_PADDING_PT, cellHeightPt - CELL_TEXT_PADDING_PT - lineHeightPt);
+}
+function renderCellText(cell, frameYDown, rowCells, columnAxis, pageHeightPt, measurer, out) {
+	const { xPt: xLeftPt, yPt: yTopDownPt, widthPt: ownWidthPt, heightPt } = frameYDown;
+	const alignment = cell.alignment ?? defaultAlignmentForValue(cell.value.kind);
 	const numericLike = isNumericLikeValue(cell.value.kind);
 	const styledRuns = cellStyledRuns(cell);
 	const naturalLine = (0, pdf_codec.wrapRunsToWidth)(styledRuns, measurer, Number.POSITIVE_INFINITY)[0];
@@ -220,7 +245,7 @@ function renderCellText(cell, rowCells, columnAxis, rowAxis, gridLeftXPt, gridTo
 	const alignOffsetPt = require_layout_shared.alignmentOffsetPt(alignment, availableWidthPt, lineWidthPt);
 	const textStartXPt = xLeftPt + CELL_TEXT_PADDING_PT + alignOffsetPt;
 	const lineHeightPt = require_layout_shared.lineNaturalHeightPt(naturalLine, measurer, styledRuns[0]);
-	const baselineYDownPt = yTopDownPt + Math.max(CELL_TEXT_PADDING_PT, heightPt - CELL_TEXT_PADDING_PT - lineHeightPt) + naturalLine.ascentPt;
+	const baselineYDownPt = verticalLineTopYDownPt(cell.verticalAlignment ?? DEFAULT_CELL_VERTICAL_ALIGNMENT, yTopDownPt, heightPt, lineHeightPt) + naturalLine.ascentPt;
 	for (const fragment of fragments) {
 		const textItem = {
 			kind: "text",
@@ -380,18 +405,27 @@ function convertSheetToPages(sheet, measurer, signal, out) {
 		const gridTopYDownPt = margins.topPt + gutter.heightPt;
 		const gridWidthPt = columnAxis.offsetsPt[columnAxis.offsetsPt.length - 1];
 		const gridHeightPt = rowAxis.offsetsPt[rowAxis.offsetsPt.length - 1];
-		const items = [];
-		if (printSettings.gridlines) renderGridlines(gridLeftXPt, gridTopYDownPt, gridWidthPt, gridHeightPt, columnAxis.offsetsPt, rowAxis.offsetsPt, pageSize.heightPt, items);
-		if (printSettings.headers) renderHeaderLabels(gutter, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, measurer, items);
+		const backgroundItems = [];
+		const borderItems = [];
+		const textItems = [];
 		for (const rowIndex of rowAxis.indices) {
 			const rowCells = cellsByRow.get(rowIndex);
 			if (rowCells === void 0) continue;
 			for (const [columnIndex, cell] of rowCells) {
 				require_ports_abort.throwIfAborted(signal);
 				if (!columnAxis.positionByIndex.has(columnIndex) || hiddenColumnIndices.has(columnIndex) || hiddenRowIndices.has(cell.row)) continue;
-				renderCellText(cell, rowCells, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, measurer, items);
+				const cellFrame = resolveCellFrame(cell, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt);
+				if (cellFrame === void 0) continue;
+				renderCellBackground(cell, cellFrame, pageSize.heightPt, backgroundItems);
+				if (cell.borders !== void 0) require_layout_shared.pushCellBorderLines(cell.borders, cellFrame, pageSize.heightPt, cell.sourcePath, borderItems);
+				renderCellText(cell, cellFrame, rowCells, columnAxis, pageSize.heightPt, measurer, textItems);
 			}
 		}
+		const items = [...backgroundItems];
+		if (printSettings.gridlines) renderGridlines(gridLeftXPt, gridTopYDownPt, gridWidthPt, gridHeightPt, columnAxis.offsetsPt, rowAxis.offsetsPt, pageSize.heightPt, items);
+		items.push(...borderItems);
+		if (printSettings.headers) renderHeaderLabels(gutter, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, measurer, items);
+		items.push(...textItems);
 		out.push({
 			widthPt: pageSize.widthPt,
 			heightPt: pageSize.heightPt,