js.documents 6.1.1 → 6.1.3

package/dist/layout/lattice.cjs

@@ -74,28 +74,21 @@ function classifyAxisLine(seg) {
 	};
 }
 const POSITION_DEDUPE_TOLERANCE_PT = .5;
-function longestContiguousSpan(segments) {
+function mergedRanges(segments) {
 	const sorted = [...segments].sort((a, b) => a.startPt - b.startPt);
-	let bestStart = sorted[0].startPt;
-	let bestEnd = sorted[0].endPt;
-	let runStart = sorted[0].startPt;
-	let runEnd = sorted[0].endPt;
+	const ranges = [{
+		startPt: sorted[0].startPt,
+		endPt: sorted[0].endPt
+	}];
 	for (const segment of sorted.slice(1)) {
-		if (segment.startPt <= runEnd + POSITION_DEDUPE_TOLERANCE_PT) runEnd = Math.max(runEnd, segment.endPt);
-		else {
-			runStart = segment.startPt;
-			runEnd = segment.endPt;
-		}
-		if (runEnd - runStart > bestEnd - bestStart) {
-			bestStart = runStart;
-			bestEnd = runEnd;
-		}
+		const last = ranges[ranges.length - 1];
+		if (segment.startPt <= last.endPt + POSITION_DEDUPE_TOLERANCE_PT) last.endPt = Math.max(last.endPt, segment.endPt);
+		else ranges.push({
+			startPt: segment.startPt,
+			endPt: segment.endPt
+		});
 	}
-	return {
-		spanPt: bestEnd - bestStart,
-		startPt: bestStart,
-		endPt: bestEnd
-	};
+	return ranges;
 }
 function dedupeAxisLines(segments, descending) {
 	const sorted = [...segments].sort((a, b) => descending ? b.position - a.position : a.position - b.position);
@@ -105,24 +98,103 @@ function dedupeAxisLines(segments, descending) {
 		if (last !== void 0 && Math.abs(candidate.position - last[0].position) <= POSITION_DEDUPE_TOLERANCE_PT) last.push(candidate);
 		else groups.push([candidate]);
 	}
-	return groups.map((group) => {
-		const { spanPt, startPt, endPt } = longestContiguousSpan(group);
-		return {
-			position: group[0].position,
-			spanPt,
-			startPt,
-			endPt,
-			items: group.map((segment) => segment.item)
-		};
-	});
+	return groups.map((group) => ({
+		position: group[0].position,
+		ranges: mergedRanges(group),
+		items: group.map((segment) => segment.item)
+	}));
 }
 const MIN_GRIDLINE_COUNT_PER_AXIS = 3;
-const GRID_SPAN_CONSISTENCY_RATIO = .9;
-function consistentLines(lines) {
-	if (lines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return [];
-	const maxSpanPt = Math.max(...lines.map((l) => l.spanPt));
-	const consistent = lines.filter((l) => l.spanPt >= maxSpanPt * GRID_SPAN_CONSISTENCY_RATIO);
-	return consistent.length >= MIN_GRIDLINE_COUNT_PER_AXIS ? consistent : [];
+const EDGE_COVERAGE_RATIO = .9;
+function bestRunCoverageRatio(ranges, aPt, bPt) {
+	const lo = Math.min(aPt, bPt);
+	const hi = Math.max(aPt, bPt);
+	if (hi <= lo) return 1;
+	let bestPt = 0;
+	for (const range of ranges) {
+		const overlapLo = Math.max(range.startPt, lo);
+		const overlapHi = Math.min(range.endPt, hi);
+		if (overlapHi > overlapLo) bestPt = Math.max(bestPt, overlapHi - overlapLo);
+	}
+	return bestPt / (hi - lo);
+}
+function hasClosedOuterRectangle(rowLines, columnLines) {
+	const leftXPt = columnLines[0].position;
+	const rightXPt = columnLines[columnLines.length - 1].position;
+	const topYPt = rowLines[0].position;
+	const bottomYPt = rowLines[rowLines.length - 1].position;
+	return bestRunCoverageRatio(rowLines[0].ranges, leftXPt, rightXPt) >= EDGE_COVERAGE_RATIO && bestRunCoverageRatio(rowLines[rowLines.length - 1].ranges, leftXPt, rightXPt) >= EDGE_COVERAGE_RATIO && bestRunCoverageRatio(columnLines[0].ranges, bottomYPt, topYPt) >= EDGE_COVERAGE_RATIO && bestRunCoverageRatio(columnLines[columnLines.length - 1].ranges, bottomYPt, topYPt) >= EDGE_COVERAGE_RATIO;
+}
+function unionFind(size) {
+	return Array.from({ length: size }, (_, i) => i);
+}
+function findRoot(parents, index) {
+	let root = index;
+	while (parents[root] !== root) root = parents[root];
+	let current = index;
+	while (parents[current] !== root) {
+		const next = parents[current];
+		parents[current] = root;
+		current = next;
+	}
+	return root;
+}
+function union(parents, a, b) {
+	const rootA = findRoot(parents, a);
+	const rootB = findRoot(parents, b);
+	if (rootA !== rootB) parents[rootA] = rootB;
+}
+function findCellRegions(rowLines, columnLines) {
+	const rowCount = rowLines.length - 1;
+	const colCount = columnLines.length - 1;
+	const indexOf = (row, col) => row * colCount + col;
+	const parents = unionFind(rowCount * colCount);
+	for (let i = 0; i < rowCount; i++) {
+		const rowTopPt = rowLines[i].position;
+		const rowBottomPt = rowLines[i + 1].position;
+		for (let j = 0; j < colCount - 1; j++) {
+			const divider = columnLines[j + 1];
+			if (bestRunCoverageRatio(divider.ranges, rowBottomPt, rowTopPt) < EDGE_COVERAGE_RATIO) union(parents, indexOf(i, j), indexOf(i, j + 1));
+		}
+	}
+	for (let j = 0; j < colCount; j++) {
+		const colLeftPt = columnLines[j].position;
+		const colRightPt = columnLines[j + 1].position;
+		for (let i = 0; i < rowCount - 1; i++) {
+			const divider = rowLines[i + 1];
+			if (bestRunCoverageRatio(divider.ranges, colLeftPt, colRightPt) < EDGE_COVERAGE_RATIO) union(parents, indexOf(i, j), indexOf(i + 1, j));
+		}
+	}
+	const cellsByRoot = /* @__PURE__ */ new Map();
+	for (let i = 0; i < rowCount; i++) for (let j = 0; j < colCount; j++) {
+		const root = findRoot(parents, indexOf(i, j));
+		const cells = cellsByRoot.get(root);
+		if (cells === void 0) cellsByRoot.set(root, [{
+			row: i,
+			col: j
+		}]);
+		else cells.push({
+			row: i,
+			col: j
+		});
+	}
+	if (cellsByRoot.size <= 1) return;
+	const regions = [];
+	for (const cells of cellsByRoot.values()) {
+		const rowStart = Math.min(...cells.map((c) => c.row));
+		const rowEnd = Math.max(...cells.map((c) => c.row)) + 1;
+		const colStart = Math.min(...cells.map((c) => c.col));
+		const colEnd = Math.max(...cells.map((c) => c.col)) + 1;
+		if (cells.length !== (rowEnd - rowStart) * (colEnd - colStart)) return;
+		regions.push({
+			rowStart,
+			rowEnd,
+			colStart,
+			colEnd
+		});
+	}
+	regions.sort((a, b) => a.rowStart - b.rowStart || a.colStart - b.colStart);
+	return regions;
 }
 function detectGridLattice(items) {
 	const horizontal = [];
@@ -132,14 +204,18 @@ function detectGridLattice(items) {
 		if (classified === void 0) continue;
 		(classified.axis === "horizontal" ? horizontal : vertical).push(classified);
 	}
-	const rowBoundaries = consistentLines(dedupeAxisLines(horizontal, true));
-	const columnBoundaries = consistentLines(dedupeAxisLines(vertical, false));
-	if (rowBoundaries.length === 0 || columnBoundaries.length === 0) return;
+	const rowLines = dedupeAxisLines(horizontal, true);
+	const columnLines = dedupeAxisLines(vertical, false);
+	if (rowLines.length < MIN_GRIDLINE_COUNT_PER_AXIS || columnLines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return;
+	if (!hasClosedOuterRectangle(rowLines, columnLines)) return;
+	const regions = findCellRegions(rowLines, columnLines);
+	if (regions === void 0) return;
 	const sourceItems = /* @__PURE__ */ new Set();
-	for (const line of [...rowBoundaries, ...columnBoundaries]) for (const item of line.items) sourceItems.add(item);
+	for (const line of [...rowLines, ...columnLines]) for (const item of line.items) sourceItems.add(item);
 	return {
-		rowBoundariesDescPt: rowBoundaries.map((l) => l.position),
-		columnBoundariesAscPt: columnBoundaries.map((l) => l.position),
+		rowBoundariesDescPt: rowLines.map((l) => l.position),
+		columnBoundariesAscPt: columnLines.map((l) => l.position),
+		regions,
 		sourceItems
 	};
 }

package/dist/layout/lattice.d.cts

@@ -8,13 +8,20 @@ interface LineSegment {
   readonly y2Pt: number;
 }
 declare function extractLineCandidates(items: readonly LayoutItem[]): LineSegment[];
+interface TableRegion {
+  readonly rowStart: number;
+  readonly rowEnd: number;
+  readonly colStart: number;
+  readonly colEnd: number;
+}
 interface GridLattice {
   readonly rowBoundariesDescPt: readonly number[];
   readonly columnBoundariesAscPt: readonly number[];
+  readonly regions: readonly TableRegion[];
   readonly sourceItems: ReadonlySet<LayoutItem>;
 }
 declare function detectGridLattice(items: readonly LayoutItem[]): GridLattice | undefined;
 declare function findRowIndex(rowBoundariesDescPt: readonly number[], yPt: number): number | undefined;
 declare function findColumnIndex(columnBoundariesAscPt: readonly number[], xPt: number): number | undefined;
 //#endregion
-export { GridLattice, LineSegment, detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };
+export { GridLattice, LineSegment, TableRegion, detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };

package/dist/layout/lattice.d.ts

@@ -8,13 +8,20 @@ interface LineSegment {
   readonly y2Pt: number;
 }
 declare function extractLineCandidates(items: readonly LayoutItem[]): LineSegment[];
+interface TableRegion {
+  readonly rowStart: number;
+  readonly rowEnd: number;
+  readonly colStart: number;
+  readonly colEnd: number;
+}
 interface GridLattice {
   readonly rowBoundariesDescPt: readonly number[];
   readonly columnBoundariesAscPt: readonly number[];
+  readonly regions: readonly TableRegion[];
   readonly sourceItems: ReadonlySet<LayoutItem>;
 }
 declare function detectGridLattice(items: readonly LayoutItem[]): GridLattice | undefined;
 declare function findRowIndex(rowBoundariesDescPt: readonly number[], yPt: number): number | undefined;
 declare function findColumnIndex(columnBoundariesAscPt: readonly number[], xPt: number): number | undefined;
 //#endregion
-export { GridLattice, LineSegment, detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };
+export { GridLattice, LineSegment, TableRegion, detectGridLattice, extractLineCandidates, findColumnIndex, findRowIndex };

package/dist/layout/lattice.js

@@ -73,28 +73,21 @@ function classifyAxisLine(seg) {
 	};
 }
 const POSITION_DEDUPE_TOLERANCE_PT = .5;
-function longestContiguousSpan(segments) {
+function mergedRanges(segments) {
 	const sorted = [...segments].sort((a, b) => a.startPt - b.startPt);
-	let bestStart = sorted[0].startPt;
-	let bestEnd = sorted[0].endPt;
-	let runStart = sorted[0].startPt;
-	let runEnd = sorted[0].endPt;
+	const ranges = [{
+		startPt: sorted[0].startPt,
+		endPt: sorted[0].endPt
+	}];
 	for (const segment of sorted.slice(1)) {
-		if (segment.startPt <= runEnd + POSITION_DEDUPE_TOLERANCE_PT) runEnd = Math.max(runEnd, segment.endPt);
-		else {
-			runStart = segment.startPt;
-			runEnd = segment.endPt;
-		}
-		if (runEnd - runStart > bestEnd - bestStart) {
-			bestStart = runStart;
-			bestEnd = runEnd;
-		}
+		const last = ranges[ranges.length - 1];
+		if (segment.startPt <= last.endPt + POSITION_DEDUPE_TOLERANCE_PT) last.endPt = Math.max(last.endPt, segment.endPt);
+		else ranges.push({
+			startPt: segment.startPt,
+			endPt: segment.endPt
+		});
 	}
-	return {
-		spanPt: bestEnd - bestStart,
-		startPt: bestStart,
-		endPt: bestEnd
-	};
+	return ranges;
 }
 function dedupeAxisLines(segments, descending) {
 	const sorted = [...segments].sort((a, b) => descending ? b.position - a.position : a.position - b.position);
@@ -104,24 +97,103 @@ function dedupeAxisLines(segments, descending) {
 		if (last !== void 0 && Math.abs(candidate.position - last[0].position) <= POSITION_DEDUPE_TOLERANCE_PT) last.push(candidate);
 		else groups.push([candidate]);
 	}
-	return groups.map((group) => {
-		const { spanPt, startPt, endPt } = longestContiguousSpan(group);
-		return {
-			position: group[0].position,
-			spanPt,
-			startPt,
-			endPt,
-			items: group.map((segment) => segment.item)
-		};
-	});
+	return groups.map((group) => ({
+		position: group[0].position,
+		ranges: mergedRanges(group),
+		items: group.map((segment) => segment.item)
+	}));
 }
 const MIN_GRIDLINE_COUNT_PER_AXIS = 3;
-const GRID_SPAN_CONSISTENCY_RATIO = .9;
-function consistentLines(lines) {
-	if (lines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return [];
-	const maxSpanPt = Math.max(...lines.map((l) => l.spanPt));
-	const consistent = lines.filter((l) => l.spanPt >= maxSpanPt * GRID_SPAN_CONSISTENCY_RATIO);
-	return consistent.length >= MIN_GRIDLINE_COUNT_PER_AXIS ? consistent : [];
+const EDGE_COVERAGE_RATIO = .9;
+function bestRunCoverageRatio(ranges, aPt, bPt) {
+	const lo = Math.min(aPt, bPt);
+	const hi = Math.max(aPt, bPt);
+	if (hi <= lo) return 1;
+	let bestPt = 0;
+	for (const range of ranges) {
+		const overlapLo = Math.max(range.startPt, lo);
+		const overlapHi = Math.min(range.endPt, hi);
+		if (overlapHi > overlapLo) bestPt = Math.max(bestPt, overlapHi - overlapLo);
+	}
+	return bestPt / (hi - lo);
+}
+function hasClosedOuterRectangle(rowLines, columnLines) {
+	const leftXPt = columnLines[0].position;
+	const rightXPt = columnLines[columnLines.length - 1].position;
+	const topYPt = rowLines[0].position;
+	const bottomYPt = rowLines[rowLines.length - 1].position;
+	return bestRunCoverageRatio(rowLines[0].ranges, leftXPt, rightXPt) >= EDGE_COVERAGE_RATIO && bestRunCoverageRatio(rowLines[rowLines.length - 1].ranges, leftXPt, rightXPt) >= EDGE_COVERAGE_RATIO && bestRunCoverageRatio(columnLines[0].ranges, bottomYPt, topYPt) >= EDGE_COVERAGE_RATIO && bestRunCoverageRatio(columnLines[columnLines.length - 1].ranges, bottomYPt, topYPt) >= EDGE_COVERAGE_RATIO;
+}
+function unionFind(size) {
+	return Array.from({ length: size }, (_, i) => i);
+}
+function findRoot(parents, index) {
+	let root = index;
+	while (parents[root] !== root) root = parents[root];
+	let current = index;
+	while (parents[current] !== root) {
+		const next = parents[current];
+		parents[current] = root;
+		current = next;
+	}
+	return root;
+}
+function union(parents, a, b) {
+	const rootA = findRoot(parents, a);
+	const rootB = findRoot(parents, b);
+	if (rootA !== rootB) parents[rootA] = rootB;
+}
+function findCellRegions(rowLines, columnLines) {
+	const rowCount = rowLines.length - 1;
+	const colCount = columnLines.length - 1;
+	const indexOf = (row, col) => row * colCount + col;
+	const parents = unionFind(rowCount * colCount);
+	for (let i = 0; i < rowCount; i++) {
+		const rowTopPt = rowLines[i].position;
+		const rowBottomPt = rowLines[i + 1].position;
+		for (let j = 0; j < colCount - 1; j++) {
+			const divider = columnLines[j + 1];
+			if (bestRunCoverageRatio(divider.ranges, rowBottomPt, rowTopPt) < EDGE_COVERAGE_RATIO) union(parents, indexOf(i, j), indexOf(i, j + 1));
+		}
+	}
+	for (let j = 0; j < colCount; j++) {
+		const colLeftPt = columnLines[j].position;
+		const colRightPt = columnLines[j + 1].position;
+		for (let i = 0; i < rowCount - 1; i++) {
+			const divider = rowLines[i + 1];
+			if (bestRunCoverageRatio(divider.ranges, colLeftPt, colRightPt) < EDGE_COVERAGE_RATIO) union(parents, indexOf(i, j), indexOf(i + 1, j));
+		}
+	}
+	const cellsByRoot = /* @__PURE__ */ new Map();
+	for (let i = 0; i < rowCount; i++) for (let j = 0; j < colCount; j++) {
+		const root = findRoot(parents, indexOf(i, j));
+		const cells = cellsByRoot.get(root);
+		if (cells === void 0) cellsByRoot.set(root, [{
+			row: i,
+			col: j
+		}]);
+		else cells.push({
+			row: i,
+			col: j
+		});
+	}
+	if (cellsByRoot.size <= 1) return;
+	const regions = [];
+	for (const cells of cellsByRoot.values()) {
+		const rowStart = Math.min(...cells.map((c) => c.row));
+		const rowEnd = Math.max(...cells.map((c) => c.row)) + 1;
+		const colStart = Math.min(...cells.map((c) => c.col));
+		const colEnd = Math.max(...cells.map((c) => c.col)) + 1;
+		if (cells.length !== (rowEnd - rowStart) * (colEnd - colStart)) return;
+		regions.push({
+			rowStart,
+			rowEnd,
+			colStart,
+			colEnd
+		});
+	}
+	regions.sort((a, b) => a.rowStart - b.rowStart || a.colStart - b.colStart);
+	return regions;
 }
 function detectGridLattice(items) {
 	const horizontal = [];
@@ -131,14 +203,18 @@ function detectGridLattice(items) {
 		if (classified === void 0) continue;
 		(classified.axis === "horizontal" ? horizontal : vertical).push(classified);
 	}
-	const rowBoundaries = consistentLines(dedupeAxisLines(horizontal, true));
-	const columnBoundaries = consistentLines(dedupeAxisLines(vertical, false));
-	if (rowBoundaries.length === 0 || columnBoundaries.length === 0) return;
+	const rowLines = dedupeAxisLines(horizontal, true);
+	const columnLines = dedupeAxisLines(vertical, false);
+	if (rowLines.length < MIN_GRIDLINE_COUNT_PER_AXIS || columnLines.length < MIN_GRIDLINE_COUNT_PER_AXIS) return;
+	if (!hasClosedOuterRectangle(rowLines, columnLines)) return;
+	const regions = findCellRegions(rowLines, columnLines);
+	if (regions === void 0) return;
 	const sourceItems = /* @__PURE__ */ new Set();
-	for (const line of [...rowBoundaries, ...columnBoundaries]) for (const item of line.items) sourceItems.add(item);
+	for (const line of [...rowLines, ...columnLines]) for (const item of line.items) sourceItems.add(item);
 	return {
-		rowBoundariesDescPt: rowBoundaries.map((l) => l.position),
-		columnBoundariesAscPt: columnBoundaries.map((l) => l.position),
+		rowBoundariesDescPt: rowLines.map((l) => l.position),
+		columnBoundariesAscPt: columnLines.map((l) => l.position),
+		regions,
 		sourceItems
 	};
 }

package/dist/layout/reconstruct.cjs

@@ -1129,19 +1129,28 @@ function textItemsPdfBox(items) {
 function cellBlocksFromItems(items, pageIndex) {
 	return clusterIntoLines(items).map((line) => lineToParagraph(line, pageIndex));
 }
+function indexRegions(lattice, rowCount, columnCount) {
+	const regionAt = Array.from({ length: rowCount }, () => new Array(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 = require_layout_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 regionAt = indexRegions(lattice, rowCount, columnCount);
+	const textByRegion = /* @__PURE__ */ new Map();
 	const consumedText = /* @__PURE__ */ new Set();
 	for (const item of page.items) {
 		if (item.kind !== "text") continue;
 		const row = require_layout_lattice.findRowIndex(lattice.rowBoundariesDescPt, item.yPt);
 		const column = require_layout_lattice.findColumnIndex(lattice.columnBoundariesAscPt, item.xPt);
 		if (row === void 0 || column === void 0) continue;
-		addToGroup(groups, row, column, item);
+		const region = regionAt[row][column];
+		const existing = textByRegion.get(region);
+		if (existing === void 0) textByRegion.set(region, [item]);
+		else existing.push(item);
 		consumedText.add(item);
 	}
 	if (consumedText.size === 0) return;
@@ -1150,12 +1159,25 @@ function recoverTable(page, pageIndex) {
 	const rows = [];
 	for (let i = 0; i < rowCount; i++) {
 		const cells = [];
-		for (let j = 0; j < columnCount; j++) {
-			const cell = { blocks: cellBlocksFromItems(groups.get(groupKey(i, j)) ?? [], pageIndex) };
-			const cellLeftXPt = lattice.columnBoundariesAscPt[j];
-			const cellRightXPt = lattice.columnBoundariesAscPt[j + 1];
-			const cellTopYPt = lattice.rowBoundariesDescPt[i];
-			const cellBottomYPt = lattice.rowBoundariesDescPt[i + 1];
+		let j = 0;
+		while (j < columnCount) {
+			const region = regionAt[i][j];
+			if (region.rowStart !== i) {
+				cells.push({ blocks: [] });
+				j = region.colEnd;
+				continue;
+			}
+			const colSpan = region.colEnd - region.colStart;
+			const rowSpan = region.rowEnd - region.rowStart;
+			const cell = {
+				blocks: cellBlocksFromItems(textByRegion.get(region) ?? [], pageIndex),
+				colSpan: colSpan > 1 ? colSpan : void 0,
+				rowSpan: rowSpan > 1 ? rowSpan : void 0
+			};
+			const cellLeftXPt = lattice.columnBoundariesAscPt[region.colStart];
+			const cellRightXPt = lattice.columnBoundariesAscPt[region.colEnd];
+			const cellTopYPt = lattice.rowBoundariesDescPt[region.rowStart];
+			const cellBottomYPt = lattice.rowBoundariesDescPt[region.rowEnd];
 			require_layout_shared.stampFrame(cell, pageIndex, {
 				xPt: cellLeftXPt,
 				yPt: cellBottomYPt,
@@ -1163,6 +1185,7 @@ function recoverTable(page, pageIndex) {
 				heightPt: cellTopYPt - cellBottomYPt
 			});
 			cells.push(cell);
+			j = region.colEnd;
 		}
 		rows.push({
 			cells,

package/dist/layout/reconstruct.js

@@ -1128,19 +1128,28 @@ function textItemsPdfBox(items) {
 function cellBlocksFromItems(items, pageIndex) {
 	return clusterIntoLines(items).map((line) => lineToParagraph(line, pageIndex));
 }
+function indexRegions(lattice, rowCount, columnCount) {
+	const regionAt = Array.from({ length: rowCount }, () => new Array(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;
 	const rowCount = lattice.rowBoundariesDescPt.length - 1;
 	const columnCount = lattice.columnBoundariesAscPt.length - 1;
-	const groups = /* @__PURE__ */ new Map();
+	const regionAt = indexRegions(lattice, rowCount, columnCount);
+	const textByRegion = /* @__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);
+		const region = regionAt[row][column];
+		const existing = textByRegion.get(region);
+		if (existing === void 0) textByRegion.set(region, [item]);
+		else existing.push(item);
 		consumedText.add(item);
 	}
 	if (consumedText.size === 0) return;
@@ -1149,12 +1158,25 @@ function recoverTable(page, pageIndex) {
 	const rows = [];
 	for (let i = 0; i < rowCount; i++) {
 		const cells = [];
-		for (let j = 0; j < columnCount; j++) {
-			const cell = { blocks: cellBlocksFromItems(groups.get(groupKey(i, j)) ?? [], pageIndex) };
-			const cellLeftXPt = lattice.columnBoundariesAscPt[j];
-			const cellRightXPt = lattice.columnBoundariesAscPt[j + 1];
-			const cellTopYPt = lattice.rowBoundariesDescPt[i];
-			const cellBottomYPt = lattice.rowBoundariesDescPt[i + 1];
+		let j = 0;
+		while (j < columnCount) {
+			const region = regionAt[i][j];
+			if (region.rowStart !== i) {
+				cells.push({ blocks: [] });
+				j = region.colEnd;
+				continue;
+			}
+			const colSpan = region.colEnd - region.colStart;
+			const rowSpan = region.rowEnd - region.rowStart;
+			const cell = {
+				blocks: cellBlocksFromItems(textByRegion.get(region) ?? [], pageIndex),
+				colSpan: colSpan > 1 ? colSpan : void 0,
+				rowSpan: rowSpan > 1 ? rowSpan : void 0
+			};
+			const cellLeftXPt = lattice.columnBoundariesAscPt[region.colStart];
+			const cellRightXPt = lattice.columnBoundariesAscPt[region.colEnd];
+			const cellTopYPt = lattice.rowBoundariesDescPt[region.rowStart];
+			const cellBottomYPt = lattice.rowBoundariesDescPt[region.rowEnd];
 			stampFrame(cell, pageIndex, {
 				xPt: cellLeftXPt,
 				yPt: cellBottomYPt,
@@ -1162,6 +1184,7 @@ function recoverTable(page, pageIndex) {
 				heightPt: cellTopYPt - cellBottomYPt
 			});
 			cells.push(cell);
+			j = region.colEnd;
 		}
 		rows.push({
 			cells,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js.documents",
-  "version": "6.1.1",
+  "version": "6.1.3",
   "description": "Bidirectional docx/pptx <-> PDF conversion and a read+write editable OOXML document model, built on ooxml.js and Zod 4 codecs.",
   "type": "module",
   "repository": {
@@ -78,12 +78,12 @@
   "license": "MIT",
   "dependencies": {
     "byte-codec": "^1.2.0",
-    "document-schema.js": "^5.1.0",
+    "document-schema.js": "^5.2.0",
     "fflate": "^0.8.3",
-    "markdown-codec": "^6.1.0",
-    "odf.js": "^6.1.0",
-    "ooxml.js": "^6.1.0",
-    "pdf-codec": "^3.5.0",
+    "markdown-codec": "^6.1.1",
+    "odf.js": "^6.1.1",
+    "ooxml.js": "^6.2.0",
+    "pdf-codec": "^3.5.1",
     "temml": "0.13.4",
     "zod": "^4.4.3"
   },