js.documents 14.4.56 → 14.4.57

package/dist/layout/reconstruct.js

@@ -1,1542 +1,2 @@
-import { flipY } from "../model/geometry.js";
-import { buildDrawingBlock } from "../model/embedded-drawing.js";
-import { stampFrame } from "./shared.js";
-import { inferCellValue } from "./cell-typing.js";
-import { throwIfAborted } from "../ports/abort.js";
-import { detectGridLattice, findColumnIndex, findRowIndex } from "./lattice.js";
-import { denseTableRows } from "document-schema.js";
-import { resolveStandardFont } from "pdf-codec/fonts";
-import { STANDARD_METRICS } from "pdf-codec/afm-widths";
-import { runGapPt, runsShareBaseline } from "pdf-codec/text-group";
-//#region src/layout/reconstruct.ts
-const DEFAULT_COLUMN_WIDTH_FALLBACK_PT = 40;
-const NO_ITEMS = /* @__PURE__ */ new Set();
-const LARGE_GAP_EM_MULTIPLIER = 2;
-const ZERO_MARGINS = {
-	topPt: 0,
-	rightPt: 0,
-	bottomPt: 0,
-	leftPt: 0
-};
-const LINE_BASELINE_TOLERANCE_FACTOR = .5;
-const AFM_UNITS_PER_EM = 1e3;
-const HALF_POINT_BUCKET_PT = .5;
-function sharesBaseline(anchor, item) {
-	return runsShareBaseline(anchor, item, { baselineToleranceEm: LINE_BASELINE_TOLERANCE_FACTOR });
-}
-const DUPLICATE_PAINT_BUCKET_PT = .1;
-function duplicatePaintKey(item) {
-	const xBucket = Math.round(item.xPt / DUPLICATE_PAINT_BUCKET_PT);
-	const yBucket = Math.round(item.yPt / DUPLICATE_PAINT_BUCKET_PT);
-	return `${item.text.trim()}|${String(xBucket)}|${String(yBucket)}`;
-}
-function dropDuplicatePaints(items) {
-	const seen = /* @__PURE__ */ new Set();
-	const kept = [];
-	for (const item of items) {
-		const key = duplicatePaintKey(item);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		kept.push(item);
-	}
-	return kept;
-}
-function dropOverlappingRepeatsWithinLine(items) {
-	const rightEdgeByText = /* @__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));
-		kept.push(item);
-	}
-	return kept;
-}
-const REDRAW_PASS_REWIND_TOLERANCE_PT = 2;
-const MIN_REDRAW_PASS_TEXT_LENGTH = 12;
-const REDRAW_PASS_SIMILARITY_THRESHOLD = .6;
-function groupByBaselineInDocumentOrder(items) {
-	const groups = [];
-	for (const item of items) {
-		const group = groups.find((g) => sharesBaseline(g.anchor, item));
-		if (group === void 0) groups.push({
-			anchor: item,
-			items: [item]
-		});
-		else group.items.push(item);
-	}
-	return groups.map((g) => g.items);
-}
-function splitIntoPasses(group) {
-	const passes = [];
-	for (const item of group) {
-		const current = passes.at(-1);
-		const itemRightPt = item.xPt + (item.widthPt ?? 0);
-		if (current !== void 0 && item.xPt >= current.endXPt - REDRAW_PASS_REWIND_TOLERANCE_PT) {
-			current.items.push(item);
-			current.endXPt = Math.max(current.endXPt, itemRightPt);
-		} else passes.push({
-			items: [item],
-			startXPt: item.xPt,
-			endXPt: itemRightPt
-		});
-	}
-	return passes;
-}
-function passText(pass) {
-	return pass.items.map((item) => item.text).join("").trim();
-}
-function passesOverlap(a, b) {
-	return a.startXPt < b.endXPt && b.startXPt < a.endXPt;
-}
-function levenshteinDistance(a, b) {
-	const memo = /* @__PURE__ */ new Map();
-	function distance(i, j) {
-		if (i === 0) return j;
-		if (j === 0) return i;
-		const key = `${String(i)}:${String(j)}`;
-		const cached = memo.get(key);
-		if (cached !== void 0) return cached;
-		const cost = a.charAt(i - 1) === b.charAt(j - 1) ? 0 : 1;
-		const result = Math.min(distance(i - 1, j) + 1, distance(i, j - 1) + 1, distance(i - 1, j - 1) + cost);
-		memo.set(key, result);
-		return result;
-	}
-	return distance(a.length, b.length);
-}
-function textSimilarity(a, b) {
-	const maxLength = Math.max(a.length, b.length);
-	return 1 - levenshteinDistance(a, b) / maxLength;
-}
-function dropFuzzyRedrawnPasses(items) {
-	const toDrop = /* @__PURE__ */ new Set();
-	for (const group of groupByBaselineInDocumentOrder(items)) {
-		const passes = splitIntoPasses(group);
-		if (passes.length < 2) continue;
-		const [first, ...rest] = passes;
-		if (first === void 0) continue;
-		const firstText = passText(first);
-		if (firstText.length < MIN_REDRAW_PASS_TEXT_LENGTH) continue;
-		for (const candidate of rest) {
-			const candidateText = passText(candidate);
-			if (candidateText.length < MIN_REDRAW_PASS_TEXT_LENGTH) continue;
-			if (!passesOverlap(first, candidate)) continue;
-			if (textSimilarity(firstText, candidateText) < REDRAW_PASS_SIMILARITY_THRESHOLD) continue;
-			for (const item of candidate.items) toDrop.add(item);
-		}
-	}
-	if (toDrop.size === 0) return items;
-	return items.filter((item) => !toDrop.has(item));
-}
-function clusterIntoLines(items) {
-	const sorted = [...dropDuplicatePaints(dropFuzzyRedrawnPasses(items))].sort((a, b) => b.yPt - a.yPt || a.xPt - b.xPt);
-	const working = [];
-	for (const item of sorted) {
-		const line = working.find((l) => sharesBaseline(l.anchor, item));
-		if (line === void 0) working.push({
-			items: [item],
-			baselineY: item.yPt,
-			anchor: item
-		});
-		else line.items.push(item);
-	}
-	for (const line of working) {
-		line.items.sort((a, b) => a.xPt - b.xPt);
-		line.items = dropOverlappingRepeatsWithinLine(line.items);
-	}
-	working.sort((a, b) => b.baselineY - a.baselineY);
-	return working;
-}
-function textItemVerticalExtent(item) {
-	const { standardName } = resolveStandardFont(item.font.family, item.font.weight === "bold", item.font.style === "italic");
-	const metrics = STANDARD_METRICS[standardName];
-	return {
-		ascentPt: metrics.ascender / AFM_UNITS_PER_EM * item.sizePt,
-		descentPt: Math.abs(metrics.descender) / AFM_UNITS_PER_EM * item.sizePt
-	};
-}
-function textItemToContentRun(item) {
-	return {
-		text: item.text,
-		...item.font.weight === "bold" ? { bold: true } : {},
-		...item.font.style === "italic" ? { italic: true } : {},
-		fontFamily: item.font.family,
-		sizePt: item.sizePt,
-		color: item.color
-	};
-}
-const MIN_WORD_GAP_PT = .5;
-function gapExceeds(previous, next, thresholdPt) {
-	const gap = runGapPt(previous, next);
-	return gap !== void 0 && gap > thresholdPt;
-}
-function textBoxOfItem(item, pageIndex) {
-	const { ascentPt, descentPt } = textItemVerticalExtent(item);
-	return {
-		pageIndex,
-		xPt: item.xPt,
-		yPt: item.yPt - descentPt,
-		widthPt: item.widthPt ?? 0,
-		heightPt: ascentPt + descentPt
-	};
-}
-function lineBox(line, pageIndex) {
-	let minX = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	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 {
-		pageIndex,
-		xPt: minX,
-		yPt: minY,
-		widthPt: maxX - minX,
-		heightPt: maxY - minY
-	};
-}
-function pushRunsForLine(runs, line, pageIndex) {
-	line.items.forEach((item, itemIndex) => {
-		if (itemIndex > 0) {
-			const prevItem = line.items[itemIndex - 1];
-			if (gapExceeds(prevItem, item, LARGE_GAP_EM_MULTIPLIER * item.sizePt)) runs.push({ text: "	" });
-			else if (gapExceeds(prevItem, item, MIN_WORD_GAP_PT)) runs[runs.length - 1].text += " ";
-		}
-		const run = textItemToContentRun(item);
-		stampFrame(run, pageIndex, textBoxOfItem(item, pageIndex));
-		runs.push(run);
-	});
-}
-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, HALF_POINT_BUCKET_PT);
-	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 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), HALF_POINT_BUCKET_PT) * 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;
-	doc = dropHiddenLayerContent(doc);
-	const headingLevels = headingSizeLevels(doc);
-	const structure = indexStructure(doc);
-	const sections = [];
-	let currentGroup = [];
-	let groupStartPageIndex = 0;
-	for (const page of doc.pages) {
-		throwIfAborted(signal);
-		if (currentGroup.length > 0 && !samePageSize(currentGroup[0], page)) {
-			sections.push(buildSection(currentGroup, groupStartPageIndex, doc.images, headingLevels, doc.form, structure));
-			groupStartPageIndex += currentGroup.length;
-			currentGroup = [];
-		}
-		currentGroup.push(page);
-	}
-	if (currentGroup.length > 0) sections.push(buildSection(currentGroup, groupStartPageIndex, doc.images, headingLevels, doc.form, structure));
-	return {
-		kind: "wordprocessing",
-		metadata: doc.metadata,
-		sections
-	};
-}
-function layerOf(item) {
-	return item.kind === "link" || item.kind === "internalLink" ? void 0 : item.layer;
-}
-function dropHiddenLayerContent(doc) {
-	const hidden = new Set((doc.layers ?? []).filter((layer) => !layer.visible).map((layer) => layer.name));
-	if (hidden.size === 0) return doc;
-	return {
-		...doc,
-		pages: doc.pages.map((page) => ({
-			...page,
-			items: page.items.filter((item) => layerOf(item) === void 0 || !hidden.has(layerOf(item)))
-		}))
-	};
-}
-const HEADING_LEVELS = new Map([
-	"H1",
-	"H2",
-	"H3",
-	"H4",
-	"H5",
-	"H6"
-].map((tag, index) => [tag, index + 1]));
-const DIVISION_TYPES = /* @__PURE__ */ new Set([
-	"Part",
-	"Sect",
-	"Div"
-]);
-const CELL_TYPES = /* @__PURE__ */ new Set(["TD", "TH"]);
-const ROW_TYPES = /* @__PURE__ */ new Set(["TR"]);
-const TABLE_TYPES = /* @__PURE__ */ new Set(["Table"]);
-function indexStructure(doc) {
-	if (doc.structure === void 0 || doc.structure.length === 0) return;
-	const byId = /* @__PURE__ */ new Map();
-	let order = 0;
-	const walk = (element, parent) => {
-		const node = {
-			id: element.id,
-			type: element.type,
-			parent,
-			order: order++
-		};
-		byId.set(element.id, node);
-		for (const child of element.children) walk(child, node);
-	};
-	for (const root of doc.structure) walk(root, void 0);
-	return { nodeOfItem: (item) => item.kind === "link" || item.kind === "internalLink" ? void 0 : byId.get(item.structure ?? "") };
-}
-function nearestOfType(node, types) {
-	for (let current = node; current !== void 0; current = current.parent) if (types.has(current.type)) return current;
-}
-function nearestHeadingLevel(node) {
-	for (let current = node; current !== void 0; current = current.parent) {
-		const level = HEADING_LEVELS.get(current.type);
-		if (level !== void 0) return level;
-	}
-}
-function structureHeadingLevel(items, structure) {
-	if (items.length === 0 || items.some((item) => structure.nodeOfItem(item) === void 0)) return;
-	let level;
-	for (const item of items) {
-		const itemLevel = nearestHeadingLevel(structure.nodeOfItem(item));
-		if (itemLevel === void 0) return { level: void 0 };
-		if (level === void 0) level = itemLevel;
-		else if (level !== itemLevel) return;
-	}
-	return { level };
-}
-const HEADING_MIN_SIZE_DELTA_PT = 2;
-const MAX_HEADING_LEVEL = 6;
-function hasVisibleText(text) {
-	return text.trim().length > 0;
-}
-function headingSizeLevels(doc) {
-	const sizes = [];
-	for (const page of doc.pages) for (const item of page.items) if (item.kind === "text" && hasVisibleText(item.text)) sizes.push(item.sizePt);
-	if (sizes.length === 0) return /* @__PURE__ */ new Map();
-	const bodySizePt = modeOf(sizes, HALF_POINT_BUCKET_PT);
-	const headingBuckets = /* @__PURE__ */ new Set();
-	for (const size of sizes) {
-		const bucket = Math.round(size / HALF_POINT_BUCKET_PT) * HALF_POINT_BUCKET_PT;
-		if (bucket - bodySizePt >= HEADING_MIN_SIZE_DELTA_PT) headingBuckets.add(bucket);
-	}
-	const levels = /* @__PURE__ */ new Map();
-	[...headingBuckets].sort((a, b) => b - a).forEach((bucket, index) => {
-		levels.set(bucket, Math.min(index + 1, MAX_HEADING_LEVEL));
-	});
-	return levels;
-}
-function headingLevelOf(paragraph, levels) {
-	return levels.get(modeOf(paragraph.lines.flatMap((line) => line.items).filter((item) => hasVisibleText(item.text)).map((item) => item.sizePt), HALF_POINT_BUCKET_PT));
-}
-function samePageSize(a, b) {
-	return a.widthPt === b.widthPt && a.heightPt === b.heightPt;
-}
-function buildSection(pages, startPageIndex, images, headingLevels, form, structure) {
-	const blocks = [];
-	const divisionByBlock = /* @__PURE__ */ new WeakMap();
-	pages.forEach((page, i) => {
-		if (i > 0) blocks.push({ kind: "pageBreak" });
-		blocks.push(...reconstructPageBlocks(page, startPageIndex + i, images, headingLevels, form, structure, divisionByBlock));
-	});
-	return {
-		pageSize: {
-			widthPt: pages[0].widthPt,
-			heightPt: pages[0].heightPt
-		},
-		margins: ZERO_MARGINS,
-		blocks: wrapDivisionExtents(blocks, divisionByBlock)
-	};
-}
-function reconstructPageBlocks(page, pageIndex, images, headingLevels, form, structure, divisionByBlock) {
-	const recoveredTables = recoverTables(page, pageIndex, structure);
-	const consumedText = /* @__PURE__ */ new Set();
-	const claimedItems = /* @__PURE__ */ new Set();
-	for (const recovered of recoveredTables) {
-		for (const item of recovered.consumedText) consumedText.add(item);
-		for (const item of recovered.latticeItems) claimedItems.add(item);
-	}
-	const textItems = page.items.filter((i) => i.kind === "text" && !consumedText.has(i));
-	const imageItems = page.items.filter((i) => i.kind === "image");
-	const paragraphs = clusterIntoParagraphs(clusterIntoLines(textItems));
-	const recordDivisions = (block, items) => {
-		if (structure !== void 0) divisionByBlock.set(block, divisionChainOf(items, structure));
-	};
-	const positioned = [];
-	for (const paragraph of paragraphs) {
-		const paragraphItems = paragraph.lines.flatMap((line) => line.items);
-		const structural = structure === void 0 ? void 0 : structureHeadingLevel(paragraphItems, structure);
-		const block = paragraphToContentParagraph(paragraph, pageIndex, structural !== void 0 ? structural.level : headingLevelOf(paragraph, headingLevels));
-		recordDivisions(block, paragraphItems);
-		positioned.push({
-			yPt: paragraph.lines[0].baselineY,
-			block
-		});
-	}
-	for (const img of imageItems) {
-		const asset = images[img.imageId];
-		if (asset !== void 0) {
-			const block = {
-				kind: "image",
-				format: asset.format,
-				base64: asset.base64,
-				widthPt: img.widthPt,
-				heightPt: img.heightPt
-			};
-			stampFrame(block, pageIndex, {
-				xPt: img.xPt,
-				yPt: img.yPt,
-				widthPt: img.widthPt,
-				heightPt: img.heightPt
-			});
-			recordDivisions(block, [img]);
-			positioned.push({
-				yPt: img.yPt,
-				block
-			});
-		}
-	}
-	for (const recovered of recoveredTables) {
-		recordDivisions(recovered.table, [...recovered.consumedText]);
-		positioned.push({
-			yPt: recovered.topYPt,
-			block: recovered.table
-		});
-	}
-	const recoveredVectors = recoverPageVectors(page, pageIndex, claimedItems);
-	if (recoveredVectors !== void 0) {
-		const vectorItems = page.items.filter((item) => !claimedItems.has(item) && layoutItemToVector(item, page.heightPt) !== void 0);
-		recordDivisions(recoveredVectors.block, vectorItems);
-		positioned.push({
-			yPt: recoveredVectors.topYPt,
-			block: recoveredVectors.block
-		});
-	}
-	positioned.sort((a, b) => b.yPt - a.yPt);
-	const blocks = positioned.map((p) => p.block);
-	reconcileLinks(blocks, page, pageIndex);
-	appendAnnotationConstructs(blocks, page, pageIndex);
-	appendFormFieldConstructs(blocks, form, pageIndex);
-	return blocks;
-}
-function divisionChainOf(items, structure) {
-	let prefix;
-	for (const item of items) {
-		const chain = [];
-		for (let current = structure.nodeOfItem(item); current !== void 0; current = current.parent) if (DIVISION_TYPES.has(current.type)) chain.push(current.id);
-		chain.reverse();
-		if (prefix === void 0) {
-			prefix = chain;
-			continue;
-		}
-		let shared = 0;
-		while (shared < prefix.length && shared < chain.length && prefix[shared] === chain[shared]) shared += 1;
-		prefix = prefix.slice(0, shared);
-	}
-	return prefix ?? [];
-}
-function wrapDivisionExtents(blocks, divisionByBlock) {
-	const out = [];
-	const open = [];
-	for (const block of blocks) {
-		const chain = divisionByBlock.get(block);
-		if (chain !== void 0) {
-			while (open.length > 0 && !chain.includes(open[open.length - 1])) {
-				out.push({ kind: "constructEnd" });
-				open.pop();
-			}
-			for (const id of chain) {
-				if (open.includes(id)) continue;
-				out.push({
-					kind: "constructStart",
-					descriptor: { kind: "division" }
-				});
-				open.push(id);
-			}
-		}
-		out.push(block);
-	}
-	while (open.length > 0) {
-		out.push({ kind: "constructEnd" });
-		open.pop();
-	}
-	return out;
-}
-function framesIntersect(a, b) {
-	return a.xPt < b.xPt + b.widthPt && b.xPt < a.xPt + a.widthPt && a.yPt < b.yPt + b.heightPt && b.yPt < a.yPt + a.heightPt;
-}
-function intersectionArea(a, b) {
-	const width = Math.min(a.xPt + a.widthPt, b.xPt + b.widthPt) - Math.max(a.xPt, b.xPt);
-	const height = Math.min(a.yPt + a.heightPt, b.yPt + b.heightPt) - Math.max(a.yPt, b.yPt);
-	return width > 0 && height > 0 ? width * height : 0;
-}
-function reconcileLinks(blocks, page, pageIndex) {
-	for (const item of page.items) {
-		if (item.kind !== "link" && item.kind !== "internalLink") continue;
-		if (item.kind === "link") {
-			let matchedRun = false;
-			for (const block of blocks) {
-				if (block.kind !== "paragraph") continue;
-				for (const run of block.runs) if ((run.frames ?? []).some((frame) => frame.pageIndex === pageIndex && framesIntersect(item, frame))) {
-					run.hyperlink = item.uri;
-					matchedRun = true;
-				}
-			}
-			if (matchedRun) continue;
-		}
-		wrapBestBlock(blocks, item, pageIndex, linkDescriptor(item));
-	}
-}
-function linkDescriptor(item) {
-	if (item.kind === "link") return {
-		kind: "link",
-		target: {
-			kind: "external",
-			uri: item.uri
-		},
-		...item.title !== void 0 ? { title: item.title } : {}
-	};
-	return {
-		kind: "link",
-		target: {
-			kind: "internal",
-			anchor: item.destination
-		},
-		...item.title !== void 0 ? { title: item.title } : {}
-	};
-}
-function blockFramesOn(block, pageIndex) {
-	return block.kind === "constructStart" || block.kind === "constructEnd" ? [] : (block.frames ?? []).filter((frame) => frame.pageIndex === pageIndex);
-}
-function wrapBestBlock(blocks, rect, pageIndex, descriptor) {
-	let bestIndex = -1;
-	let bestArea = 0;
-	blocks.forEach((block, index) => {
-		const area = blockFramesOn(block, pageIndex).reduce((sum, frame) => sum + intersectionArea(rect, frame), 0);
-		if (area > bestArea) {
-			bestArea = area;
-			bestIndex = index;
-		}
-	});
-	const start = {
-		kind: "constructStart",
-		descriptor
-	};
-	const end = { kind: "constructEnd" };
-	if (bestIndex >= 0) {
-		blocks.splice(bestIndex, 0, start);
-		blocks.splice(bestIndex + 2, 0, end);
-	} else blocks.push(start, end);
-}
-function appendAnnotationConstructs(blocks, page, pageIndex) {
-	(page.annotations ?? []).forEach((annotation, annotIndex) => {
-		const key = `pdf-annot-${String(pageIndex)}-${String(annotIndex)}`;
-		blocks.push({
-			kind: "constructStart",
-			descriptor: {
-				kind: "anchor",
-				anchorType: "comment",
-				name: key,
-				definition: key,
-				...annotation.source !== void 0 ? { source: annotation.source } : {}
-			}
-		}, { kind: "constructEnd" });
-	});
-}
-function controlTypeOf(field) {
-	if (field.fieldType === "text") return "plainText";
-	if (field.fieldType === "button") return "button";
-	if (field.fieldType === "combobox") return "comboBox";
-	if (field.fieldType === "listbox") return "dropDown";
-	return "checkbox";
-}
-function appendFormFieldConstructs(blocks, form, pageIndex) {
-	const visit = (fields) => {
-		for (const field of fields) {
-			visit(field.children);
-			if (field.fieldType === "group" || field.fieldType === "signature") continue;
-			for (const widget of field.widgets) {
-				if (widget.pageIndex !== pageIndex) continue;
-				wrapBestBlock(blocks, widget, pageIndex, {
-					kind: "contentControl",
-					controlType: controlTypeOf(field),
-					tag: field.name,
-					...field.alias !== void 0 ? { alias: field.alias } : {},
-					...field.readOnly === true ? { lock: "content" } : {},
-					...field.value !== void 0 ? { value: field.value } : {},
-					...field.checked !== void 0 ? { checked: field.checked } : {},
-					...field.options !== void 0 ? { options: [...field.options] } : {}
-				});
-			}
-		}
-	};
-	visit(form ?? []);
-}
-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;
-	if (!fontSizesClose(prev.items[0].sizePt, next.items[0].sizePt)) 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, pageIndex, headingLevel) {
-	const dominantLeftX = modeOf(paragraph.lines.map((l) => l.items[0].xPt), 1);
-	const result = {
-		kind: "paragraph",
-		runs: [],
-		alignment: paragraph.lines.every((l) => Math.abs(l.items[0].xPt - dominantLeftX) <= LEFT_ALIGN_TOLERANCE_PT) ? "left" : void 0,
-		...headingLevel !== void 0 ? {
-			styleId: `Heading${String(headingLevel)}`,
-			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 += " ";
-		}
-		pushRunsForLine(result.runs, line, pageIndex);
-	});
-	if (headingLevel !== void 0) result.runs = result.runs.map((run) => {
-		if (run.bold !== true) return run;
-		const withoutBold = { ...run };
-		delete withoutBold.bold;
-		return withoutBold;
-	});
-	return result;
-}
-function reconstructPresentation(doc, options) {
-	const signal = options?.signal;
-	const structure = indexStructure(doc);
-	const slides = doc.pages.map((page, pageIndex) => {
-		throwIfAborted(signal);
-		return reconstructSlide(page, pageIndex, doc.images, structure);
-	});
-	return {
-		kind: "presentation",
-		metadata: doc.metadata,
-		slides
-	};
-}
-function reconstructSlide(page, pageIndex, images, structure) {
-	const recoveredTables = recoverTables(page, pageIndex, structure);
-	const consumedText = /* @__PURE__ */ new Set();
-	const claimedItems = /* @__PURE__ */ new Set();
-	for (const recovered of recoveredTables) {
-		for (const item of recovered.consumedText) consumedText.add(item);
-		for (const item of recovered.latticeItems) claimedItems.add(item);
-	}
-	const textItems = page.items.filter((i) => i.kind === "text" && !consumedText.has(i));
-	const imageItems = page.items.filter((i) => i.kind === "image");
-	const textShapes = clusterIntoBlocks(clusterIntoLines(textItems)).map((block) => blockToShape(block, page.heightPt, pageIndex));
-	const imageShapes = [];
-	for (const img of imageItems) {
-		const shape = imageToShape(img, page.heightPt, pageIndex, images);
-		if (shape !== void 0) imageShapes.push(shape);
-	}
-	const recoveredVectors = recoverPageVectors(page, pageIndex, claimedItems);
-	const vectorShapes = recoveredVectors === void 0 ? [] : [wrapBlockInShape(recoveredVectors.block, {
-		xPt: 0,
-		yPt: 0,
-		widthPt: page.widthPt,
-		heightPt: page.heightPt
-	}, page.heightPt, pageIndex)];
-	const tableShapes = recoveredTables.map((recovered) => wrapBlockInShape(recovered.table, recovered.frame, page.heightPt, pageIndex));
-	return {
-		size: {
-			widthPt: page.widthPt,
-			heightPt: page.heightPt
-		},
-		shapes: [
-			...vectorShapes,
-			...imageShapes,
-			...tableShapes,
-			...textShapes
-		],
-		notes: page.notes ?? ""
-	};
-}
-function wrapBlockInShape(block, frame, pageHeightPt, pageIndex) {
-	const shape = {
-		frame,
-		insetLeftPt: 0,
-		insetTopPt: 0,
-		insetRightPt: 0,
-		insetBottomPt: 0,
-		blocks: [block]
-	};
-	stampFrame(shape, pageIndex, flipY(frame, pageHeightPt));
-	return shape;
-}
-function splitLineByLargeGaps(line) {
-	const segments = [];
-	let current = [];
-	line.items.forEach((item, i) => {
-		if (i > 0) {
-			const prev = line.items[i - 1];
-			if (gapExceeds(prev, item, 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 flipY({
-		xPt: minX,
-		yPt: minY,
-		widthPt: maxX - minX,
-		heightPt: maxY - minY
-	}, slideHeightPt);
-}
-function lineToParagraph(line, pageIndex) {
-	const paragraph = {
-		kind: "paragraph",
-		runs: []
-	};
-	stampFrame(paragraph, pageIndex, lineBox(line, pageIndex));
-	pushRunsForLine(paragraph.runs, line, pageIndex);
-	return paragraph;
-}
-function blockToShape(block, slideHeightPt, pageIndex) {
-	const shape = {
-		frame: computeBlockFrame(block, slideHeightPt),
-		insetLeftPt: 0,
-		insetTopPt: 0,
-		insetRightPt: 0,
-		insetBottomPt: 0,
-		blocks: block.lines.map((line) => lineToParagraph(line, pageIndex))
-	};
-	stampFrame(shape, pageIndex, flipY(shape.frame, slideHeightPt));
-	return shape;
-}
-function imageToShape(img, slideHeightPt, pageIndex, images) {
-	const asset = images[img.imageId];
-	if (asset === void 0) return;
-	const frame = flipY({
-		xPt: img.xPt,
-		yPt: img.yPt,
-		widthPt: img.widthPt,
-		heightPt: img.heightPt
-	}, slideHeightPt);
-	const block = {
-		kind: "image",
-		format: asset.format,
-		base64: asset.base64,
-		widthPt: img.widthPt,
-		heightPt: img.heightPt
-	};
-	stampFrame(block, pageIndex, {
-		xPt: img.xPt,
-		yPt: img.yPt,
-		widthPt: img.widthPt,
-		heightPt: img.heightPt
-	});
-	const shape = {
-		frame,
-		rotationDeg: img.rotationDeg !== void 0 ? -img.rotationDeg : void 0,
-		insetLeftPt: 0,
-		insetTopPt: 0,
-		insetRightPt: 0,
-		insetBottomPt: 0,
-		blocks: [block]
-	};
-	stampFrame(shape, pageIndex, {
-		xPt: img.xPt,
-		yPt: img.yPt,
-		widthPt: img.widthPt,
-		heightPt: img.heightPt
-	});
-	return shape;
-}
-function reconstructDrawing(doc, options) {
-	const signal = options?.signal;
-	const pages = doc.pages.map((page, pageIndex) => {
-		throwIfAborted(signal);
-		return reconstructDrawPage(page, pageIndex, doc.images);
-	});
-	return {
-		kind: "drawing",
-		metadata: doc.metadata,
-		pages
-	};
-}
-function reconstructDrawPage(page, pageIndex, images) {
-	const vectors = [];
-	const shapes = [];
-	let paintOrder = 0;
-	for (const item of page.items) {
-		const vector = layoutItemToVector(item, page.heightPt);
-		if (vector !== void 0) {
-			stampVectorFrame(vector, item, pageIndex);
-			vectors.push({
-				...vector,
-				paintOrder: paintOrder++
-			});
-			continue;
-		}
-		if (item.kind === "text") {
-			const shape = layoutTextToShape(item, page.heightPt, pageIndex);
-			stampFrame(shape, pageIndex, flipY(shape.frame, page.heightPt));
-			shapes.push({
-				...shape,
-				paintOrder: paintOrder++
-			});
-		} else if (item.kind === "image") {
-			const shape = imageToShape(item, page.heightPt, pageIndex, images);
-			if (shape !== void 0) shapes.push({
-				...shape,
-				paintOrder: paintOrder++
-			});
-		}
-	}
-	return {
-		size: {
-			widthPt: page.widthPt,
-			heightPt: page.heightPt
-		},
-		shapes,
-		vectors
-	};
-}
-function stampVectorFrame(vector, item, pageIndex) {
-	if (item.kind === "rect" || item.kind === "ellipse") {
-		stampFrame(vector, pageIndex, {
-			xPt: item.xPt,
-			yPt: item.yPt,
-			widthPt: item.widthPt,
-			heightPt: item.heightPt
-		});
-		return;
-	}
-	if (item.kind === "line") {
-		stampFrame(vector, pageIndex, {
-			xPt: Math.min(item.x1Pt, item.x2Pt),
-			yPt: Math.min(item.y1Pt, item.y2Pt),
-			widthPt: Math.abs(item.x2Pt - item.x1Pt),
-			heightPt: Math.abs(item.y2Pt - item.y1Pt)
-		});
-		return;
-	}
-	if (item.kind !== "path") return;
-	const points = collectPathPoints(item.subpaths);
-	let minX = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of points) {
-		minX = Math.min(minX, point.xPt);
-		maxX = Math.max(maxX, point.xPt);
-		minY = Math.min(minY, point.yPt);
-		maxY = Math.max(maxY, point.yPt);
-	}
-	stampFrame(vector, pageIndex, {
-		xPt: minX,
-		yPt: minY,
-		widthPt: maxX - minX,
-		heightPt: maxY - minY
-	});
-}
-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",
-		frame: 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: 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, pageIndex) {
-	const frame = computeBlockFrame({ lines: [{
-		items: [item],
-		baselineY: item.yPt
-	}] }, pageHeightPt);
-	const run = textItemToContentRun(item);
-	stampFrame(run, pageIndex, textBoxOfItem(item, pageIndex));
-	const paragraph = {
-		kind: "paragraph",
-		runs: [run]
-	};
-	stampFrame(paragraph, pageIndex, textBoxOfItem(item, pageIndex));
-	return {
-		frame,
-		rotationDeg: item.rotationDeg !== void 0 ? -item.rotationDeg : void 0,
-		insetLeftPt: 0,
-		insetTopPt: 0,
-		insetRightPt: 0,
-		insetBottomPt: 0,
-		blocks: [paragraph]
-	};
-}
-function vectorTopYDownPt(vector) {
-	return vector.kind === "line" ? Math.min(vector.from.yPt, vector.to.yPt) : vector.frame.yPt;
-}
-function recoverPageVectors(page, pageIndex, excluded) {
-	const vectors = [];
-	for (const item of page.items) {
-		if (excluded.has(item)) continue;
-		const vector = layoutItemToVector(item, page.heightPt);
-		if (vector !== void 0) {
-			stampVectorFrame(vector, item, pageIndex);
-			vectors.push({
-				...vector,
-				paintOrder: vectors.length
-			});
-		}
-	}
-	if (vectors.length === 0) return;
-	const topYDownPt = Math.min(...vectors.map(vectorTopYDownPt));
-	const block = buildDrawingBlock({
-		widthPt: page.widthPt,
-		heightPt: page.heightPt
-	}, vectors);
-	stampFrame(block, pageIndex, {
-		xPt: 0,
-		yPt: 0,
-		widthPt: page.widthPt,
-		heightPt: page.heightPt
-	});
-	return {
-		block,
-		topYPt: page.heightPt - topYDownPt
-	};
-}
-function recoverTables(page, pageIndex, structure) {
-	if (structure !== void 0) {
-		const tagged = recoverTaggedTables(page, pageIndex, structure);
-		if (tagged.length > 0) return tagged;
-	}
-	const lattice = recoverTable(page, pageIndex);
-	return lattice === void 0 ? [] : [lattice];
-}
-function recoverTaggedTables(page, pageIndex, structure) {
-	const cellsByTable = /* @__PURE__ */ new Map();
-	for (const item of page.items) {
-		if (item.kind !== "text") continue;
-		const cell = nearestOfType(structure.nodeOfItem(item), CELL_TYPES);
-		const row = nearestOfType(cell?.parent, ROW_TYPES);
-		const table = nearestOfType(row?.parent, TABLE_TYPES);
-		if (cell === void 0 || row === void 0 || table === void 0) continue;
-		const entry = cellsByTable.get(table.id) ?? {
-			table,
-			cellsById: /* @__PURE__ */ new Map()
-		};
-		const existing = entry.cellsById.get(cell.id);
-		if (existing === void 0) entry.cellsById.set(cell.id, {
-			table,
-			row,
-			cell,
-			items: [item]
-		});
-		else existing.items.push(item);
-		cellsByTable.set(table.id, entry);
-	}
-	if (cellsByTable.size === 0) return [];
-	const latticeItems = detectGridLattice(page.items)?.sourceItems ?? NO_ITEMS;
-	const recovered = [];
-	for (const { cellsById } of cellsByTable.values()) {
-		const cells = [...cellsById.values()];
-		const rowsById = /* @__PURE__ */ new Map();
-		for (const cellEntry of cells) {
-			const rowEntry = rowsById.get(cellEntry.row.id) ?? {
-				row: cellEntry.row,
-				cells: []
-			};
-			rowEntry.cells.push(cellEntry);
-			rowsById.set(cellEntry.row.id, rowEntry);
-		}
-		const rows = [...rowsById.values()].sort((a, b) => a.row.order - b.row.order);
-		for (const row of rows) row.cells.sort((a, b) => a.cell.order - b.cell.order);
-		const columnCount = Math.max(...rows.map((row) => row.cells.length));
-		const columns = [];
-		for (let j = 0; j < columnCount; j++) {
-			let minX = Number.POSITIVE_INFINITY;
-			let maxX = Number.NEGATIVE_INFINITY;
-			for (const row of rows) {
-				const cellEntry = row.cells[j];
-				if (cellEntry === void 0) continue;
-				for (const item of cellEntry.items) {
-					minX = Math.min(minX, item.xPt);
-					maxX = Math.max(maxX, item.xPt + (item.widthPt ?? 0));
-				}
-			}
-			const width = maxX - minX;
-			columns.push({ widthPt: width > 0 ? width : DEFAULT_COLUMN_WIDTH_FALLBACK_PT });
-		}
-		const allItems = cells.flatMap((cellEntry) => cellEntry.items);
-		const contentRows = rows.map((row) => {
-			const contentCells = [];
-			for (let j = 0; j < columnCount; j++) {
-				const cellEntry = row.cells[j];
-				const cell = { blocks: cellBlocksFromItems(cellEntry?.items ?? [], pageIndex) };
-				if (cellEntry !== void 0) stampFrame(cell, pageIndex, textItemsPdfBox(cellEntry.items));
-				contentCells.push(cell);
-			}
-			return { cells: contentCells };
-		});
-		const box = textItemsPdfBox(allItems);
-		const table = {
-			kind: "table",
-			rows: contentRows,
-			columns
-		};
-		stampFrame(table, pageIndex, box);
-		recovered.push({
-			table,
-			frame: flipY(box, page.heightPt),
-			topYPt: box.yPt + box.heightPt,
-			consumedText: new Set(allItems),
-			latticeItems
-		});
-	}
-	return recovered;
-}
-function textItemsPdfBox(items) {
-	let minX = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const item of 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 {
-		xPt: minX,
-		yPt: minY,
-		widthPt: maxX - minX,
-		heightPt: maxY - minY
-	};
-}
-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 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;
-		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;
-	const columns = [];
-	for (let j = 0; j < columnCount; j++) columns.push({ widthPt: lattice.columnBoundariesAscPt[j + 1] - lattice.columnBoundariesAscPt[j] });
-	const positionedRows = [];
-	for (let i = 0; i < rowCount; i++) {
-		const positioned = [];
-		for (let j = 0; j < columnCount; j++) {
-			const region = regionAt[i][j];
-			if (region.rowStart !== i || region.colStart !== j) 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,
-				widthPt: cellRightXPt - cellLeftXPt,
-				heightPt: cellTopYPt - cellBottomYPt
-			});
-			positioned.push({
-				columnIndex: j,
-				cell
-			});
-		}
-		positionedRows.push({
-			cells: positioned,
-			heightPt: lattice.rowBoundariesDescPt[i] - lattice.rowBoundariesDescPt[i + 1]
-		});
-	}
-	const rows = denseTableRows(positionedRows, columnCount);
-	const leftXPt = lattice.columnBoundariesAscPt[0];
-	const rightXPt = lattice.columnBoundariesAscPt[columnCount];
-	const topYPt = lattice.rowBoundariesDescPt[0];
-	const bottomYPt = lattice.rowBoundariesDescPt[rowCount];
-	const pdfBox = {
-		xPt: leftXPt,
-		yPt: bottomYPt,
-		widthPt: rightXPt - leftXPt,
-		heightPt: topYPt - bottomYPt
-	};
-	const frame = flipY(pdfBox, page.heightPt);
-	const table = {
-		kind: "table",
-		rows,
-		columns
-	};
-	stampFrame(table, pageIndex, pdfBox);
-	return {
-		table,
-		frame,
-		topYPt,
-		consumedText,
-		latticeItems: lattice.sourceItems
-	};
-}
-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 (gapExceeds(prev, item, 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, pageIndex, 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);
-		const cell = {
-			row,
-			column,
-			value: inferredCellValue(displayText, row, column, context),
-			displayText
-		};
-		stampFrame(cell, pageIndex, textItemsPdfBox(items));
-		cells.push(cell);
-	}
-	cells.sort((a, b) => a.row - b.row || a.column - b.column);
-	return cells;
-}
-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, pageIndex, context) {
-	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, pageIndex, context),
-		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;
-}
-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, pageIndex, context) {
-	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, pageIndex, context),
-		columns,
-		rows,
-		gridlines: false
-	};
-}
-function reconstructSheet(page, pageIndex, sink) {
-	const textItems = page.items.filter((i) => i.kind === "text");
-	const lattice = detectGridLattice(page.items);
-	const context = {
-		sheetIndex: pageIndex,
-		sink
-	};
-	const grid = lattice !== void 0 ? buildGridFromLattice(textItems, lattice, pageIndex, context) : buildGridFromTextClustering(textItems, pageIndex, context);
-	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) => {
-		throwIfAborted(signal);
-		return reconstructSheet(page, index, options?.onCellTypeInference);
-	});
-	return {
-		kind: "spreadsheet",
-		metadata: doc.metadata,
-		sheets
-	};
-}
-//#endregion
-export { reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing };
+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-B5fkPiRZ.js";
+export { CELL_TYPES, DEFAULT_COLUMN_WIDTH_FALLBACK_PT, NO_ITEMS, ROW_TYPES, TABLE_TYPES, ZERO_MARGINS, indexStructure, nearestOfType, reconstructSpreadsheet, reconstructWordprocessing };