js.documents 14.4.56 → 14.4.57

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

@@ -0,0 +1,1375 @@
+const require_model_geometry = require("./model/geometry.cjs");
+const require_model_embedded_drawing = require("./model/embedded-drawing.cjs");
+const require_layout_shared = require("./layout/shared.cjs");
+const require_layout_cell_typing = require("./layout/cell-typing.cjs");
+const require_ports_abort = require("./ports/abort.cjs");
+const require_layout_reconstruct_lines = require("./layout/reconstruct-lines.cjs");
+const require_layout_lattice = require("./layout/lattice.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/layout/reconstruct-tables.ts
+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 = require_layout_lattice.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 : 40 });
+		}
+		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) require_layout_shared.stampFrame(cell, pageIndex, textItemsPdfBox(cellEntry.items));
+				contentCells.push(cell);
+			}
+			return { cells: contentCells };
+		});
+		const box = textItemsPdfBox(allItems);
+		const table = {
+			kind: "table",
+			rows: contentRows,
+			columns
+		};
+		require_layout_shared.stampFrame(table, pageIndex, box);
+		recovered.push({
+			table,
+			frame: require_model_geometry.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 } = require_layout_reconstruct_lines.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 require_layout_reconstruct_lines.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 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;
+		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];
+			require_layout_shared.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 = (0, document_schema_js.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 = require_model_geometry.flipY(pdfBox, page.heightPt);
+	const table = {
+		kind: "table",
+		rows,
+		columns
+	};
+	require_layout_shared.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 (require_layout_reconstruct_lines.gapExceeds(prev, item, .5)) 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
+		};
+		require_layout_shared.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 = require_layout_cell_typing.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 = 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 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 = require_layout_reconstruct_lines.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 : 40;
+}
+function buildGridFromTextClustering(textItems, pageIndex, context) {
+	const lines = require_layout_reconstruct_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 = require_layout_reconstruct_lines.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
+	};
+}
+//#endregion
+//#region src/layout/reconstruct.ts
+const DEFAULT_COLUMN_WIDTH_FALLBACK_PT = 40;
+const NO_ITEMS = /* @__PURE__ */ new Set();
+const ZERO_MARGINS = {
+	topPt: 0,
+	rightPt: 0,
+	bottomPt: 0,
+	leftPt: 0
+};
+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) {
+		require_ports_abort.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 = require_layout_reconstruct_lines.modeOf(sizes, require_layout_reconstruct_lines.HALF_POINT_BUCKET_PT);
+	const headingBuckets = /* @__PURE__ */ new Set();
+	for (const size of sizes) {
+		const bucket = Math.round(size / require_layout_reconstruct_lines.HALF_POINT_BUCKET_PT) * require_layout_reconstruct_lines.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(require_layout_reconstruct_lines.modeOf(paragraph.lines.flatMap((line) => line.items).filter((item) => hasVisibleText(item.text)).map((item) => item.sizePt), require_layout_reconstruct_lines.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 lines = require_layout_reconstruct_lines.clusterIntoLines(textItems);
+	const paragraphs = require_layout_reconstruct_lines.clusterIntoParagraphs(lines);
+	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 headingLevel = structural !== void 0 ? structural.level : headingLevelOf(paragraph, headingLevels);
+		const block = require_layout_reconstruct_lines.paragraphToContentParagraph(paragraph, pageIndex, headingLevel);
+		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
+			};
+			require_layout_shared.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 reconstructSpreadsheet(doc, options) {
+	const signal = options?.signal;
+	const sheets = doc.pages.map((page, index) => {
+		require_ports_abort.throwIfAborted(signal);
+		return reconstructSheet(page, index, options?.onCellTypeInference);
+	});
+	return {
+		kind: "spreadsheet",
+		metadata: doc.metadata,
+		sheets
+	};
+}
+//#endregion
+//#region src/layout/reconstruct-presentations-prod.ts
+function reconstructPresentation(doc, options) {
+	const signal = options?.signal;
+	const structure = indexStructure(doc);
+	const slides = doc.pages.map((page, pageIndex) => {
+		require_ports_abort.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(require_layout_reconstruct_lines.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]
+	};
+	require_layout_shared.stampFrame(shape, pageIndex, require_model_geometry.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 (require_layout_reconstruct_lines.gapExceeds(prev, item, 2 * 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;
+}
+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) <= 2 && require_layout_reconstruct_lines.fontSizesClose(sizePt, lastSizePt) && gap <= 1.25 * 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 } = require_layout_reconstruct_lines.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, pageIndex) {
+	const paragraph = {
+		kind: "paragraph",
+		runs: []
+	};
+	require_layout_shared.stampFrame(paragraph, pageIndex, require_layout_reconstruct_lines.lineBox(line, pageIndex));
+	require_layout_reconstruct_lines.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))
+	};
+	require_layout_shared.stampFrame(shape, pageIndex, require_model_geometry.flipY(shape.frame, slideHeightPt));
+	return shape;
+}
+function imageToShape(img, slideHeightPt, pageIndex, images) {
+	const asset = images[img.imageId];
+	if (asset === void 0) return;
+	const frame = require_model_geometry.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
+	};
+	require_layout_shared.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]
+	};
+	require_layout_shared.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) => {
+		require_ports_abort.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);
+			require_layout_shared.stampFrame(shape, pageIndex, require_model_geometry.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") {
+		require_layout_shared.stampFrame(vector, pageIndex, {
+			xPt: item.xPt,
+			yPt: item.yPt,
+			widthPt: item.widthPt,
+			heightPt: item.heightPt
+		});
+		return;
+	}
+	if (item.kind === "line") {
+		require_layout_shared.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);
+	}
+	require_layout_shared.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: 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, pageIndex) {
+	const frame = computeBlockFrame({ lines: [{
+		items: [item],
+		baselineY: item.yPt
+	}] }, pageHeightPt);
+	const run = require_layout_reconstruct_lines.textItemToContentRun(item);
+	require_layout_shared.stampFrame(run, pageIndex, require_layout_reconstruct_lines.textBoxOfItem(item, pageIndex));
+	const paragraph = {
+		kind: "paragraph",
+		runs: [run]
+	};
+	require_layout_shared.stampFrame(paragraph, pageIndex, require_layout_reconstruct_lines.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 = require_model_embedded_drawing.buildDrawingBlock({
+		widthPt: page.widthPt,
+		heightPt: page.heightPt
+	}, vectors);
+	require_layout_shared.stampFrame(block, pageIndex, {
+		xPt: 0,
+		yPt: 0,
+		widthPt: page.widthPt,
+		heightPt: page.heightPt
+	});
+	return {
+		block,
+		topYPt: page.heightPt - topYDownPt
+	};
+}
+function reconstructSheet(page, pageIndex, sink) {
+	const textItems = page.items.filter((i) => i.kind === "text");
+	const lattice = require_layout_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
+	};
+}
+//#endregion
+Object.defineProperty(exports, "CELL_TYPES", {
+	enumerable: true,
+	get: function() {
+		return CELL_TYPES;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_COLUMN_WIDTH_FALLBACK_PT", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_COLUMN_WIDTH_FALLBACK_PT;
+	}
+});
+Object.defineProperty(exports, "NO_ITEMS", {
+	enumerable: true,
+	get: function() {
+		return NO_ITEMS;
+	}
+});
+Object.defineProperty(exports, "ROW_TYPES", {
+	enumerable: true,
+	get: function() {
+		return ROW_TYPES;
+	}
+});
+Object.defineProperty(exports, "TABLE_TYPES", {
+	enumerable: true,
+	get: function() {
+		return TABLE_TYPES;
+	}
+});
+Object.defineProperty(exports, "ZERO_MARGINS", {
+	enumerable: true,
+	get: function() {
+		return ZERO_MARGINS;
+	}
+});
+Object.defineProperty(exports, "buildGridFromLattice", {
+	enumerable: true,
+	get: function() {
+		return buildGridFromLattice;
+	}
+});
+Object.defineProperty(exports, "buildGridFromTextClustering", {
+	enumerable: true,
+	get: function() {
+		return buildGridFromTextClustering;
+	}
+});
+Object.defineProperty(exports, "indexStructure", {
+	enumerable: true,
+	get: function() {
+		return indexStructure;
+	}
+});
+Object.defineProperty(exports, "layoutItemToVector", {
+	enumerable: true,
+	get: function() {
+		return layoutItemToVector;
+	}
+});
+Object.defineProperty(exports, "lineToParagraph", {
+	enumerable: true,
+	get: function() {
+		return lineToParagraph;
+	}
+});
+Object.defineProperty(exports, "nearestOfType", {
+	enumerable: true,
+	get: function() {
+		return nearestOfType;
+	}
+});
+Object.defineProperty(exports, "reconstructDrawing", {
+	enumerable: true,
+	get: function() {
+		return reconstructDrawing;
+	}
+});
+Object.defineProperty(exports, "reconstructPresentation", {
+	enumerable: true,
+	get: function() {
+		return reconstructPresentation;
+	}
+});
+Object.defineProperty(exports, "reconstructSheet", {
+	enumerable: true,
+	get: function() {
+		return reconstructSheet;
+	}
+});
+Object.defineProperty(exports, "reconstructSpreadsheet", {
+	enumerable: true,
+	get: function() {
+		return reconstructSpreadsheet;
+	}
+});
+Object.defineProperty(exports, "reconstructWordprocessing", {
+	enumerable: true,
+	get: function() {
+		return reconstructWordprocessing;
+	}
+});
+Object.defineProperty(exports, "recoverPageVectors", {
+	enumerable: true,
+	get: function() {
+		return recoverPageVectors;
+	}
+});
+Object.defineProperty(exports, "recoverTables", {
+	enumerable: true,
+	get: function() {
+		return recoverTables;
+	}
+});
+Object.defineProperty(exports, "splitLineByLargeGaps", {
+	enumerable: true,
+	get: function() {
+		return splitLineByLargeGaps;
+	}
+});