js.documents 14.4.56 → 14.4.57

package/dist/sheets-DWDvGN-g.js

@@ -0,0 +1,545 @@
+import { flipY } from "./model/geometry.js";
+import { t as layoutFormula } from "./layout-DIJzJk4x.js";
+import { wrapRunsToWidth } from "./layout/text-layout.js";
+import { alignmentOffsetPt, formulaSizePtForFrame, justifyLineGapsPt, layoutDocumentOf, lineNaturalHeightPt, packagePagesOf, pushCellBorderLines, registerImage, stampFragmentFrame, stampFrame, sumColumnWidthsPt, toStyledRuns } from "./layout/shared.js";
+import { throwIfAborted } from "./ports/abort.js";
+import { COLOR_BLACK, DEFAULT_LAYOUT_FONT, columnIndexToLetters, resolveCellFillColor, rgbHexToColor } from "document-schema.js";
+//#region src/layout/sheets-render.ts
+function anchoredFormulas(sheet) {
+	const resolved = [];
+	for (const object of sheet.embeddedObjects ?? []) {
+		const anchored = resolveAnchoredFormula(object);
+		if (anchored !== void 0) resolved.push(anchored);
+	}
+	return resolved;
+}
+function resolveAnchoredFormula(object) {
+	if (object.objectKind !== "formula" || object.document.kind !== "formula" || object.document.formula.mathml.length === 0) return;
+	const { anchorRow, anchorColumn, offsetXPt, offsetYPt } = object;
+	if (anchorRow === void 0 || anchorColumn === void 0 || offsetXPt === void 0 || offsetYPt === void 0) return;
+	return {
+		formula: object.document.formula,
+		anchorRow,
+		anchorColumn,
+		offsetXPt,
+		offsetYPt,
+		frame: object.frame
+	};
+}
+function cellStyledRuns(cell) {
+	if (cell.runs !== void 0 && cell.runs.length > 0) {
+		const runsWithNominalSize = cell.runs.map((run) => run.sizePt === void 0 ? {
+			...run,
+			sizePt: 10
+		} : run);
+		return toStyledRuns(runsWithNominalSize);
+	}
+	return [{
+		text: cell.displayText,
+		font: DEFAULT_LAYOUT_FONT,
+		sizePt: 10,
+		color: COLOR_BLACK
+	}];
+}
+function isNumericLikeValue(kind) {
+	return kind === "number" || kind === "percentage" || kind === "currency" || kind === "date" || kind === "time" || kind === "dateTime";
+}
+function defaultAlignmentForValue(kind) {
+	if (isNumericLikeValue(kind)) return "right";
+	if (kind === "boolean" || kind === "error") return "center";
+	return "left";
+}
+function isCellVisuallyEmpty(cell) {
+	return cell === void 0 || cell.value.kind === "empty" && cell.displayText.length === 0;
+}
+function truncateFragmentsToWidth(fragments, measurer, maxWidthPt) {
+	const result = [];
+	for (const fragment of fragments) {
+		if (fragment.xOffsetPt >= maxWidthPt) break;
+		const remainingWidthPt = maxWidthPt - fragment.xOffsetPt;
+		if (measurer.widthOfTextAtSize(fragment.text, fragment.font, fragment.sizePt) <= remainingWidthPt) {
+			result.push(fragment);
+			continue;
+		}
+		const chars = Array.from(fragment.text);
+		let width = 0;
+		let fitCount = 0;
+		for (const char of chars) {
+			const charWidthPt = measurer.widthOfTextAtSize(char, fragment.font, fragment.sizePt);
+			if (width + charWidthPt > remainingWidthPt) break;
+			width += charWidthPt;
+			fitCount++;
+		}
+		if (fitCount > 0) result.push({
+			...fragment,
+			text: chars.slice(0, fitCount).join("")
+		});
+		break;
+	}
+	return result;
+}
+function buildPositionedAxis(repeatIndices, repeatSizePtOf, bandIndices, bandSizePtOf) {
+	const indices = [...repeatIndices, ...bandIndices];
+	const sizesPt = [...repeatIndices.map(repeatSizePtOf), ...bandIndices.map(bandSizePtOf)];
+	const offsetsPt = [0];
+	let running = 0;
+	for (const size of sizesPt) {
+		running += size;
+		offsetsPt.push(running);
+	}
+	return {
+		indices,
+		sizesPt,
+		offsetsPt,
+		positionByIndex: new Map(indices.map((index, position) => [index, position]))
+	};
+}
+function axisSpanSizePt(axis, startIndex, span) {
+	const startPosition = axis.positionByIndex.get(startIndex);
+	if (startPosition === void 0) return 0;
+	return sumColumnWidthsPt(axis.sizesPt, startPosition, span);
+}
+function resolveCellFrame(cell, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt) {
+	const columnPosition = columnAxis.positionByIndex.get(cell.column);
+	const rowPosition = rowAxis.positionByIndex.get(cell.row);
+	if (columnPosition === void 0 || rowPosition === void 0) return;
+	return {
+		xPt: gridLeftXPt + columnAxis.offsetsPt[columnPosition],
+		yPt: gridTopYDownPt + rowAxis.offsetsPt[rowPosition],
+		widthPt: axisSpanSizePt(columnAxis, cell.column, cell.colSpan ?? 1),
+		heightPt: axisSpanSizePt(rowAxis, cell.row, cell.rowSpan ?? 1)
+	};
+}
+function renderCellBackground(cell, frameYDown, pageHeightPt, out) {
+	if (cell.background === void 0) return;
+	const fill = resolveCellFillColor(cell.background);
+	if (fill === void 0) return;
+	const flipped = flipY(frameYDown, pageHeightPt);
+	out.push({
+		kind: "rect",
+		xPt: flipped.xPt,
+		yPt: flipped.yPt,
+		widthPt: flipped.widthPt,
+		heightPt: flipped.heightPt,
+		fill,
+		sourcePath: cell.sourcePath
+	});
+}
+const DEFAULT_CELL_VERTICAL_ALIGNMENT = "bottom";
+function verticalLineTopYDownPt(verticalAlignment, cellTopYDownPt, cellHeightPt, lineHeightPt) {
+	if (verticalAlignment === "top") return cellTopYDownPt + 2;
+	if (verticalAlignment === "middle") return cellTopYDownPt + Math.max(2, (cellHeightPt - lineHeightPt) / 2);
+	return cellTopYDownPt + Math.max(2, cellHeightPt - 2 - lineHeightPt);
+}
+function renderCellText(cell, frameYDown, pageIndex, rowCells, columnAxis, pageHeightPt, measurer, out) {
+	const { xPt: xLeftPt, yPt: yTopDownPt, widthPt: ownWidthPt, heightPt } = frameYDown;
+	const alignment = cell.alignment ?? defaultAlignmentForValue(cell.value.kind);
+	const numericLike = isNumericLikeValue(cell.value.kind);
+	const styledRuns = cellStyledRuns(cell);
+	const lines = wrapRunsToWidth(styledRuns, measurer, Number.POSITIVE_INFINITY);
+	const naturalLine = lines[0];
+	let availableWidthPt = Math.max(0, ownWidthPt - 4);
+	let fragments = naturalLine.fragments;
+	let lineWidthPt = naturalLine.widthPt;
+	let overflowed = false;
+	if (lineWidthPt > availableWidthPt) {
+		overflowed = true;
+		if (numericLike) {
+			const overflowRuns = [{
+				text: "###",
+				font: styledRuns[0].font,
+				sizePt: styledRuns[0].sizePt,
+				color: styledRuns[0].color
+			}];
+			const overflowLine = wrapRunsToWidth(overflowRuns, measurer, Number.POSITIVE_INFINITY)[0];
+			fragments = overflowLine.fragments;
+			lineWidthPt = overflowLine.widthPt;
+		} else if (cell.value.kind === "string") {
+			let spillColumn = cell.column + (cell.colSpan ?? 1);
+			while (lineWidthPt > availableWidthPt) {
+				const neighborPosition = columnAxis.positionByIndex.get(spillColumn);
+				if (neighborPosition === void 0 || !isCellVisuallyEmpty(rowCells?.get(spillColumn))) break;
+				availableWidthPt += columnAxis.sizesPt[neighborPosition];
+				spillColumn++;
+			}
+			if (lineWidthPt > availableWidthPt) fragments = truncateFragmentsToWidth(fragments, measurer, availableWidthPt);
+		} else fragments = truncateFragmentsToWidth(fragments, measurer, availableWidthPt);
+	}
+	const alignOffsetPt = alignmentOffsetPt(alignment, availableWidthPt, lineWidthPt);
+	const textStartXPt = xLeftPt + 2 + alignOffsetPt;
+	const lineHeightPt = lineNaturalHeightPt(naturalLine, measurer, styledRuns[0]);
+	const baselineYDownPt = verticalLineTopYDownPt(cell.verticalAlignment ?? DEFAULT_CELL_VERTICAL_ALIGNMENT, yTopDownPt, heightPt, lineHeightPt) + naturalLine.ascentPt;
+	const justifyGapsPt = alignment === "justify" && !overflowed && lines.length > 1 ? justifyLineGapsPt(naturalLine, availableWidthPt, measurer) : void 0;
+	fragments.forEach((fragment, fragmentIndex) => {
+		const textItem = {
+			kind: "text",
+			text: fragment.text,
+			xPt: textStartXPt + fragment.xOffsetPt + (justifyGapsPt?.[fragmentIndex] ?? 0),
+			yPt: pageHeightPt - baselineYDownPt,
+			font: fragment.font,
+			sizePt: fragment.sizePt,
+			color: fragment.color,
+			underline: fragment.underline,
+			sourcePath: fragment.sourcePath
+		};
+		out.push(textItem);
+		stampFragmentFrame(cell.runs ?? [], fragment, pageIndex, textItem, measurer, naturalLine);
+	});
+}
+function renderHeaderLabels(gutter, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageHeightPt, measurer, out) {
+	const lineHeightPt = measurer.lineHeightAtSize(DEFAULT_LAYOUT_FONT, 8);
+	const ascentPt = measurer.ascenderAtSize(DEFAULT_LAYOUT_FONT, 8);
+	columnAxis.indices.forEach((columnIndex, position) => {
+		const label = columnIndexToLetters(columnIndex);
+		const widthPt = columnAxis.sizesPt[position];
+		const labelWidthPt = measurer.widthOfTextAtSize(label, DEFAULT_LAYOUT_FONT, 8);
+		const xPt = gridLeftXPt + columnAxis.offsetsPt[position] + alignmentOffsetPt("center", widthPt, labelWidthPt);
+		const baselineYDownPt = gridTopYDownPt - gutter.heightPt + (gutter.heightPt - lineHeightPt) / 2 + ascentPt;
+		out.push({
+			kind: "text",
+			text: label,
+			xPt,
+			yPt: pageHeightPt - baselineYDownPt,
+			font: DEFAULT_LAYOUT_FONT,
+			sizePt: 8,
+			color: HEADER_LABEL_COLOR
+		});
+	});
+	rowAxis.indices.forEach((rowIndex, position) => {
+		const label = String(rowIndex + 1);
+		const heightPt = rowAxis.sizesPt[position];
+		const labelWidthPt = measurer.widthOfTextAtSize(label, DEFAULT_LAYOUT_FONT, 8);
+		const xPt = gridLeftXPt - gutter.widthPt + Math.max(2, gutter.widthPt - 2 - labelWidthPt);
+		const baselineYDownPt = gridTopYDownPt + rowAxis.offsetsPt[position] + Math.max(0, (heightPt - lineHeightPt) / 2) + ascentPt;
+		out.push({
+			kind: "text",
+			text: label,
+			xPt,
+			yPt: pageHeightPt - baselineYDownPt,
+			font: DEFAULT_LAYOUT_FONT,
+			sizePt: 8,
+			color: HEADER_LABEL_COLOR
+		});
+	});
+}
+function renderGridlines(gridLeftXPt, gridTopYDownPt, gridWidthPt, gridHeightPt, columnOffsetsPt, rowOffsetsPt, pageHeightPt, out) {
+	for (const offsetPt of columnOffsetsPt) {
+		const xPt = gridLeftXPt + offsetPt;
+		const line = {
+			kind: "line",
+			x1Pt: xPt,
+			y1Pt: pageHeightPt - gridTopYDownPt,
+			x2Pt: xPt,
+			y2Pt: pageHeightPt - (gridTopYDownPt + gridHeightPt),
+			color: GRIDLINE_COLOR,
+			widthPt: GRIDLINE_WIDTH_PT
+		};
+		out.push(line);
+	}
+	for (const offsetPt of rowOffsetsPt) {
+		const yDownPt = gridTopYDownPt + offsetPt;
+		const line = {
+			kind: "line",
+			x1Pt: gridLeftXPt,
+			y1Pt: pageHeightPt - yDownPt,
+			x2Pt: gridLeftXPt + gridWidthPt,
+			y2Pt: pageHeightPt - yDownPt,
+			color: GRIDLINE_COLOR,
+			widthPt: GRIDLINE_WIDTH_PT
+		};
+		out.push(line);
+	}
+}
+function renderAnchoredFormulas(formulas, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageHeightPt, pageIndex, hiddenColumnIndices, hiddenRowIndices, out, mathMetricsAt) {
+	for (const anchored of formulas) {
+		const columnPosition = columnAxis.positionByIndex.get(anchored.anchorColumn);
+		const rowPosition = rowAxis.positionByIndex.get(anchored.anchorRow);
+		if (columnPosition === void 0 || rowPosition === void 0 || hiddenColumnIndices.has(anchored.anchorColumn) || hiddenRowIndices.has(anchored.anchorRow)) continue;
+		const sizePt = formulaSizePtForFrame(anchored.formula.mathml, anchored.frame, mathMetricsAt);
+		const metrics = mathMetricsAt(sizePt);
+		const { box } = layoutFormula(anchored.formula.mathml, {
+			metrics,
+			sizePt,
+			color: COLOR_BLACK
+		});
+		const boxYDown = {
+			xPt: gridLeftXPt + columnAxis.offsetsPt[columnPosition] + anchored.offsetXPt,
+			yPt: gridTopYDownPt + rowAxis.offsetsPt[rowPosition] + anchored.offsetYPt,
+			widthPt: box.widthPt,
+			heightPt: box.heightPt
+		};
+		const flipped = flipY(boxYDown, pageHeightPt);
+		out.push({
+			pageIndex,
+			xPt: flipped.xPt,
+			yPt: flipped.yPt,
+			box
+		});
+	}
+}
+function renderAnchoredImages(sheetImages, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageHeightPt, pageIndex, hiddenColumnIndices, hiddenRowIndices, out, images) {
+	for (const image of sheetImages) {
+		const columnPosition = columnAxis.positionByIndex.get(image.anchorColumn);
+		const rowPosition = rowAxis.positionByIndex.get(image.anchorRow);
+		if (columnPosition === void 0 || rowPosition === void 0 || hiddenColumnIndices.has(image.anchorColumn) || hiddenRowIndices.has(image.anchorRow)) continue;
+		const imageId = registerImage(image, images);
+		const boxYDown = {
+			xPt: gridLeftXPt + columnAxis.offsetsPt[columnPosition] + image.offsetXPt,
+			yPt: gridTopYDownPt + rowAxis.offsetsPt[rowPosition] + image.offsetYPt,
+			widthPt: image.widthPt,
+			heightPt: image.heightPt
+		};
+		const flipped = flipY(boxYDown, pageHeightPt);
+		const imageItem = {
+			kind: "image",
+			imageId,
+			xPt: flipped.xPt,
+			yPt: flipped.yPt,
+			widthPt: image.widthPt,
+			heightPt: image.heightPt,
+			sourcePath: image.sourcePath
+		};
+		out.push(imageItem);
+		stampFrame(image, pageIndex, {
+			xPt: imageItem.xPt,
+			yPt: imageItem.yPt,
+			widthPt: imageItem.widthPt,
+			heightPt: imageItem.heightPt
+		});
+	}
+}
+//#endregion
+//#region src/layout/sheets.ts
+const PERCENT_SCALE = 100;
+const DEFAULT_COLUMN_WIDTH_PT = 64;
+const DEFAULT_ROW_HEIGHT_PT = 15;
+const NOMINAL_CELL_TEXT_SIZE_PT = 10;
+const HEADER_LABEL_SIZE_PT = 8;
+const CELL_TEXT_PADDING_PT = 2;
+const HEADER_LABEL_PADDING_PT = 2;
+const MINIMUM_SCALE = .01;
+const NUMERIC_OVERFLOW_TEXT = "###";
+const GRIDLINE_COLOR = rgbHexToColor("#D0D0D0");
+const GRIDLINE_WIDTH_PT = .5;
+const HEADER_LABEL_COLOR = rgbHexToColor("#606060");
+function resolvePrintRange(sheet, formulas) {
+	if (sheet.printSettings.printRange !== void 0) return sheet.printSettings.printRange;
+	if (sheet.cells.length === 0 && formulas.length === 0 && sheet.images.length === 0) return;
+	let startRow = Number.POSITIVE_INFINITY;
+	let startColumn = Number.POSITIVE_INFINITY;
+	let endRow = Number.NEGATIVE_INFINITY;
+	let endColumn = Number.NEGATIVE_INFINITY;
+	for (const cell of sheet.cells) {
+		startRow = Math.min(startRow, cell.row);
+		startColumn = Math.min(startColumn, cell.column);
+		endRow = Math.max(endRow, cell.row + (cell.rowSpan ?? 1) - 1);
+		endColumn = Math.max(endColumn, cell.column + (cell.colSpan ?? 1) - 1);
+	}
+	for (const formula of formulas) {
+		startRow = Math.min(startRow, formula.anchorRow);
+		startColumn = Math.min(startColumn, formula.anchorColumn);
+		endRow = Math.max(endRow, formula.anchorRow);
+		endColumn = Math.max(endColumn, formula.anchorColumn);
+	}
+	for (const image of sheet.images) {
+		startRow = Math.min(startRow, image.anchorRow);
+		startColumn = Math.min(startColumn, image.anchorColumn);
+		endRow = Math.max(endRow, image.anchorRow);
+		endColumn = Math.max(endColumn, image.anchorColumn);
+	}
+	return {
+		startRow,
+		startColumn,
+		endRow,
+		endColumn
+	};
+}
+function resolveAxis(entries, start, end, defaultSizePt) {
+	const sorted = [...entries].sort((a, b) => a.index - b.index);
+	const resolved = [];
+	let pointer = 0;
+	let currentSizePt = defaultSizePt;
+	let currentHidden = false;
+	for (let index = start; index <= end; index++) {
+		while (pointer < sorted.length && sorted[pointer].index <= index) {
+			currentSizePt = sorted[pointer].sizePt ?? defaultSizePt;
+			currentHidden = sorted[pointer].hidden ?? false;
+			pointer++;
+		}
+		resolved.push({
+			index,
+			sizePt: currentHidden ? 0 : currentSizePt,
+			hidden: currentHidden
+		});
+	}
+	return resolved;
+}
+function computeHeaderGutter(printSettings, range, measurer) {
+	if (!printSettings.headers) return {
+		widthPt: 0,
+		heightPt: 0
+	};
+	const widestRowLabel = String(range.endRow + 1);
+	return {
+		widthPt: measurer.widthOfTextAtSize(widestRowLabel, DEFAULT_LAYOUT_FONT, 8) + 4,
+		heightPt: measurer.lineHeightAtSize(DEFAULT_LAYOUT_FONT, 8)
+	};
+}
+function resolveScale(printSettings, availableWidthPt, availableHeightPt, totalContentWidthPt, totalContentHeightPt) {
+	if (printSettings.scalePercent !== void 0) return Math.max(printSettings.scalePercent / PERCENT_SCALE, MINIMUM_SCALE);
+	if (printSettings.fitToPages !== void 0) {
+		const budgetWidthPt = availableWidthPt * printSettings.fitToPages.width;
+		const budgetHeightPt = availableHeightPt * printSettings.fitToPages.height;
+		const widthRatio = totalContentWidthPt > 0 ? budgetWidthPt / totalContentWidthPt : 1;
+		const heightRatio = totalContentHeightPt > 0 ? budgetHeightPt / totalContentHeightPt : 1;
+		return Math.max(Math.min(widthRatio, heightRatio, 1), MINIMUM_SCALE);
+	}
+	return 1;
+}
+function partitionIndices(indices, sizeOf, availablePt, manualBreaks) {
+	const bands = [];
+	let current = [];
+	let currentSizePt = 0;
+	for (const index of indices) {
+		if (manualBreaks.has(index) && current.length > 0) {
+			bands.push(current);
+			current = [];
+			currentSizePt = 0;
+		}
+		const sizePt = sizeOf(index);
+		if (current.length > 0 && currentSizePt + sizePt > availablePt) {
+			bands.push(current);
+			current = [];
+			currentSizePt = 0;
+		}
+		current.push(index);
+		currentSizePt += sizePt;
+	}
+	if (current.length > 0) bands.push(current);
+	return bands;
+}
+function bandableIndices(start, end, repeat) {
+	const indices = [];
+	for (let i = start; i <= end; i++) {
+		if (repeat !== void 0 && i >= repeat.start && i <= repeat.end) continue;
+		indices.push(i);
+	}
+	return indices;
+}
+function rangeIndices(start, end) {
+	const indices = [];
+	for (let i = start; i <= end; i++) indices.push(i);
+	return indices;
+}
+function convertSheetToPages(sheet, measurer, signal, out, formulasOut, images, mathMetricsAt) {
+	throwIfAborted(signal);
+	const formulas = anchoredFormulas(sheet);
+	const range = resolvePrintRange(sheet, formulas);
+	if (range === void 0) return;
+	const { printSettings } = sheet;
+	const { pageSize, margins } = printSettings;
+	const pageContentWidthPt = Math.max(0, pageSize.widthPt - margins.leftPt - margins.rightPt);
+	const pageContentHeightPt = Math.max(0, pageSize.heightPt - margins.topPt - margins.bottomPt);
+	const columnEntries = resolveAxis(sheet.columns.map((c) => ({
+		index: c.index,
+		sizePt: c.widthPt,
+		hidden: c.hidden
+	})), range.startColumn, range.endColumn, DEFAULT_COLUMN_WIDTH_PT);
+	const rowEntries = resolveAxis(sheet.rows.map((r) => ({
+		index: r.index,
+		sizePt: r.heightPt,
+		hidden: r.hidden
+	})), range.startRow, range.endRow, DEFAULT_ROW_HEIGHT_PT);
+	const columnSizeByIndex = new Map(columnEntries.map((e) => [e.index, e.sizePt]));
+	const rowSizeByIndex = new Map(rowEntries.map((e) => [e.index, e.sizePt]));
+	const hiddenColumnIndices = new Set(columnEntries.filter((e) => e.hidden).map((e) => e.index));
+	const hiddenRowIndices = new Set(rowEntries.filter((e) => e.hidden).map((e) => e.index));
+	const gutter = computeHeaderGutter(printSettings, range, measurer);
+	const repeatColumns = printSettings.repeatColumns;
+	const repeatRows = printSettings.repeatRows;
+	const repeatColumnIndices = repeatColumns === void 0 ? [] : rangeIndices(repeatColumns.start, repeatColumns.end);
+	const repeatRowIndices = repeatRows === void 0 ? [] : rangeIndices(repeatRows.start, repeatRows.end);
+	const repeatColumnsWidthPt = repeatColumnIndices.reduce((sum, i) => sum + (columnSizeByIndex.get(i) ?? 0), 0);
+	const repeatRowsHeightPt = repeatRowIndices.reduce((sum, i) => sum + (rowSizeByIndex.get(i) ?? 0), 0);
+	const bandableColumnIndices = bandableIndices(range.startColumn, range.endColumn, repeatColumns);
+	const bandableRowIndices = bandableIndices(range.startRow, range.endRow, repeatRows);
+	const availableWidthPt = Math.max(0, pageContentWidthPt - gutter.widthPt - repeatColumnsWidthPt);
+	const availableHeightPt = Math.max(0, pageContentHeightPt - gutter.heightPt - repeatRowsHeightPt);
+	const scale = resolveScale(printSettings, availableWidthPt, availableHeightPt, bandableColumnIndices.reduce((sum, i) => sum + (columnSizeByIndex.get(i) ?? 0), 0), bandableRowIndices.reduce((sum, i) => sum + (rowSizeByIndex.get(i) ?? 0), 0));
+	const descaledAvailableWidthPt = availableWidthPt / scale;
+	const descaledAvailableHeightPt = availableHeightPt / scale;
+	const manualBreakColumns = new Set(printSettings.manualBreaks?.columns ?? []);
+	const manualBreakRows = new Set(printSettings.manualBreaks?.rows ?? []);
+	throwIfAborted(signal);
+	const columnBands = partitionIndices(bandableColumnIndices, (i) => columnSizeByIndex.get(i) ?? 0, descaledAvailableWidthPt, manualBreakColumns);
+	const rowBands = partitionIndices(bandableRowIndices, (i) => rowSizeByIndex.get(i) ?? 0, descaledAvailableHeightPt, manualBreakRows);
+	const cellsByRow = /* @__PURE__ */ new Map();
+	for (const cell of sheet.cells) {
+		let row = cellsByRow.get(cell.row);
+		if (row === void 0) {
+			row = /* @__PURE__ */ new Map();
+			cellsByRow.set(cell.row, row);
+		}
+		row.set(cell.column, cell);
+	}
+	const scaledSizeOf = (sizeByIndex) => (index) => (sizeByIndex.get(index) ?? 0) * scale;
+	const unscaledSizeOf = (sizeByIndex) => (index) => sizeByIndex.get(index) ?? 0;
+	const bandPairs = printSettings.pageOrder === "overThenDown" ? rowBands.flatMap((rowBand) => columnBands.map((columnBand) => ({
+		columnBand,
+		rowBand
+	}))) : columnBands.flatMap((columnBand) => rowBands.map((rowBand) => ({
+		columnBand,
+		rowBand
+	})));
+	for (const { columnBand, rowBand } of bandPairs) {
+		throwIfAborted(signal);
+		const columnAxis = buildPositionedAxis(repeatColumnIndices, unscaledSizeOf(columnSizeByIndex), columnBand, scaledSizeOf(columnSizeByIndex));
+		const rowAxis = buildPositionedAxis(repeatRowIndices, unscaledSizeOf(rowSizeByIndex), rowBand, scaledSizeOf(rowSizeByIndex));
+		const gridLeftXPt = margins.leftPt + gutter.widthPt;
+		const gridTopYDownPt = margins.topPt + gutter.heightPt;
+		const gridWidthPt = columnAxis.offsetsPt[columnAxis.offsetsPt.length - 1];
+		const gridHeightPt = rowAxis.offsetsPt[rowAxis.offsetsPt.length - 1];
+		const backgroundItems = [];
+		const borderItems = [];
+		const textItems = [];
+		for (const rowIndex of rowAxis.indices) {
+			const rowCells = cellsByRow.get(rowIndex);
+			if (rowCells === void 0) continue;
+			for (const [columnIndex, cell] of rowCells) {
+				throwIfAborted(signal);
+				if (!columnAxis.positionByIndex.has(columnIndex) || hiddenColumnIndices.has(columnIndex) || hiddenRowIndices.has(cell.row)) continue;
+				const cellFrame = resolveCellFrame(cell, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt);
+				if (cellFrame === void 0) continue;
+				stampFrame(cell, out.length, flipY(cellFrame, pageSize.heightPt));
+				renderCellBackground(cell, cellFrame, pageSize.heightPt, backgroundItems);
+				if (cell.borders !== void 0) pushCellBorderLines(cell.borders, cellFrame, pageSize.heightPt, cell.sourcePath, borderItems);
+				renderCellText(cell, cellFrame, out.length, rowCells, columnAxis, pageSize.heightPt, measurer, textItems);
+			}
+		}
+		const items = [...backgroundItems];
+		if (printSettings.gridlines) renderGridlines(gridLeftXPt, gridTopYDownPt, gridWidthPt, gridHeightPt, columnAxis.offsetsPt, rowAxis.offsetsPt, pageSize.heightPt, items);
+		items.push(...borderItems);
+		if (printSettings.headers) renderHeaderLabels(gutter, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, measurer, items);
+		items.push(...textItems);
+		renderAnchoredFormulas(formulas, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, out.length, hiddenColumnIndices, hiddenRowIndices, formulasOut, mathMetricsAt);
+		renderAnchoredImages(sheet.images, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, out.length, hiddenColumnIndices, hiddenRowIndices, items, images);
+		out.push({
+			widthPt: pageSize.widthPt,
+			heightPt: pageSize.heightPt,
+			items
+		});
+	}
+}
+function convertSpreadsheetToLayout(doc, options) {
+	const pages = [];
+	const formulas = [];
+	const images = {};
+	for (const sheet of doc.sheets) convertSheetToPages(sheet, options.measurer, options.signal, pages, formulas, images, options.mathMetricsAt);
+	return {
+		document: layoutDocumentOf(doc.metadata, pages, images),
+		formulas,
+		pages: packagePagesOf(pages)
+	};
+}
+//#endregion
+export { resolveAnchoredFormula as C, verticalLineTopYDownPt as E, renderHeaderLabels as S, truncateFragmentsToWidth as T, renderAnchoredFormulas as _, HEADER_LABEL_PADDING_PT as a, renderCellText as b, NUMERIC_OVERFLOW_TEXT as c, axisSpanSizePt as d, buildPositionedAxis as f, isNumericLikeValue as g, isCellVisuallyEmpty as h, HEADER_LABEL_COLOR as i, convertSpreadsheetToLayout as l, defaultAlignmentForValue as m, GRIDLINE_COLOR as n, HEADER_LABEL_SIZE_PT as o, cellStyledRuns as p, GRIDLINE_WIDTH_PT as r, NOMINAL_CELL_TEXT_SIZE_PT as s, CELL_TEXT_PADDING_PT as t, anchoredFormulas as u, renderAnchoredImages as v, resolveCellFrame as w, renderGridlines as x, renderCellBackground as y };

package/dist/svg/read-geometry.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_read = require("../read-CahCZMwG.cjs");
+exports.axisAlignedFrame = require_read.axisAlignedFrame;
+exports.boxOfPoints = require_read.boxOfPoints;
+exports.buildPathVector = require_read.buildPathVector;
+exports.ellipseSubpaths = require_read.ellipseSubpaths;
+exports.resolvePaint = require_read.resolvePaint;
+exports.resolveStroke = require_read.resolveStroke;
+exports.roundedRectSubpaths = require_read.roundedRectSubpaths;
+exports.similarityFrame = require_read.similarityFrame;

package/dist/svg/read-geometry.d.cts

@@ -0,0 +1,24 @@
+import { PaintState, ReaderState } from "./read.cjs";
+import { ParsedPathSubpath } from "./path.cjs";
+import { AffineMatrix } from "./transform.cjs";
+import { Box, Color, ContentStroke, ContentVector } from "document-schema.js";
+//#region src/svg/read-geometry.d.ts
+declare function resolveStroke(state: ReaderState, paint: PaintState, ctm: AffineMatrix): ContentStroke | undefined;
+declare function resolvePaint(state: ReaderState, paint: PaintState, ctm: AffineMatrix): {
+  readonly fill?: Color;
+  readonly stroke?: ContentStroke;
+};
+declare function boxOfPoints(points: readonly {
+  readonly x: number;
+  readonly y: number;
+}[]): Box;
+declare function axisAlignedFrame(ctm: AffineMatrix, x: number, y: number, width: number, height: number): Box;
+declare function similarityFrame(ctm: AffineMatrix, x: number, y: number, width: number, height: number): Box;
+declare function buildPathVector(state: ReaderState, subpaths: readonly ParsedPathSubpath[], ctm: AffineMatrix, paint: {
+  readonly fill?: Color;
+  readonly stroke?: ContentStroke;
+}, fillRule: "evenodd" | undefined): ContentVector | undefined;
+declare function roundedRectSubpaths(x: number, y: number, width: number, height: number, rx: number, ry: number): ParsedPathSubpath[];
+declare function ellipseSubpaths(cx: number, cy: number, rx: number, ry: number): ParsedPathSubpath[];
+//#endregion
+export { axisAlignedFrame, boxOfPoints, buildPathVector, ellipseSubpaths, resolvePaint, resolveStroke, roundedRectSubpaths, similarityFrame };

package/dist/svg/read-geometry.d.ts

@@ -0,0 +1,24 @@
+import { PaintState, ReaderState } from "./read.js";
+import { ParsedPathSubpath } from "./path.js";
+import { AffineMatrix } from "./transform.js";
+import { Box, Color, ContentStroke, ContentVector } from "document-schema.js";
+//#region src/svg/read-geometry.d.ts
+declare function resolveStroke(state: ReaderState, paint: PaintState, ctm: AffineMatrix): ContentStroke | undefined;
+declare function resolvePaint(state: ReaderState, paint: PaintState, ctm: AffineMatrix): {
+  readonly fill?: Color;
+  readonly stroke?: ContentStroke;
+};
+declare function boxOfPoints(points: readonly {
+  readonly x: number;
+  readonly y: number;
+}[]): Box;
+declare function axisAlignedFrame(ctm: AffineMatrix, x: number, y: number, width: number, height: number): Box;
+declare function similarityFrame(ctm: AffineMatrix, x: number, y: number, width: number, height: number): Box;
+declare function buildPathVector(state: ReaderState, subpaths: readonly ParsedPathSubpath[], ctm: AffineMatrix, paint: {
+  readonly fill?: Color;
+  readonly stroke?: ContentStroke;
+}, fillRule: "evenodd" | undefined): ContentVector | undefined;
+declare function roundedRectSubpaths(x: number, y: number, width: number, height: number, rx: number, ry: number): ParsedPathSubpath[];
+declare function ellipseSubpaths(cx: number, cy: number, rx: number, ry: number): ParsedPathSubpath[];
+//#endregion
+export { axisAlignedFrame, boxOfPoints, buildPathVector, ellipseSubpaths, resolvePaint, resolveStroke, roundedRectSubpaths, similarityFrame };

package/dist/svg/read-geometry.js

@@ -0,0 +1,2 @@
+import { c as buildPathVector, d as resolveStroke, f as roundedRectSubpaths, l as ellipseSubpaths, o as axisAlignedFrame, p as similarityFrame, s as boxOfPoints, u as resolvePaint } from "../read-BSH--XB4.js";
+export { axisAlignedFrame, boxOfPoints, buildPathVector, ellipseSubpaths, resolvePaint, resolveStroke, roundedRectSubpaths, similarityFrame };