js.documents 1.57.0 → 1.58.0

package/dist/layout/reconstruct.cjs

@@ -0,0 +1,809 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../model/content.cjs");
+const require_model_geometry = require("../model/geometry.cjs");
+const require_ports_abort = require("../ports/abort.cjs");
+let pdf_codec = require("pdf-codec");
+//#region src/layout/reconstruct.ts
+const ZERO_MARGINS = {
+	topPt: 0,
+	rightPt: 0,
+	bottomPt: 0,
+	leftPt: 0
+};
+const LINE_BASELINE_TOLERANCE_FACTOR = .5;
+function clusterIntoLines(items) {
+	const sorted = [...items].sort((a, b) => b.yPt - a.yPt || a.xPt - b.xPt);
+	const working = [];
+	for (const item of sorted) {
+		const tolerance = LINE_BASELINE_TOLERANCE_FACTOR * item.sizePt;
+		const line = working.find((l) => Math.abs(l.baselineY - item.yPt) <= tolerance);
+		if (line === void 0) working.push({
+			items: [item],
+			baselineY: item.yPt
+		});
+		else line.items.push(item);
+	}
+	for (const line of working) line.items.sort((a, b) => a.xPt - b.xPt);
+	working.sort((a, b) => b.baselineY - a.baselineY);
+	return working;
+}
+function textItemVerticalExtent(item) {
+	const { standardName } = (0, pdf_codec.resolveStandardFont)(item.font.family, item.font.weight === "bold", item.font.style === "italic");
+	const metrics = pdf_codec.STANDARD_METRICS[standardName];
+	return {
+		ascentPt: metrics.ascender / 1e3 * item.sizePt,
+		descentPt: Math.abs(metrics.descender) / 1e3 * item.sizePt
+	};
+}
+function textItemToContentRun(item) {
+	return {
+		text: item.text,
+		bold: item.font.weight === "bold" ? true : void 0,
+		italic: item.font.style === "italic" ? true : void 0,
+		fontFamily: item.font.family,
+		sizePt: item.sizePt,
+		color: item.color
+	};
+}
+const MIN_WORD_GAP_PT = .5;
+function pushRunsForLine(runs, line) {
+	line.items.forEach((item, itemIndex) => {
+		if (itemIndex > 0) {
+			const prevItem = line.items[itemIndex - 1];
+			const gap = item.xPt - (prevItem.xPt + (prevItem.widthPt ?? 0));
+			if (gap > LARGE_GAP_EM_MULTIPLIER * item.sizePt) runs.push({ text: "	" });
+			else if (gap > MIN_WORD_GAP_PT) runs[runs.length - 1].text += " ";
+		}
+		runs.push(textItemToContentRun(item));
+	});
+}
+function bucketCounts(values, bucketSize) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const v of values) {
+		const bucket = Math.round(v / bucketSize) * bucketSize;
+		counts.set(bucket, (counts.get(bucket) ?? 0) + 1);
+	}
+	return counts;
+}
+function modeOf(values, bucketSize) {
+	if (values.length === 0) return 0;
+	const counts = bucketCounts(values, bucketSize);
+	let bestBucket = values[0];
+	let bestCount = 0;
+	for (const [bucket, count] of counts) if (count > bestCount) {
+		bestBucket = bucket;
+		bestCount = count;
+	}
+	return bestBucket;
+}
+function modalLineGap(gaps) {
+	const counts = bucketCounts(gaps, .5);
+	let bestBucket = gaps[0];
+	let bestCount = 0;
+	for (const [bucket, count] of counts) if (count > bestCount) {
+		bestBucket = bucket;
+		bestCount = count;
+	}
+	return bestCount > 1 ? bestBucket : Math.min(...gaps);
+}
+const LARGE_GAP_EM_MULTIPLIER = 2;
+const PARAGRAPH_GAP_MULTIPLIER = 1.25;
+const NOMINAL_LINE_SPACING_RATIO = 1.2;
+const MIN_LINES_FOR_GAP_MODE = 3;
+function estimateModalLineSpacing(lines) {
+	if (lines.length < MIN_LINES_FOR_GAP_MODE) return modeOf(lines.map((l) => l.items[0].sizePt), .5) * NOMINAL_LINE_SPACING_RATIO;
+	const gaps = [];
+	for (let i = 1; i < lines.length; i++) gaps.push(lines[i - 1].baselineY - lines[i].baselineY);
+	return modalLineGap(gaps);
+}
+function reconstructWordprocessing(doc, options) {
+	const signal = options?.signal;
+	const sections = [];
+	let currentGroup = [];
+	for (const page of doc.pages) {
+		require_ports_abort.throwIfAborted(signal);
+		if (currentGroup.length > 0 && !samePageSize(currentGroup[0], page)) {
+			sections.push(buildSection(currentGroup, doc.images));
+			currentGroup = [];
+		}
+		currentGroup.push(page);
+	}
+	if (currentGroup.length > 0) sections.push(buildSection(currentGroup, doc.images));
+	return {
+		kind: "wordprocessing",
+		formatVersion: 1,
+		metadata: doc.metadata,
+		sections
+	};
+}
+function samePageSize(a, b) {
+	return a.widthPt === b.widthPt && a.heightPt === b.heightPt;
+}
+function buildSection(pages, images) {
+	const blocks = [];
+	pages.forEach((page, i) => {
+		if (i > 0) blocks.push({ kind: "pageBreak" });
+		blocks.push(...reconstructPageBlocks(page, images));
+	});
+	return {
+		pageSize: {
+			widthPt: pages[0].widthPt,
+			heightPt: pages[0].heightPt
+		},
+		margins: ZERO_MARGINS,
+		blocks
+	};
+}
+function reconstructPageBlocks(page, images) {
+	const textItems = page.items.filter((i) => i.kind === "text");
+	const imageItems = page.items.filter((i) => i.kind === "image");
+	const paragraphs = clusterIntoParagraphs(clusterIntoLines(textItems));
+	const positioned = [];
+	for (const paragraph of paragraphs) positioned.push({
+		yPt: paragraph.lines[0].baselineY,
+		block: paragraphToContentParagraph(paragraph)
+	});
+	for (const img of imageItems) {
+		const asset = images[img.imageId];
+		if (asset !== void 0) positioned.push({
+			yPt: img.yPt,
+			block: {
+				kind: "image",
+				format: asset.format,
+				base64: asset.base64,
+				widthPt: img.widthPt,
+				heightPt: img.heightPt
+			}
+		});
+	}
+	positioned.sort((a, b) => b.yPt - a.yPt);
+	return positioned.map((p) => p.block);
+}
+function clusterIntoParagraphs(lines) {
+	if (lines.length === 0) return [];
+	const modalSpacing = estimateModalLineSpacing(lines);
+	const dominantLeftX = modeOf(lines.map((l) => l.items[0].xPt), 1);
+	const paragraphs = [{ lines: [lines[0]] }];
+	for (let i = 1; i < lines.length; i++) {
+		const prev = lines[i - 1];
+		const next = lines[i];
+		if (startsNewParagraph(prev, next, modalSpacing, dominantLeftX)) paragraphs.push({ lines: [next] });
+		else paragraphs[paragraphs.length - 1].lines.push(next);
+	}
+	return paragraphs;
+}
+function startsNewParagraph(prev, next, modalSpacing, dominantLeftX) {
+	if (prev.baselineY - next.baselineY > PARAGRAPH_GAP_MULTIPLIER * modalSpacing) return true;
+	const nextLeft = next.items[0].xPt;
+	const prevLeft = prev.items[0].xPt;
+	const emPt = next.items[0].sizePt;
+	const nextIndented = Math.abs(nextLeft - dominantLeftX) > emPt;
+	const prevAtMargin = Math.abs(prevLeft - dominantLeftX) <= emPt;
+	return nextIndented && prevAtMargin;
+}
+const LEFT_ALIGN_TOLERANCE_PT = 2;
+function paragraphToContentParagraph(paragraph) {
+	const dominantLeftX = modeOf(paragraph.lines.map((l) => l.items[0].xPt), 1);
+	const alignment = paragraph.lines.every((l) => Math.abs(l.items[0].xPt - dominantLeftX) <= LEFT_ALIGN_TOLERANCE_PT) ? "left" : void 0;
+	const runs = [];
+	paragraph.lines.forEach((line, lineIndex) => {
+		if (lineIndex > 0) {
+			const lastRun = runs[runs.length - 1];
+			if (lastRun !== void 0) lastRun.text += " ";
+		}
+		pushRunsForLine(runs, line);
+	});
+	return {
+		kind: "paragraph",
+		runs,
+		alignment
+	};
+}
+function reconstructPresentation(doc, options) {
+	const signal = options?.signal;
+	const slides = doc.pages.map((page) => {
+		require_ports_abort.throwIfAborted(signal);
+		return reconstructSlide(page, doc.images);
+	});
+	return {
+		kind: "presentation",
+		formatVersion: 1,
+		metadata: doc.metadata,
+		slides
+	};
+}
+function reconstructSlide(page, images) {
+	const textItems = page.items.filter((i) => i.kind === "text");
+	const imageItems = page.items.filter((i) => i.kind === "image");
+	const textShapes = clusterIntoBlocks(clusterIntoLines(textItems)).map((block) => blockToShape(block, page.heightPt));
+	const imageShapes = [];
+	for (const img of imageItems) {
+		const shape = imageToShape(img, page.heightPt, images);
+		if (shape !== void 0) imageShapes.push(shape);
+	}
+	return {
+		size: {
+			widthPt: page.widthPt,
+			heightPt: page.heightPt
+		},
+		shapes: [...imageShapes, ...textShapes],
+		notes: page.notes ?? ""
+	};
+}
+function splitLineByLargeGaps(line) {
+	const segments = [];
+	let current = [];
+	line.items.forEach((item, i) => {
+		if (i > 0) {
+			const prev = line.items[i - 1];
+			if (item.xPt - (prev.xPt + (prev.widthPt ?? 0)) > LARGE_GAP_EM_MULTIPLIER * item.sizePt) {
+				segments.push({
+					items: current,
+					baselineY: line.baselineY
+				});
+				current = [];
+			}
+		}
+		current.push(item);
+	});
+	if (current.length > 0) segments.push({
+		items: current,
+		baselineY: line.baselineY
+	});
+	return segments;
+}
+const FONT_SIZE_CLOSE_TOLERANCE_PT = 1;
+const FONT_SIZE_CLOSE_TOLERANCE_RATIO = .15;
+function fontSizesClose(a, b) {
+	return Math.abs(a - b) <= FONT_SIZE_CLOSE_TOLERANCE_PT || Math.abs(a - b) / Math.max(a, b) <= FONT_SIZE_CLOSE_TOLERANCE_RATIO;
+}
+function clusterIntoBlocks(pageLines) {
+	const segments = pageLines.flatMap(splitLineByLargeGaps);
+	const blocks = [];
+	for (const segment of segments) {
+		const leftX = segment.items[0].xPt;
+		const sizePt = segment.items[0].sizePt;
+		const matched = blocks.find((block) => {
+			const lastLine = block.lines[block.lines.length - 1];
+			const lastLeftX = lastLine.items[0].xPt;
+			const lastSizePt = lastLine.items[0].sizePt;
+			const gap = lastLine.baselineY - segment.baselineY;
+			if (gap <= 0) return false;
+			return Math.abs(leftX - lastLeftX) <= LEFT_ALIGN_TOLERANCE_PT && fontSizesClose(sizePt, lastSizePt) && gap <= PARAGRAPH_GAP_MULTIPLIER * lastSizePt;
+		});
+		if (matched !== void 0) matched.lines.push(segment);
+		else blocks.push({ lines: [segment] });
+	}
+	return blocks;
+}
+function computeBlockFrame(block, slideHeightPt) {
+	let minX = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const line of block.lines) for (const item of line.items) {
+		const { ascentPt, descentPt } = textItemVerticalExtent(item);
+		minX = Math.min(minX, item.xPt);
+		maxX = Math.max(maxX, item.xPt + (item.widthPt ?? 0));
+		minY = Math.min(minY, item.yPt - descentPt);
+		maxY = Math.max(maxY, item.yPt + ascentPt);
+	}
+	return require_model_geometry.flipY({
+		xPt: minX,
+		yPt: minY,
+		widthPt: maxX - minX,
+		heightPt: maxY - minY
+	}, slideHeightPt);
+}
+function lineToParagraph(line) {
+	const runs = [];
+	pushRunsForLine(runs, line);
+	return {
+		kind: "paragraph",
+		runs
+	};
+}
+function blockToShape(block, slideHeightPt) {
+	return {
+		frame: computeBlockFrame(block, slideHeightPt),
+		insetLeftPt: 0,
+		insetTopPt: 0,
+		insetRightPt: 0,
+		insetBottomPt: 0,
+		blocks: block.lines.map(lineToParagraph)
+	};
+}
+function imageToShape(img, slideHeightPt, images) {
+	const asset = images[img.imageId];
+	if (asset === void 0) return;
+	return {
+		frame: require_model_geometry.flipY({
+			xPt: img.xPt,
+			yPt: img.yPt,
+			widthPt: img.widthPt,
+			heightPt: img.heightPt
+		}, slideHeightPt),
+		rotationDeg: img.rotationDeg !== void 0 ? -img.rotationDeg : void 0,
+		insetLeftPt: 0,
+		insetTopPt: 0,
+		insetRightPt: 0,
+		insetBottomPt: 0,
+		blocks: [{
+			kind: "image",
+			format: asset.format,
+			base64: asset.base64,
+			widthPt: img.widthPt,
+			heightPt: img.heightPt
+		}]
+	};
+}
+function reconstructDrawing(doc, options) {
+	const signal = options?.signal;
+	const pages = doc.pages.map((page) => {
+		require_ports_abort.throwIfAborted(signal);
+		return reconstructDrawPage(page, doc.images);
+	});
+	return {
+		kind: "drawing",
+		formatVersion: 1,
+		metadata: doc.metadata,
+		pages
+	};
+}
+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);
+	}
+	return {
+		size: {
+			widthPt: page.widthPt,
+			heightPt: page.heightPt
+		},
+		shapes,
+		vectors
+	};
+}
+function layoutRectToVector(item, pageHeightPt) {
+	return {
+		kind: "rect",
+		frame: require_model_geometry.flipY({
+			xPt: item.xPt,
+			yPt: item.yPt,
+			widthPt: item.widthPt,
+			heightPt: item.heightPt
+		}, pageHeightPt),
+		fill: item.fill,
+		stroke: item.stroke,
+		sourcePath: item.sourcePath
+	};
+}
+function layoutEllipseToVector(item, pageHeightPt) {
+	return {
+		kind: "ellipse",
+		frame: require_model_geometry.flipY({
+			xPt: item.xPt,
+			yPt: item.yPt,
+			widthPt: item.widthPt,
+			heightPt: item.heightPt
+		}, pageHeightPt),
+		fill: item.fill,
+		stroke: item.stroke,
+		sourcePath: item.sourcePath
+	};
+}
+function layoutLineToVector(item, pageHeightPt) {
+	return {
+		kind: "line",
+		from: {
+			xPt: item.x1Pt,
+			yPt: pageHeightPt - item.y1Pt
+		},
+		to: {
+			xPt: item.x2Pt,
+			yPt: pageHeightPt - item.y2Pt
+		},
+		stroke: {
+			color: item.color,
+			widthPt: item.widthPt
+		},
+		sourcePath: item.sourcePath
+	};
+}
+function collectPathPoints(subpaths) {
+	const points = [];
+	for (const subpath of subpaths) {
+		points.push({
+			xPt: subpath.startXPt,
+			yPt: subpath.startYPt
+		});
+		for (const segment of subpath.segments) {
+			if (segment.kind === "cubic") {
+				points.push({
+					xPt: segment.c1xPt,
+					yPt: segment.c1yPt
+				});
+				points.push({
+					xPt: segment.c2xPt,
+					yPt: segment.c2yPt
+				});
+			}
+			points.push({
+				xPt: segment.xPt,
+				yPt: segment.yPt
+			});
+		}
+	}
+	return points;
+}
+function pathBoundingFrame(points, pageHeightPt) {
+	if (points.length === 0) return {
+		xPt: 0,
+		yPt: 0,
+		widthPt: 0,
+		heightPt: 0
+	};
+	let minX = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let minYDown = Number.POSITIVE_INFINITY;
+	let maxYDown = Number.NEGATIVE_INFINITY;
+	for (const point of points) {
+		const yDown = pageHeightPt - point.yPt;
+		minX = Math.min(minX, point.xPt);
+		maxX = Math.max(maxX, point.xPt);
+		minYDown = Math.min(minYDown, yDown);
+		maxYDown = Math.max(maxYDown, yDown);
+	}
+	return {
+		xPt: minX,
+		yPt: minYDown,
+		widthPt: maxX - minX,
+		heightPt: maxYDown - minYDown
+	};
+}
+function localizePathPoint(frame, point, pageHeightPt) {
+	return {
+		xPt: point.xPt - frame.xPt,
+		yPt: pageHeightPt - frame.yPt - point.yPt
+	};
+}
+function layoutPathToVector(item, pageHeightPt) {
+	const frame = pathBoundingFrame(collectPathPoints(item.subpaths), pageHeightPt);
+	return {
+		kind: "path",
+		frame,
+		subpaths: item.subpaths.map((subpath) => ({
+			start: localizePathPoint(frame, {
+				xPt: subpath.startXPt,
+				yPt: subpath.startYPt
+			}, pageHeightPt),
+			closed: subpath.closed,
+			segments: subpath.segments.map((segment) => {
+				if (segment.kind === "line") return {
+					kind: "line",
+					to: localizePathPoint(frame, {
+						xPt: segment.xPt,
+						yPt: segment.yPt
+					}, pageHeightPt)
+				};
+				return {
+					kind: "cubic",
+					control1: localizePathPoint(frame, {
+						xPt: segment.c1xPt,
+						yPt: segment.c1yPt
+					}, pageHeightPt),
+					control2: localizePathPoint(frame, {
+						xPt: segment.c2xPt,
+						yPt: segment.c2yPt
+					}, pageHeightPt),
+					to: localizePathPoint(frame, {
+						xPt: segment.xPt,
+						yPt: segment.yPt
+					}, pageHeightPt)
+				};
+			})
+		})),
+		fill: item.fill,
+		fillRule: item.fillRule,
+		stroke: item.stroke,
+		sourcePath: item.sourcePath
+	};
+}
+function layoutTextToShape(item, pageHeightPt) {
+	return {
+		frame: computeBlockFrame({ lines: [{
+			items: [item],
+			baselineY: item.yPt
+		}] }, pageHeightPt),
+		rotationDeg: item.rotationDeg !== void 0 ? -item.rotationDeg : void 0,
+		insetLeftPt: 0,
+		insetTopPt: 0,
+		insetRightPt: 0,
+		insetBottomPt: 0,
+		blocks: [{
+			kind: "paragraph",
+			runs: [textItemToContentRun(item)]
+		}]
+	};
+}
+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;
+}
+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
+		});
+	}
+	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;
+	return {
+		rowBoundariesDescPt: rowBoundaries.map((l) => l.position),
+		columnBoundariesAscPt: columnBoundaries.map((l) => l.position)
+	};
+}
+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 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 joinCellText(items) {
+	const sorted = [...items].sort((a, b) => a.xPt - b.xPt);
+	let text = "";
+	sorted.forEach((item, i) => {
+		if (i > 0) {
+			const prev = sorted[i - 1];
+			if (item.xPt - (prev.xPt + (prev.widthPt ?? 0)) > MIN_WORD_GAP_PT) text += " ";
+		}
+		text += item.text;
+	});
+	return text;
+}
+function groupKey(row, column) {
+	return `${row},${column}`;
+}
+function addToGroup(groups, row, column, item) {
+	const key = groupKey(row, column);
+	const existing = groups.get(key);
+	if (existing === void 0) groups.set(key, [item]);
+	else existing.push(item);
+}
+function buildCellsFromGroups(groups) {
+	const cells = [];
+	for (const [key, items] of groups) {
+		const displayText = joinCellText(items);
+		if (displayText.length === 0) continue;
+		const [rowPart, columnPart] = key.split(",");
+		cells.push({
+			row: Number(rowPart),
+			column: Number(columnPart),
+			value: {
+				kind: "string",
+				value: displayText
+			},
+			displayText
+		});
+	}
+	cells.sort((a, b) => a.row - b.row || a.column - b.column);
+	return cells;
+}
+function buildGridFromLattice(textItems, lattice) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of textItems) {
+		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 columns = [];
+	for (let j = 0; j < lattice.columnBoundariesAscPt.length - 1; j++) columns.push({
+		index: j,
+		widthPt: lattice.columnBoundariesAscPt[j + 1] - lattice.columnBoundariesAscPt[j]
+	});
+	const rows = [];
+	for (let i = 0; i < lattice.rowBoundariesDescPt.length - 1; i++) rows.push({
+		index: i,
+		heightPt: lattice.rowBoundariesDescPt[i] - lattice.rowBoundariesDescPt[i + 1]
+	});
+	return {
+		cells: buildCellsFromGroups(groups),
+		columns,
+		rows,
+		gridlines: true
+	};
+}
+const COLUMN_ALIGNMENT_TOLERANCE_PT = 3;
+const MIN_COLUMN_RECURRENCE = 2;
+function detectColumnPositions(segmentsByLine) {
+	const allXs = segmentsByLine.flatMap((segments) => segments.map((segment) => segment.items[0].xPt));
+	if (allXs.length === 0) return [];
+	const counts = bucketCounts(allXs, COLUMN_ALIGNMENT_TOLERANCE_PT);
+	const recurring = [...counts.entries()].filter(([, count]) => count >= MIN_COLUMN_RECURRENCE).map(([bucket]) => bucket);
+	const positions = recurring.length > 0 ? recurring : [...counts.keys()];
+	positions.sort((a, b) => a - b);
+	return positions;
+}
+function nearestColumnIndex(positions, xPt) {
+	let bestIndex = 0;
+	let bestDistancePt = Number.POSITIVE_INFINITY;
+	positions.forEach((position, index) => {
+		const distancePt = Math.abs(position - xPt);
+		if (distancePt < bestDistancePt) {
+			bestDistancePt = distancePt;
+			bestIndex = index;
+		}
+	});
+	return bestIndex;
+}
+const DEFAULT_COLUMN_WIDTH_FALLBACK_PT = 40;
+function lastColumnWidthPt(groups, columnIndex, anchorXPt) {
+	let maxWidthPt = 0;
+	for (const [key, items] of groups) {
+		const [, columnPart] = key.split(",");
+		if (Number(columnPart) !== columnIndex) continue;
+		for (const item of items) maxWidthPt = Math.max(maxWidthPt, item.xPt + (item.widthPt ?? 0) - anchorXPt);
+	}
+	return maxWidthPt > 0 ? maxWidthPt : DEFAULT_COLUMN_WIDTH_FALLBACK_PT;
+}
+function buildGridFromTextClustering(textItems) {
+	const lines = clusterIntoLines(textItems);
+	if (lines.length === 0) return {
+		cells: [],
+		columns: [],
+		rows: [],
+		gridlines: false
+	};
+	const segmentsByLine = lines.map((l) => splitLineByLargeGaps(l));
+	const columnPositions = detectColumnPositions(segmentsByLine);
+	const groups = /* @__PURE__ */ new Map();
+	segmentsByLine.forEach((segments, rowIndex) => {
+		for (const segment of segments) {
+			const key = groupKey(rowIndex, nearestColumnIndex(columnPositions, segment.items[0].xPt));
+			const existing = groups.get(key);
+			if (existing === void 0) groups.set(key, [...segment.items]);
+			else existing.push(...segment.items);
+		}
+	});
+	const nominalRowHeightPt = estimateModalLineSpacing(lines);
+	const rows = lines.map((line, i) => {
+		const nextBaselineY = lines[i + 1]?.baselineY;
+		const heightPt = nextBaselineY !== void 0 ? line.baselineY - nextBaselineY : nominalRowHeightPt;
+		return {
+			index: i,
+			heightPt: heightPt > 0 ? heightPt : nominalRowHeightPt
+		};
+	});
+	const columns = columnPositions.map((position, j) => {
+		const nextPosition = columnPositions[j + 1];
+		return {
+			index: j,
+			widthPt: nextPosition !== void 0 ? nextPosition - position : lastColumnWidthPt(groups, j, position)
+		};
+	});
+	return {
+		cells: buildCellsFromGroups(groups),
+		columns,
+		rows,
+		gridlines: false
+	};
+}
+function reconstructSheet(page, pageIndex) {
+	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 printSettings = {
+		pageSize: {
+			widthPt: page.widthPt,
+			heightPt: page.heightPt
+		},
+		margins: ZERO_MARGINS,
+		gridlines: grid.gridlines,
+		headers: false,
+		pageOrder: "downThenOver"
+	};
+	return {
+		name: `Sheet${pageIndex + 1}`,
+		cells: grid.cells,
+		columns: grid.columns,
+		rows: grid.rows,
+		images: [],
+		printSettings
+	};
+}
+function reconstructSpreadsheet(doc, options) {
+	const signal = options?.signal;
+	const sheets = doc.pages.map((page, index) => {
+		require_ports_abort.throwIfAborted(signal);
+		return reconstructSheet(page, index);
+	});
+	return {
+		kind: "spreadsheet",
+		formatVersion: 1,
+		metadata: doc.metadata,
+		sheets
+	};
+}
+//#endregion
+exports.reconstructDrawing = reconstructDrawing;
+exports.reconstructPresentation = reconstructPresentation;
+exports.reconstructSpreadsheet = reconstructSpreadsheet;
+exports.reconstructWordprocessing = reconstructWordprocessing;