js.documents 14.6.4 → 14.6.6

package/dist/layout/reconstruct-lines.js

@@ -1,7 +1,7 @@
 import { stampFrame } from "./shared.js";
 import { resolveStandardFont } from "pdf-codec/fonts";
 import { STANDARD_METRICS } from "pdf-codec/afm-widths";
-import { runGapPt, runsShareBaseline } from "pdf-codec/text-group";
+import { attachScriptRuns, runGapPt, runsShareBaseline, scriptPositionOf } from "pdf-codec/text-group";
 //#region src/layout/reconstruct-lines.ts
 const LINE_BASELINE_TOLERANCE_FACTOR = .5;
 const AFM_UNITS_PER_EM = 1e3;
@@ -27,13 +27,14 @@ function dropDuplicatePaints(items) {
 	return kept;
 }
 function dropOverlappingRepeatsWithinLine(items) {
-	const rightEdgeByText = /* @__PURE__ */ new Map();
+	const keptByText = /* @__PURE__ */ new Map();
 	const kept = [];
 	for (const item of items) {
 		const textKey = item.text.trim();
-		const priorRightEdge = rightEdgeByText.get(textKey);
-		if (priorRightEdge !== void 0 && item.xPt < priorRightEdge) continue;
-		rightEdgeByText.set(textKey, item.xPt + (item.widthPt ?? 0));
+		const earlier = keptByText.get(textKey);
+		if (earlier?.some((prior) => item.xPt < prior.xPt + (prior.widthPt ?? 0) && Math.abs(item.yPt - prior.yPt) <= DUPLICATE_PAINT_BUCKET_PT) === true) continue;
+		if (earlier === void 0) keptByText.set(textKey, [item]);
+		else earlier.push(item);
 		kept.push(item);
 	}
 	return kept;
@@ -126,12 +127,23 @@ function clusterIntoLines(items) {
 		});
 		else line.items.push(item);
 	}
-	for (const line of working) {
+	const lines = attachScriptRuns(working, (line) => line.items).filter(({ runs }) => runs.length > 0).map(({ line, runs }) => ({
+		...line,
+		items: runs
+	}));
+	for (const line of lines) {
 		line.items.sort((a, b) => a.xPt - b.xPt);
 		line.items = dropOverlappingRepeatsWithinLine(line.items);
 	}
-	working.sort((a, b) => b.baselineY - a.baselineY);
-	return working;
+	lines.sort((a, b) => b.baselineY - a.baselineY);
+	return lines;
+}
+function scriptPositionOnLine(item, line) {
+	for (const base of line.items) {
+		if (base === item) continue;
+		const position = scriptPositionOf(base, item);
+		if (position !== void 0) return position;
+	}
 }
 function textItemVerticalExtent(item) {
 	const { standardName } = resolveStandardFont(item.font.family, item.font.weight === "bold", item.font.style === "italic");
@@ -191,13 +203,32 @@ function pushRunsForLine(runs, line, pageIndex) {
 		if (itemIndex > 0) {
 			const prevItem = line.items[itemIndex - 1];
 			if (gapExceeds(prevItem, item, 2 * item.sizePt)) runs.push({ text: "	" });
-			else if (gapExceeds(prevItem, item, .5)) runs[runs.length - 1].text += " ";
+			else if (gapExceeds(prevItem, item, .5)) appendWordSpace(runs);
 		}
 		const run = textItemToContentRun(item);
 		stampFrame(run, pageIndex, textBoxOfItem(item, pageIndex));
-		runs.push(run);
+		const verticalAlign = scriptPositionOnLine(item, line);
+		const core = item.text.trim();
+		if (verticalAlign === void 0 || core.length === 0) {
+			runs.push(run);
+			return;
+		}
+		const leading = item.text.slice(0, item.text.length - item.text.trimStart().length);
+		const trailing = item.text.slice(item.text.trimEnd().length);
+		if (leading.length > 0) runs.push({ text: leading });
+		runs.push({
+			...run,
+			text: core,
+			verticalAlign
+		});
+		if (trailing.length > 0) runs.push({ text: trailing });
 	});
 }
+function appendWordSpace(runs) {
+	const last = runs[runs.length - 1];
+	if (last.verticalAlign === void 0) last.text += " ";
+	else runs.push({ text: " " });
+}
 function bucketCounts(values, bucketSize) {
 	const counts = /* @__PURE__ */ new Map();
 	for (const v of values) {
@@ -280,8 +311,7 @@ function paragraphToContentParagraph(paragraph, pageIndex, headingLevel) {
 	paragraph.lines.forEach((line, lineIndex) => {
 		stampFrame(result, pageIndex, lineBox(line, pageIndex));
 		if (lineIndex > 0) {
-			const lastRun = result.runs[result.runs.length - 1];
-			if (lastRun !== void 0) lastRun.text += " ";
+			if (result.runs.length > 0) appendWordSpace(result.runs);
 		}
 		pushRunsForLine(result.runs, line, pageIndex);
 	});

package/dist/layout/reconstruct-presentations-prod.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_reconstruct_presentations_prod = require("../reconstruct-presentations-prod-CsvGlvP2.cjs");
+const require_reconstruct_presentations_prod = require("../reconstruct-presentations-prod-DtpKKgRY.cjs");
 exports.layoutItemToVector = require_reconstruct_presentations_prod.layoutItemToVector;
 exports.lineToParagraph = require_reconstruct_presentations_prod.lineToParagraph;
 exports.reconstructDrawing = require_reconstruct_presentations_prod.reconstructDrawing;

package/dist/layout/reconstruct-presentations-prod.js

@@ -1,2 +1,2 @@
-import { a as reconstructSheet, i as reconstructPresentation, n as lineToParagraph, o as recoverPageVectors, r as reconstructDrawing, s as splitLineByLargeGaps, t as layoutItemToVector } from "../reconstruct-presentations-prod-D1KbGPxa.js";
+import { a as reconstructSheet, i as reconstructPresentation, n as lineToParagraph, o as recoverPageVectors, r as reconstructDrawing, s as splitLineByLargeGaps, t as layoutItemToVector } from "../reconstruct-presentations-prod-DV7UQqMT.js";
 export { layoutItemToVector, lineToParagraph, reconstructDrawing, reconstructPresentation, reconstructSheet, recoverPageVectors, splitLineByLargeGaps };

package/dist/layout/reconstruct-tables.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_reconstruct_presentations_prod = require("../reconstruct-presentations-prod-CsvGlvP2.cjs");
+const require_reconstruct_presentations_prod = require("../reconstruct-presentations-prod-DtpKKgRY.cjs");
 exports.buildGridFromLattice = require_reconstruct_presentations_prod.buildGridFromLattice;
 exports.buildGridFromTextClustering = require_reconstruct_presentations_prod.buildGridFromTextClustering;
 exports.recoverTables = require_reconstruct_presentations_prod.recoverTables;

package/dist/layout/reconstruct-tables.js

@@ -1,2 +1,2 @@
-import { b as recoverTables, v as buildGridFromLattice, y as buildGridFromTextClustering } from "../reconstruct-presentations-prod-D1KbGPxa.js";
+import { b as recoverTables, v as buildGridFromLattice, y as buildGridFromTextClustering } from "../reconstruct-presentations-prod-DV7UQqMT.js";
 export { buildGridFromLattice, buildGridFromTextClustering, recoverTables };

package/dist/layout/reconstruct.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_reconstruct_presentations_prod = require("../reconstruct-presentations-prod-CsvGlvP2.cjs");
+const require_reconstruct_presentations_prod = require("../reconstruct-presentations-prod-DtpKKgRY.cjs");
 exports.CELL_TYPES = require_reconstruct_presentations_prod.CELL_TYPES;
 exports.DEFAULT_COLUMN_WIDTH_FALLBACK_PT = require_reconstruct_presentations_prod.DEFAULT_COLUMN_WIDTH_FALLBACK_PT;
 exports.NO_ITEMS = require_reconstruct_presentations_prod.NO_ITEMS;

package/dist/layout/reconstruct.js

@@ -1,2 +1,2 @@
-import { _ as reconstructWordprocessing, c as CELL_TYPES, d as ROW_TYPES, f as TABLE_TYPES, g as reconstructSpreadsheet, h as nearestOfType, l as DEFAULT_COLUMN_WIDTH_FALLBACK_PT, m as indexStructure, p as ZERO_MARGINS, u as NO_ITEMS } from "../reconstruct-presentations-prod-D1KbGPxa.js";
+import { _ as reconstructWordprocessing, c as CELL_TYPES, d as ROW_TYPES, f as TABLE_TYPES, g as reconstructSpreadsheet, h as nearestOfType, l as DEFAULT_COLUMN_WIDTH_FALLBACK_PT, m as indexStructure, p as ZERO_MARGINS, u as NO_ITEMS } from "../reconstruct-presentations-prod-DV7UQqMT.js";
 export { CELL_TYPES, DEFAULT_COLUMN_WIDTH_FALLBACK_PT, NO_ITEMS, ROW_TYPES, TABLE_TYPES, ZERO_MARGINS, indexStructure, nearestOfType, reconstructSpreadsheet, reconstructWordprocessing };

package/dist/layout/ruled-rows.cjs

@@ -0,0 +1,214 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_layout_reconstruct_lines = require("./reconstruct-lines.cjs");
+const require_layout_lattice = require("./lattice.cjs");
+const require_layout_reading_order = require("./reading-order.cjs");
+//#region src/layout/ruled-rows.ts
+/**
+* The grid of a table ruled between its rows and set apart by gutters between its columns, when the page holds one.
+* @param items - the page's items; rules are read from its lines, paths and thin rectangles, and text from its text items
+* @returns a lattice whose row boundaries are the rules (and the top of an unruled heading row above them) and whose column boundaries are the table's two ends and the middle of each gutter, a row that crosses a gutter spanning the columns it covers; undefined when no set of rules of one span holds two rows of text, fewer than two rows hold text in more than one place, the rows leave no gutter they all share, or every column reads as running prose
+*/
+function detectRuledRowLattice(items) {
+	const rules = rulesOfOneTable(items);
+	if (rules === void 0) return;
+	const text = items.filter((item) => item.kind === "text" && item.text.trim().length > 0 && item.xPt >= rules.leftPt && item.xPt < rules.rightPt);
+	if (text.some((item) => item.widthPt === void 0 || item.writingMode !== void 0 || (item.rotationDeg ?? 0) !== 0)) return;
+	const ruledRows = rules.positionsDescPt.slice(1).map((lowerPt, row) => text.filter((item) => item.yPt > lowerPt && item.yPt < rules.positionsDescPt[row]));
+	const widestSpacePt = Math.max(...ruledRows.flat().map(require_layout_reading_order.spaceAdvancePt));
+	const shared = sharedGutters(ruledRows, widestSpacePt);
+	if (shared === void 0) return;
+	const { gutters } = shared;
+	const dividersPt = gutters.map((gutter) => (gutter.loPt + gutter.hiPt) / 2);
+	const topRulePt = rules.positionsDescPt[0];
+	const heading = headingRow(text.filter((item) => item.yPt > topRulePt), topRulePt, dividersPt, require_layout_reconstruct_lines.clusterIntoLines(ruledRows.flat()), widestSpacePt);
+	const rows = heading === void 0 ? ruledRows : [heading.items, ...ruledRows];
+	if (shared.rowsWithColumns + (heading !== void 0 && textRuns(heading.items, widestSpacePt).length > 1 ? 1 : 0) < 2) return;
+	const columnBoundariesAscPt = [
+		rules.leftPt,
+		...dividersPt,
+		rules.rightPt
+	];
+	if (holdsDrawing(items, rules, heading?.topPt ?? rules.positionsDescPt[0])) return;
+	const narrowestGutterPt = Math.min(...gutters.map((gutter) => gutter.hiPt - gutter.loPt));
+	if (columnBoundariesAscPt.slice(1).map((rightPt, column) => rows.flat().filter((item) => item.xPt >= columnBoundariesAscPt[column] && item.xPt < rightPt)).every((column) => require_layout_reading_order.isRunningProse(column, narrowestGutterPt))) return;
+	const bands = [...heading === void 0 ? [] : [heading], ...ruledRows.map((rowItems, row) => ({
+		items: rowItems,
+		topPt: rules.positionsDescPt[row]
+	}))].flatMap((band) => rowsOfBand(band.items, band.topPt, dividersPt, widestSpacePt));
+	return {
+		rowBoundariesDescPt: [...bands.map((band) => band.topPt), rules.positionsDescPt.at(-1)],
+		columnBoundariesAscPt,
+		regions: bands.flatMap((band, rowIndex) => rowRegions(band.items, rowIndex, dividersPt, widestSpacePt)),
+		sourceItems: rules.sourceItems
+	};
+}
+function rulesOfOneTable(items) {
+	const groups = [];
+	for (const rule of require_layout_lattice.horizontalRules(items)) {
+		const group = groups.find((members) => members.every((member) => spansOverlap(member, rule)));
+		if (group === void 0) groups.push([rule]);
+		else group.push(rule);
+	}
+	const best = groups.filter((members) => members.length >= 3).map((members) => ({
+		members,
+		leftPt: Math.min(...members.map((rule) => rule.leftPt)),
+		rightPt: Math.max(...members.map((rule) => rule.rightPt))
+	})).sort((a, b) => b.members.length - a.members.length || b.rightPt - b.leftPt - (a.rightPt - a.leftPt))[0];
+	if (best === void 0) return;
+	return {
+		positionsDescPt: best.members.map((rule) => rule.position).sort((a, b) => b - a),
+		leftPt: best.leftPt,
+		rightPt: best.rightPt,
+		sourceItems: new Set(best.members.flatMap((rule) => rule.items))
+	};
+}
+function holdsDrawing(items, rules, topPt) {
+	const bottomPt = rules.positionsDescPt.at(-1);
+	const widthPt = rules.rightPt - rules.leftPt;
+	const inside = (box) => box.loXPt < rules.rightPt - 3 && box.hiXPt > rules.leftPt + 3 && box.loYPt < topPt && box.hiYPt > bottomPt;
+	const spansRow = (box) => box.hiXPt - box.loXPt >= require_layout_lattice.EDGE_COVERAGE_RATIO * widthPt;
+	const horizontal = (box) => box.hiYPt - box.loYPt <= 3 && box.hiXPt - box.loXPt > box.hiYPt - box.loYPt;
+	return items.some((item) => {
+		if (rules.sourceItems.has(item)) return false;
+		const box = boxOf(item);
+		return box !== void 0 && inside(box) && !horizontal(box) && !(item.kind !== "image" && item.kind !== "ellipse" && spansRow(box));
+	});
+}
+function boxOf(item) {
+	switch (item.kind) {
+		case "image":
+		case "rect":
+		case "ellipse": return {
+			loXPt: item.xPt,
+			hiXPt: item.xPt + item.widthPt,
+			loYPt: item.yPt,
+			hiYPt: item.yPt + item.heightPt
+		};
+		case "line": return {
+			loXPt: Math.min(item.x1Pt, item.x2Pt),
+			hiXPt: Math.max(item.x1Pt, item.x2Pt),
+			loYPt: Math.min(item.y1Pt, item.y2Pt),
+			hiYPt: Math.max(item.y1Pt, item.y2Pt)
+		};
+		case "path": {
+			const xs = item.subpaths.flatMap((subpath) => [subpath.startXPt, ...subpath.segments.flatMap((segment) => segment.kind === "cubic" ? [
+				segment.c1xPt,
+				segment.c2xPt,
+				segment.xPt
+			] : [segment.xPt])]);
+			const ys = item.subpaths.flatMap((subpath) => [subpath.startYPt, ...subpath.segments.flatMap((segment) => segment.kind === "cubic" ? [
+				segment.c1yPt,
+				segment.c2yPt,
+				segment.yPt
+			] : [segment.yPt])]);
+			return {
+				loXPt: Math.min(...xs),
+				hiXPt: Math.max(...xs),
+				loYPt: Math.min(...ys),
+				hiYPt: Math.max(...ys)
+			};
+		}
+		case "text":
+		case "link":
+		case "internalLink": return;
+	}
+}
+function spansOverlap(a, b) {
+	const overlapPt = Math.min(a.rightPt, b.rightPt) - Math.max(a.leftPt, b.leftPt);
+	const unionPt = Math.max(a.rightPt, b.rightPt) - Math.min(a.leftPt, b.leftPt);
+	return overlapPt >= require_layout_lattice.EDGE_COVERAGE_RATIO * unionPt;
+}
+function textRuns(row, widestSpacePt) {
+	const runs = [];
+	for (const item of [...row].sort((a, b) => a.xPt - b.xPt)) {
+		const last = runs.at(-1);
+		if (last !== void 0 && item.xPt - last.hiPt <= widestSpacePt) last.hiPt = Math.max(last.hiPt, rightEdge(item));
+		else runs.push({
+			loPt: item.xPt,
+			hiPt: rightEdge(item)
+		});
+	}
+	return runs;
+}
+function sharedGutters(rows, widestSpacePt) {
+	const gapsByRow = rows.map((row) => textRuns(row, widestSpacePt)).filter((runs) => runs.length > 1).map((runs) => runs.slice(1).map((run, index) => ({
+		loPt: runs[index].hiPt,
+		hiPt: run.loPt
+	})));
+	const [first, ...rest] = gapsByRow;
+	if (first === void 0) return;
+	const gutters = rest.reduce((shared, gaps) => shared.flatMap((gutter) => gaps.flatMap((gap) => {
+		const loPt = Math.max(gutter.loPt, gap.loPt);
+		const hiPt = Math.min(gutter.hiPt, gap.hiPt);
+		return hiPt - loPt > widestSpacePt ? [{
+			loPt,
+			hiPt
+		}] : [];
+	})), first);
+	return gutters.length > 0 ? {
+		gutters,
+		rowsWithColumns: gapsByRow.length
+	} : void 0;
+}
+function headingRow(above, topRulePt, dividersPt, tableLines, widestSpacePt) {
+	const reachPt = require_layout_reconstruct_lines.PARAGRAPH_GAP_MULTIPLIER * require_layout_reconstruct_lines.estimateModalLineSpacing(tableLines);
+	const items = [];
+	let lowerPt = topRulePt;
+	for (const line of [...require_layout_reconstruct_lines.clusterIntoLines(above)].reverse()) {
+		if (line.items.some((item) => dividersPt.some((dividerPt) => item.xPt < dividerPt && rightEdge(item) > dividerPt)) || line.baselineY - lowerPt > reachPt) break;
+		items.push(...line.items);
+		lowerPt = line.baselineY;
+	}
+	if (columnsHolding(items, dividersPt, widestSpacePt).size < 2) return;
+	return {
+		items,
+		topPt: Math.max(...items.map((item) => item.yPt + item.sizePt))
+	};
+}
+function columnsHolding(items, dividersPt, widestSpacePt) {
+	return new Set(textRuns(items, widestSpacePt).map((run) => dividersPt.filter((dividerPt) => dividerPt <= run.loPt).length));
+}
+function rowsOfBand(items, topPt, dividersPt, widestSpacePt) {
+	const lines = require_layout_reconstruct_lines.clusterIntoLines(items);
+	const first = lines[0];
+	const opening = first === void 0 ? /* @__PURE__ */ new Set() : columnsHolding(first.items, dividersPt, widestSpacePt);
+	if (!(lines.length > 1 && opening.size > 1 && lines.every((line) => {
+		const occupied = columnsHolding(line.items, dividersPt, widestSpacePt);
+		return [...opening].every((column) => occupied.has(column));
+	}))) return [{
+		items: [...items],
+		topPt
+	}];
+	return lines.map((line, index) => ({
+		items: [...line.items],
+		topPt: index === 0 ? topPt : (lines[index - 1].baselineY + line.baselineY) / 2
+	}));
+}
+function rowRegions(row, rowIndex, dividersPt, widestSpacePt) {
+	const runs = textRuns(row, widestSpacePt);
+	const regions = [];
+	let colStart = 0;
+	dividersPt.forEach((dividerPt, index) => {
+		if (!runs.some((run) => run.loPt < dividerPt && run.hiPt > dividerPt)) {
+			regions.push({
+				rowStart: rowIndex,
+				rowEnd: rowIndex + 1,
+				colStart,
+				colEnd: index + 1
+			});
+			colStart = index + 1;
+		}
+	});
+	regions.push({
+		rowStart: rowIndex,
+		rowEnd: rowIndex + 1,
+		colStart,
+		colEnd: dividersPt.length + 1
+	});
+	return regions;
+}
+function rightEdge(item) {
+	return item.xPt + (item.widthPt ?? 0);
+}
+//#endregion
+exports.detectRuledRowLattice = detectRuledRowLattice;

package/dist/layout/ruled-rows.d.cts

@@ -0,0 +1,11 @@
+import { GridLattice } from "./lattice.cjs";
+import { LayoutItem } from "pdf-codec";
+//#region src/layout/ruled-rows.d.ts
+/**
+ * The grid of a table ruled between its rows and set apart by gutters between its columns, when the page holds one.
+ * @param items - the page's items; rules are read from its lines, paths and thin rectangles, and text from its text items
+ * @returns a lattice whose row boundaries are the rules (and the top of an unruled heading row above them) and whose column boundaries are the table's two ends and the middle of each gutter, a row that crosses a gutter spanning the columns it covers; undefined when no set of rules of one span holds two rows of text, fewer than two rows hold text in more than one place, the rows leave no gutter they all share, or every column reads as running prose
+ */
+declare function detectRuledRowLattice(items: readonly LayoutItem[]): GridLattice | undefined;
+//#endregion
+export { detectRuledRowLattice };

package/dist/layout/ruled-rows.d.ts

@@ -0,0 +1,11 @@
+import { GridLattice } from "./lattice.js";
+import { LayoutItem } from "pdf-codec";
+//#region src/layout/ruled-rows.d.ts
+/**
+ * The grid of a table ruled between its rows and set apart by gutters between its columns, when the page holds one.
+ * @param items - the page's items; rules are read from its lines, paths and thin rectangles, and text from its text items
+ * @returns a lattice whose row boundaries are the rules (and the top of an unruled heading row above them) and whose column boundaries are the table's two ends and the middle of each gutter, a row that crosses a gutter spanning the columns it covers; undefined when no set of rules of one span holds two rows of text, fewer than two rows hold text in more than one place, the rows leave no gutter they all share, or every column reads as running prose
+ */
+declare function detectRuledRowLattice(items: readonly LayoutItem[]): GridLattice | undefined;
+//#endregion
+export { detectRuledRowLattice };

package/dist/layout/ruled-rows.js

@@ -0,0 +1,213 @@
+import { PARAGRAPH_GAP_MULTIPLIER, clusterIntoLines, estimateModalLineSpacing } from "./reconstruct-lines.js";
+import { EDGE_COVERAGE_RATIO, horizontalRules } from "./lattice.js";
+import { isRunningProse, spaceAdvancePt } from "./reading-order.js";
+//#region src/layout/ruled-rows.ts
+/**
+* The grid of a table ruled between its rows and set apart by gutters between its columns, when the page holds one.
+* @param items - the page's items; rules are read from its lines, paths and thin rectangles, and text from its text items
+* @returns a lattice whose row boundaries are the rules (and the top of an unruled heading row above them) and whose column boundaries are the table's two ends and the middle of each gutter, a row that crosses a gutter spanning the columns it covers; undefined when no set of rules of one span holds two rows of text, fewer than two rows hold text in more than one place, the rows leave no gutter they all share, or every column reads as running prose
+*/
+function detectRuledRowLattice(items) {
+	const rules = rulesOfOneTable(items);
+	if (rules === void 0) return;
+	const text = items.filter((item) => item.kind === "text" && item.text.trim().length > 0 && item.xPt >= rules.leftPt && item.xPt < rules.rightPt);
+	if (text.some((item) => item.widthPt === void 0 || item.writingMode !== void 0 || (item.rotationDeg ?? 0) !== 0)) return;
+	const ruledRows = rules.positionsDescPt.slice(1).map((lowerPt, row) => text.filter((item) => item.yPt > lowerPt && item.yPt < rules.positionsDescPt[row]));
+	const widestSpacePt = Math.max(...ruledRows.flat().map(spaceAdvancePt));
+	const shared = sharedGutters(ruledRows, widestSpacePt);
+	if (shared === void 0) return;
+	const { gutters } = shared;
+	const dividersPt = gutters.map((gutter) => (gutter.loPt + gutter.hiPt) / 2);
+	const topRulePt = rules.positionsDescPt[0];
+	const heading = headingRow(text.filter((item) => item.yPt > topRulePt), topRulePt, dividersPt, clusterIntoLines(ruledRows.flat()), widestSpacePt);
+	const rows = heading === void 0 ? ruledRows : [heading.items, ...ruledRows];
+	if (shared.rowsWithColumns + (heading !== void 0 && textRuns(heading.items, widestSpacePt).length > 1 ? 1 : 0) < 2) return;
+	const columnBoundariesAscPt = [
+		rules.leftPt,
+		...dividersPt,
+		rules.rightPt
+	];
+	if (holdsDrawing(items, rules, heading?.topPt ?? rules.positionsDescPt[0])) return;
+	const narrowestGutterPt = Math.min(...gutters.map((gutter) => gutter.hiPt - gutter.loPt));
+	if (columnBoundariesAscPt.slice(1).map((rightPt, column) => rows.flat().filter((item) => item.xPt >= columnBoundariesAscPt[column] && item.xPt < rightPt)).every((column) => isRunningProse(column, narrowestGutterPt))) return;
+	const bands = [...heading === void 0 ? [] : [heading], ...ruledRows.map((rowItems, row) => ({
+		items: rowItems,
+		topPt: rules.positionsDescPt[row]
+	}))].flatMap((band) => rowsOfBand(band.items, band.topPt, dividersPt, widestSpacePt));
+	return {
+		rowBoundariesDescPt: [...bands.map((band) => band.topPt), rules.positionsDescPt.at(-1)],
+		columnBoundariesAscPt,
+		regions: bands.flatMap((band, rowIndex) => rowRegions(band.items, rowIndex, dividersPt, widestSpacePt)),
+		sourceItems: rules.sourceItems
+	};
+}
+function rulesOfOneTable(items) {
+	const groups = [];
+	for (const rule of horizontalRules(items)) {
+		const group = groups.find((members) => members.every((member) => spansOverlap(member, rule)));
+		if (group === void 0) groups.push([rule]);
+		else group.push(rule);
+	}
+	const best = groups.filter((members) => members.length >= 3).map((members) => ({
+		members,
+		leftPt: Math.min(...members.map((rule) => rule.leftPt)),
+		rightPt: Math.max(...members.map((rule) => rule.rightPt))
+	})).sort((a, b) => b.members.length - a.members.length || b.rightPt - b.leftPt - (a.rightPt - a.leftPt))[0];
+	if (best === void 0) return;
+	return {
+		positionsDescPt: best.members.map((rule) => rule.position).sort((a, b) => b - a),
+		leftPt: best.leftPt,
+		rightPt: best.rightPt,
+		sourceItems: new Set(best.members.flatMap((rule) => rule.items))
+	};
+}
+function holdsDrawing(items, rules, topPt) {
+	const bottomPt = rules.positionsDescPt.at(-1);
+	const widthPt = rules.rightPt - rules.leftPt;
+	const inside = (box) => box.loXPt < rules.rightPt - 3 && box.hiXPt > rules.leftPt + 3 && box.loYPt < topPt && box.hiYPt > bottomPt;
+	const spansRow = (box) => box.hiXPt - box.loXPt >= EDGE_COVERAGE_RATIO * widthPt;
+	const horizontal = (box) => box.hiYPt - box.loYPt <= 3 && box.hiXPt - box.loXPt > box.hiYPt - box.loYPt;
+	return items.some((item) => {
+		if (rules.sourceItems.has(item)) return false;
+		const box = boxOf(item);
+		return box !== void 0 && inside(box) && !horizontal(box) && !(item.kind !== "image" && item.kind !== "ellipse" && spansRow(box));
+	});
+}
+function boxOf(item) {
+	switch (item.kind) {
+		case "image":
+		case "rect":
+		case "ellipse": return {
+			loXPt: item.xPt,
+			hiXPt: item.xPt + item.widthPt,
+			loYPt: item.yPt,
+			hiYPt: item.yPt + item.heightPt
+		};
+		case "line": return {
+			loXPt: Math.min(item.x1Pt, item.x2Pt),
+			hiXPt: Math.max(item.x1Pt, item.x2Pt),
+			loYPt: Math.min(item.y1Pt, item.y2Pt),
+			hiYPt: Math.max(item.y1Pt, item.y2Pt)
+		};
+		case "path": {
+			const xs = item.subpaths.flatMap((subpath) => [subpath.startXPt, ...subpath.segments.flatMap((segment) => segment.kind === "cubic" ? [
+				segment.c1xPt,
+				segment.c2xPt,
+				segment.xPt
+			] : [segment.xPt])]);
+			const ys = item.subpaths.flatMap((subpath) => [subpath.startYPt, ...subpath.segments.flatMap((segment) => segment.kind === "cubic" ? [
+				segment.c1yPt,
+				segment.c2yPt,
+				segment.yPt
+			] : [segment.yPt])]);
+			return {
+				loXPt: Math.min(...xs),
+				hiXPt: Math.max(...xs),
+				loYPt: Math.min(...ys),
+				hiYPt: Math.max(...ys)
+			};
+		}
+		case "text":
+		case "link":
+		case "internalLink": return;
+	}
+}
+function spansOverlap(a, b) {
+	const overlapPt = Math.min(a.rightPt, b.rightPt) - Math.max(a.leftPt, b.leftPt);
+	const unionPt = Math.max(a.rightPt, b.rightPt) - Math.min(a.leftPt, b.leftPt);
+	return overlapPt >= EDGE_COVERAGE_RATIO * unionPt;
+}
+function textRuns(row, widestSpacePt) {
+	const runs = [];
+	for (const item of [...row].sort((a, b) => a.xPt - b.xPt)) {
+		const last = runs.at(-1);
+		if (last !== void 0 && item.xPt - last.hiPt <= widestSpacePt) last.hiPt = Math.max(last.hiPt, rightEdge(item));
+		else runs.push({
+			loPt: item.xPt,
+			hiPt: rightEdge(item)
+		});
+	}
+	return runs;
+}
+function sharedGutters(rows, widestSpacePt) {
+	const gapsByRow = rows.map((row) => textRuns(row, widestSpacePt)).filter((runs) => runs.length > 1).map((runs) => runs.slice(1).map((run, index) => ({
+		loPt: runs[index].hiPt,
+		hiPt: run.loPt
+	})));
+	const [first, ...rest] = gapsByRow;
+	if (first === void 0) return;
+	const gutters = rest.reduce((shared, gaps) => shared.flatMap((gutter) => gaps.flatMap((gap) => {
+		const loPt = Math.max(gutter.loPt, gap.loPt);
+		const hiPt = Math.min(gutter.hiPt, gap.hiPt);
+		return hiPt - loPt > widestSpacePt ? [{
+			loPt,
+			hiPt
+		}] : [];
+	})), first);
+	return gutters.length > 0 ? {
+		gutters,
+		rowsWithColumns: gapsByRow.length
+	} : void 0;
+}
+function headingRow(above, topRulePt, dividersPt, tableLines, widestSpacePt) {
+	const reachPt = PARAGRAPH_GAP_MULTIPLIER * estimateModalLineSpacing(tableLines);
+	const items = [];
+	let lowerPt = topRulePt;
+	for (const line of [...clusterIntoLines(above)].reverse()) {
+		if (line.items.some((item) => dividersPt.some((dividerPt) => item.xPt < dividerPt && rightEdge(item) > dividerPt)) || line.baselineY - lowerPt > reachPt) break;
+		items.push(...line.items);
+		lowerPt = line.baselineY;
+	}
+	if (columnsHolding(items, dividersPt, widestSpacePt).size < 2) return;
+	return {
+		items,
+		topPt: Math.max(...items.map((item) => item.yPt + item.sizePt))
+	};
+}
+function columnsHolding(items, dividersPt, widestSpacePt) {
+	return new Set(textRuns(items, widestSpacePt).map((run) => dividersPt.filter((dividerPt) => dividerPt <= run.loPt).length));
+}
+function rowsOfBand(items, topPt, dividersPt, widestSpacePt) {
+	const lines = clusterIntoLines(items);
+	const first = lines[0];
+	const opening = first === void 0 ? /* @__PURE__ */ new Set() : columnsHolding(first.items, dividersPt, widestSpacePt);
+	if (!(lines.length > 1 && opening.size > 1 && lines.every((line) => {
+		const occupied = columnsHolding(line.items, dividersPt, widestSpacePt);
+		return [...opening].every((column) => occupied.has(column));
+	}))) return [{
+		items: [...items],
+		topPt
+	}];
+	return lines.map((line, index) => ({
+		items: [...line.items],
+		topPt: index === 0 ? topPt : (lines[index - 1].baselineY + line.baselineY) / 2
+	}));
+}
+function rowRegions(row, rowIndex, dividersPt, widestSpacePt) {
+	const runs = textRuns(row, widestSpacePt);
+	const regions = [];
+	let colStart = 0;
+	dividersPt.forEach((dividerPt, index) => {
+		if (!runs.some((run) => run.loPt < dividerPt && run.hiPt > dividerPt)) {
+			regions.push({
+				rowStart: rowIndex,
+				rowEnd: rowIndex + 1,
+				colStart,
+				colEnd: index + 1
+			});
+			colStart = index + 1;
+		}
+	});
+	regions.push({
+		rowStart: rowIndex,
+		rowEnd: rowIndex + 1,
+		colStart,
+		colEnd: dividersPt.length + 1
+	});
+	return regions;
+}
+function rightEdge(item) {
+	return item.xPt + (item.widthPt ?? 0);
+}
+//#endregion
+export { detectRuledRowLattice };

package/dist/{reconstruct-presentations-prod-D1KbGPxa.js → reconstruct-presentations-prod-DV7UQqMT.js}

@@ -6,6 +6,7 @@ import { throwIfAborted } from "./ports/abort.js";
 import { HALF_POINT_BUCKET_PT, bucketCounts, clusterIntoLines, clusterIntoParagraphs, estimateModalLineSpacing, fontSizesClose, gapExceeds, lineBox, modeOf, paragraphToContentParagraph, pushRunsForLine, textBoxOfItem, textItemToContentRun, textItemVerticalExtent } from "./layout/reconstruct-lines.js";
 import { detectGridLattice, findColumnIndex, findRowIndex } from "./layout/lattice.js";
 import { compareReadingPosition, readingOrder } from "./layout/reading-order.js";
+import { detectRuledRowLattice } from "./layout/ruled-rows.js";
 import { denseTableRows } from "document-schema.js";
 import { sourcePageIndex } from "pdf-codec/layout";
 //#region src/layout/reconstruct-tables.ts
@@ -14,8 +15,23 @@ function recoverTables(page, pageIndex, structure) {
 		const tagged = recoverTaggedTables(page, pageIndex, structure);
 		if (tagged.length > 0) return tagged;
 	}
-	const lattice = recoverTable(page, pageIndex);
-	return lattice === void 0 ? [] : [lattice];
+	const grid = detectGridLattice(page.items);
+	const gridItems = grid?.sourceItems ?? NO_ITEMS;
+	return [grid, detectRuledRowLattice(page.items.filter((item) => !gridItems.has(item)))].filter((lattice) => lattice !== void 0).filter((lattice, index, lattices) => index === 0 || !latticesOverlap(lattices[0], lattice)).flatMap((lattice) => {
+		const table = recoverTable(page, pageIndex, lattice);
+		return table === void 0 ? [] : [table];
+	});
+}
+function latticesOverlap(a, b) {
+	const aLeft = a.columnBoundariesAscPt[0];
+	const aRight = a.columnBoundariesAscPt.at(-1);
+	const aTop = a.rowBoundariesDescPt[0];
+	const aBottom = a.rowBoundariesDescPt.at(-1);
+	const bLeft = b.columnBoundariesAscPt[0];
+	const bRight = b.columnBoundariesAscPt.at(-1);
+	const bTop = b.rowBoundariesDescPt[0];
+	const bBottom = b.rowBoundariesDescPt.at(-1);
+	return aLeft < bRight && bLeft < aRight && aBottom < bTop && bBottom < aTop;
 }
 function recoverTaggedTables(page, pageIndex, structure) {
 	const cellsByTable = /* @__PURE__ */ new Map();
@@ -126,9 +142,7 @@ function indexRegions(lattice, rowCount, columnCount) {
 	for (const region of lattice.regions) for (let i = region.rowStart; i < region.rowEnd; i++) for (let j = region.colStart; j < region.colEnd; j++) regionAt[i][j] = region;
 	return regionAt;
 }
-function recoverTable(page, pageIndex) {
-	const lattice = detectGridLattice(page.items);
-	if (lattice === void 0) return;
+function recoverTable(page, pageIndex, lattice) {
 	const rowCount = lattice.rowBoundariesDescPt.length - 1;
 	const columnCount = lattice.columnBoundariesAscPt.length - 1;
 	const regionAt = indexRegions(lattice, rowCount, columnCount);