odf.js 6.3.0 → 6.4.1

package/dist/typed/ods/write.cjs

@@ -0,0 +1,579 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_media_type = require("../../media-type.cjs");
+const require_xml_fragment = require("../../xml/fragment.cjs");
+const require_xml_entities = require("../../xml/entities.cjs");
+const require_manifest = require("../../manifest.cjs");
+const require_typed_shared_units = require("../shared/units.cjs");
+const require_typed_shared_color = require("../shared/color.cjs");
+const require_styles_registry = require("../../styles/registry.cjs");
+const require_typed_shared_a1 = require("../shared/a1.cjs");
+const require_typed_shared_metadata = require("../shared/metadata.cjs");
+const require_typed_shared_paragraph = require("../shared/paragraph.cjs");
+const require_typed_shared_table = require("../shared/table.cjs");
+const require_package_io_scaffold = require("../../package-io/scaffold.cjs");
+const require_typed_shared_image = require("../shared/image.cjs");
+require("../../embedded-Bxyss_ck.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/typed/ods/write.ts
+const CONTENT_PART = "content.xml";
+const STYLES_PART = "styles.xml";
+const PICTURES_DIRECTORY = "Pictures";
+function unsupported(what, where) {
+	return /* @__PURE__ */ new Error(`writeOds: ${where} carries ${what}, which this writer does not write yet -- refusing rather than producing an .ods that silently lost it. See ExaDev/documents.js for the tracked follow-up covering embedded objects, data validation, and conditional formatting.`);
+}
+function formatOdfDuration(isoTime) {
+	const match = /^(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/.exec(isoTime);
+	if (match === null) throw new Error(`writeOdsContent: a "time" cell's value "${isoTime}" is not the canonical ISO 8601 HH:MM:SS wall-clock spelling document-schema.js's ContentCellValueSchema documents -- refusing to guess at an ODF xsd:duration equivalent`);
+	const [, hours, minutes, seconds, fraction] = match;
+	const secondsLiteral = fraction === void 0 ? String(Number(seconds)) : `${Number(seconds)}.${fraction}`;
+	return `PT${Number(hours)}H${Number(minutes)}M${secondsLiteral}S`;
+}
+function formatCellNumberLiteral(value) {
+	return value.exactValue ?? String(value.value);
+}
+function unsupportedCellValueKind(kind) {
+	return /* @__PURE__ */ new Error(`writeOdsContent: a cell carries a "${kind}" value, which this writer does not write -- readOdsContent's own reader can never produce this kind for an .ods document (see its own doc comment), so there is no genuine inverse to verify a write against; refusing rather than writing a document that would read back reporting a different value kind than it was given.`);
+}
+function writeCellValueAttributes(value) {
+	switch (value.kind) {
+		case "number": return {
+			"office:value-type": "float",
+			"office:value": formatCellNumberLiteral(value)
+		};
+		case "percentage": return {
+			"office:value-type": "percentage",
+			"office:value": formatCellNumberLiteral(value)
+		};
+		case "currency": {
+			const attributes = {
+				"office:value-type": "currency",
+				"office:value": formatCellNumberLiteral(value)
+			};
+			if (value.currency !== void 0) attributes["office:currency"] = require_xml_entities.encodeXmlText(value.currency);
+			return attributes;
+		}
+		case "boolean": return {
+			"office:value-type": "boolean",
+			"office:boolean-value": value.value ? "true" : "false"
+		};
+		case "date": return {
+			"office:value-type": "date",
+			"office:date-value": require_xml_entities.encodeXmlText(value.value)
+		};
+		case "time": return {
+			"office:value-type": "time",
+			"office:time-value": require_xml_entities.encodeXmlText(formatOdfDuration(value.value))
+		};
+		case "string": return {
+			"office:value-type": "string",
+			"office:string-value": require_xml_entities.encodeXmlText(value.value)
+		};
+		case "empty": return {};
+		case "dateTime":
+		case "error": throw unsupportedCellValueKind(value.kind);
+	}
+}
+function isBareNewlineRun(run) {
+	return run.text === "\n" && run.bold === void 0 && run.italic === void 0 && run.underline === void 0 && run.strike === void 0 && run.fontFamily === void 0 && run.sizePt === void 0 && run.color === void 0 && run.hyperlink === void 0;
+}
+function cellSourceRuns(cell) {
+	if (cell.runs !== void 0) return [...cell.runs];
+	return cell.displayText.length > 0 ? [{ text: cell.displayText }] : [];
+}
+function planCellTextGroups(cell) {
+	const runs = cellSourceRuns(cell);
+	const groups = [[]];
+	for (const run of runs) if (isBareNewlineRun(run)) groups.push([]);
+	else groups[groups.length - 1].push(run);
+	return groups;
+}
+function writeCellParagraphs(cell, registry) {
+	return planCellTextGroups(cell).map((group) => require_typed_shared_paragraph.writeOdfParagraph({
+		kind: "paragraph",
+		runs: group
+	}, registry));
+}
+function sheetCellStyle(cell, registry) {
+	const cellProperties = {};
+	if (cell.background !== void 0) cellProperties["fo:background-color"] = require_typed_shared_color.formatOdfColor(cell.background);
+	if (cell.borders !== void 0) for (const edge of require_typed_shared_table.BORDER_EDGE_KEYS) {
+		const border = cell.borders[edge];
+		if (border !== void 0) cellProperties[require_typed_shared_table.BORDER_EDGE_ATTRS[edge]] = require_typed_shared_table.formatBorderEdge(border);
+	}
+	if (cell.verticalAlignment !== void 0) cellProperties["style:vertical-align"] = cell.verticalAlignment;
+	const propertyElements = [];
+	if (Object.keys(cellProperties).length > 0) propertyElements.push(require_xml_fragment.el("style:table-cell-properties", cellProperties));
+	if (cell.alignment !== void 0) propertyElements.push(require_xml_fragment.el("style:paragraph-properties", { "fo:text-align": cell.alignment }));
+	if (propertyElements.length === 0) return;
+	return registry.intern({
+		properties: {},
+		family: "table-cell",
+		propertyElements
+	});
+}
+function sheetColumnStyle(widthPt, manualBreak, registry) {
+	const properties = {};
+	if (widthPt !== void 0) properties["style:column-width"] = require_typed_shared_units.formatOdfLength(widthPt);
+	if (manualBreak) properties["fo:break-before"] = "page";
+	if (Object.keys(properties).length === 0) return;
+	return registry.intern({
+		properties: {},
+		family: "table-column",
+		propertyElements: [require_xml_fragment.el("style:table-column-properties", properties)]
+	});
+}
+function sheetRowStyle(heightPt, manualBreak, registry) {
+	const properties = {};
+	if (heightPt !== void 0) properties["style:row-height"] = require_typed_shared_units.formatOdfLength(heightPt);
+	if (manualBreak) properties["fo:break-before"] = "page";
+	if (Object.keys(properties).length === 0) return;
+	return registry.intern({
+		properties: {},
+		family: "table-row",
+		propertyElements: [require_xml_fragment.el("style:table-row-properties", properties)]
+	});
+}
+function computeUsedRange(sheet) {
+	let maxRow;
+	let maxColumn;
+	const bumpRow = (row) => {
+		if (maxRow === void 0 || row > maxRow) maxRow = row;
+	};
+	const bumpColumn = (column) => {
+		if (maxColumn === void 0 || column > maxColumn) maxColumn = column;
+	};
+	for (const cell of sheet.cells) {
+		bumpRow(cell.row + (cell.rowSpan ?? 1) - 1);
+		bumpColumn(cell.column + (cell.colSpan ?? 1) - 1);
+	}
+	for (const column of sheet.columns) bumpColumn(column.index);
+	for (const row of sheet.rows) bumpRow(row.index);
+	for (const image of sheet.images) {
+		bumpRow(image.anchorRow);
+		bumpColumn(image.anchorColumn);
+	}
+	const printSettings = sheet.printSettings;
+	if (printSettings.repeatColumns !== void 0) bumpColumn(printSettings.repeatColumns.end);
+	if (printSettings.repeatRows !== void 0) bumpRow(printSettings.repeatRows.end);
+	if (printSettings.manualBreaks !== void 0) {
+		for (const row of printSettings.manualBreaks.rows) bumpRow(row);
+		for (const column of printSettings.manualBreaks.columns) bumpColumn(column);
+	}
+	if (printSettings.printRange !== void 0) {
+		bumpRow(printSettings.printRange.endRow);
+		bumpColumn(printSettings.printRange.endColumn);
+	}
+	return {
+		maxRow,
+		maxColumn
+	};
+}
+function coverageKey(row, column) {
+	return `${row},${column}`;
+}
+function computeCoveredPositions(cells) {
+	const covered = /* @__PURE__ */ new Set();
+	for (const cell of cells) {
+		const rowSpan = cell.rowSpan ?? 1;
+		const colSpan = cell.colSpan ?? 1;
+		for (let row = cell.row; row < cell.row + rowSpan; row += 1) for (let column = cell.column; column < cell.column + colSpan; column += 1) if (row !== cell.row || column !== cell.column) covered.add(coverageKey(row, column));
+	}
+	return covered;
+}
+function groupImagesByPosition(images) {
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const image of images) {
+		const key = coverageKey(image.anchorRow, image.anchorColumn);
+		const existing = byPosition.get(key);
+		if (existing === void 0) byPosition.set(key, [image]);
+		else existing.push(image);
+	}
+	return byPosition;
+}
+function writeSheetImageFrame(image, state) {
+	const extension = require_typed_shared_image.imageExtension(image.format);
+	const path = `${PICTURES_DIRECTORY}/image${state.nextImage}.${extension}`;
+	state.nextImage += 1;
+	state.pkg.parts[path] = {
+		kind: "binary",
+		base64: image.base64
+	};
+	const children = [require_xml_fragment.el("draw:image", {
+		"xlink:href": require_xml_entities.encodeXmlText(path),
+		"xlink:type": "simple",
+		"xlink:show": "embed",
+		"xlink:actuate": "onLoad"
+	})];
+	if (image.altText !== void 0) children.push(require_xml_fragment.el("svg:title", {}, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(image.altText))]));
+	return require_xml_fragment.el("draw:frame", {
+		"draw:z-index": String(state.nextZIndex++),
+		"svg:x": require_typed_shared_units.formatOdfLength(image.offsetXPt),
+		"svg:y": require_typed_shared_units.formatOdfLength(image.offsetYPt),
+		"svg:width": require_typed_shared_units.formatOdfLength(image.widthPt),
+		"svg:height": require_typed_shared_units.formatOdfLength(image.heightPt)
+	}, children);
+}
+function sheetPageLayoutElement(name, printSettings) {
+	const properties = {
+		"fo:page-width": require_typed_shared_units.formatOdfLength(printSettings.pageSize.widthPt),
+		"fo:page-height": require_typed_shared_units.formatOdfLength(printSettings.pageSize.heightPt),
+		"fo:margin-top": require_typed_shared_units.formatOdfLength(printSettings.margins.topPt),
+		"fo:margin-right": require_typed_shared_units.formatOdfLength(printSettings.margins.rightPt),
+		"fo:margin-bottom": require_typed_shared_units.formatOdfLength(printSettings.margins.bottomPt),
+		"fo:margin-left": require_typed_shared_units.formatOdfLength(printSettings.margins.leftPt),
+		"style:print-page-order": printSettings.pageOrder === "overThenDown" ? "ltr" : "ttb"
+	};
+	const printTokens = [];
+	if (printSettings.gridlines) printTokens.push("grid");
+	if (printSettings.headers) printTokens.push("headers");
+	if (printTokens.length > 0) properties["style:print"] = printTokens.join(" ");
+	if (printSettings.scalePercent !== void 0) properties["style:scale-to"] = `${printSettings.scalePercent}%`;
+	if (printSettings.fitToPages !== void 0) {
+		properties["style:scale-to-X"] = String(printSettings.fitToPages.width);
+		properties["style:scale-to-Y"] = String(printSettings.fitToPages.height);
+	}
+	return require_xml_fragment.el("style:page-layout", { "style:name": require_xml_entities.encodeXmlText(name) }, [require_xml_fragment.el("style:page-layout-properties", properties)]);
+}
+function formatPrintRange(range, sheetName) {
+	const start = require_typed_shared_a1.cellReference(range.startColumn, range.startRow);
+	const end = require_typed_shared_a1.cellReference(range.endColumn, range.endRow);
+	const qualifiedSheet = require_xml_entities.encodeXmlText(sheetName);
+	return `${qualifiedSheet}.${start}:${qualifiedSheet}.${end}`;
+}
+function wrapHeaderRange(elements, range, wrapperTag) {
+	if (range === void 0) return [...elements];
+	const before = elements.slice(0, range.start);
+	const wrapped = elements.slice(range.start, range.end + 1);
+	const after = elements.slice(range.end + 1);
+	return [
+		...before,
+		require_xml_fragment.el(wrapperTag, {}, wrapped),
+		...after
+	];
+}
+function writeColumns(sheet, state, manualBreakColumns, maxColumn) {
+	if (maxColumn === void 0) return [];
+	const byIndex = new Map(sheet.columns.map((column) => [column.index, column]));
+	const elements = [];
+	for (let index = 0; index <= maxColumn; index += 1) {
+		const declared = byIndex.get(index);
+		const styleName = sheetColumnStyle(declared?.widthPt, manualBreakColumns.has(index), state.registry);
+		const attributes = {};
+		if (styleName !== void 0) attributes["table:style-name"] = require_xml_entities.encodeXmlText(styleName);
+		if (declared?.hidden === true) attributes["table:visibility"] = "collapse";
+		elements.push(require_xml_fragment.el("table:table-column", attributes));
+	}
+	return wrapHeaderRange(elements, sheet.printSettings.repeatColumns, "table:table-header-columns");
+}
+function writeRowCells(row, maxColumn, cellByPosition, imagesByPosition, covered, state) {
+	if (maxColumn === void 0) return [];
+	const nodes = [];
+	let column = 0;
+	while (column <= maxColumn) {
+		const key = coverageKey(row, column);
+		if (covered.has(key)) {
+			let end = column;
+			while (end + 1 <= maxColumn && covered.has(coverageKey(row, end + 1)) && !cellByPosition.has(coverageKey(row, end + 1))) end += 1;
+			const count = end - column + 1;
+			nodes.push(require_xml_fragment.el("table:covered-table-cell", count > 1 ? { "table:number-columns-repeated": String(count) } : {}));
+			column = end + 1;
+			continue;
+		}
+		const cell = cellByPosition.get(key);
+		const images = imagesByPosition.get(key);
+		if (cell !== void 0 || images !== void 0 && images.length > 0) {
+			const attributes = {};
+			if (cell !== void 0) {
+				Object.assign(attributes, writeCellValueAttributes(cell.value));
+				if (cell.formula !== void 0) attributes["table:formula"] = require_xml_entities.encodeXmlText(cell.formula);
+				if (cell.colSpan !== void 0) attributes["table:number-columns-spanned"] = String(cell.colSpan);
+				if (cell.rowSpan !== void 0) attributes["table:number-rows-spanned"] = String(cell.rowSpan);
+				const styleName = sheetCellStyle(cell, state.registry);
+				if (styleName !== void 0) attributes["table:style-name"] = require_xml_entities.encodeXmlText(styleName);
+			}
+			const children = cell === void 0 ? [] : writeCellParagraphs(cell, state.registry);
+			for (const image of images ?? []) children.push(writeSheetImageFrame(image, state));
+			nodes.push(require_xml_fragment.el("table:table-cell", attributes, children));
+			column += 1;
+			continue;
+		}
+		let end = column;
+		while (end + 1 <= maxColumn && !covered.has(coverageKey(row, end + 1)) && !cellByPosition.has(coverageKey(row, end + 1)) && (imagesByPosition.get(coverageKey(row, end + 1))?.length ?? 0) === 0) end += 1;
+		const count = end - column + 1;
+		nodes.push(require_xml_fragment.el("table:table-cell", count > 1 ? { "table:number-columns-repeated": String(count) } : {}));
+		column = end + 1;
+	}
+	return nodes;
+}
+function writeRows(sheet, state, manualBreakRows, maxRow, maxColumn) {
+	if (maxRow === void 0) return [];
+	const rowByIndex = new Map(sheet.rows.map((row) => [row.index, row]));
+	const cellByPosition = new Map(sheet.cells.map((cell) => [coverageKey(cell.row, cell.column), cell]));
+	const imagesByPosition = groupImagesByPosition(sheet.images);
+	const covered = computeCoveredPositions(sheet.cells);
+	const elements = [];
+	for (let row = 0; row <= maxRow; row += 1) {
+		const declared = rowByIndex.get(row);
+		const styleName = sheetRowStyle(declared?.heightPt, manualBreakRows.has(row), state.registry);
+		const attributes = {};
+		if (styleName !== void 0) attributes["table:style-name"] = require_xml_entities.encodeXmlText(styleName);
+		if (declared?.hidden === true) attributes["table:visibility"] = "collapse";
+		const cells = writeRowCells(row, maxColumn, cellByPosition, imagesByPosition, covered, state);
+		elements.push(require_xml_fragment.el("table:table-row", attributes, cells));
+	}
+	return wrapHeaderRange(elements, sheet.printSettings.repeatRows, "table:table-header-rows");
+}
+function writeSheet(sheet, state) {
+	if (sheet.embeddedObjects !== void 0 && sheet.embeddedObjects.length > 0) throw unsupported(`an embedded object ("${sheet.embeddedObjects[0].objectKind}")`, `sheet "${sheet.name}"`);
+	if (sheet.dataValidations !== void 0 && sheet.dataValidations.length > 0) throw unsupported("a data-validation rule", `sheet "${sheet.name}"`);
+	if (sheet.conditionalFormats !== void 0 && sheet.conditionalFormats.length > 0) throw unsupported("a conditional-formatting rule", `sheet "${sheet.name}"`);
+	const { maxRow, maxColumn } = computeUsedRange(sheet);
+	const manualBreakRows = new Set(sheet.printSettings.manualBreaks?.rows ?? []);
+	const manualBreakColumns = new Set(sheet.printSettings.manualBreaks?.columns ?? []);
+	const ordinal = state.nextSheetStyle;
+	state.nextSheetStyle += 1;
+	const masterPageName = `SheetMP${ordinal}`;
+	const pageLayoutName = `SheetPL${ordinal}`;
+	const tableStyleName = `SheetTable${ordinal}`;
+	state.stylesAutomaticStyles.children.push(sheetPageLayoutElement(pageLayoutName, sheet.printSettings));
+	state.masterStyles.children.push(require_xml_fragment.el("style:master-page", {
+		"style:name": require_xml_entities.encodeXmlText(masterPageName),
+		"style:page-layout-name": require_xml_entities.encodeXmlText(pageLayoutName)
+	}));
+	state.contentAutomaticStyles.children.push(require_xml_fragment.el("style:style", {
+		"style:name": require_xml_entities.encodeXmlText(tableStyleName),
+		"style:family": "table",
+		"style:master-page-name": require_xml_entities.encodeXmlText(masterPageName)
+	}, [require_xml_fragment.el("style:table-properties", { "table:display": "true" })]));
+	const columns = writeColumns(sheet, state, manualBreakColumns, maxColumn);
+	const rows = writeRows(sheet, state, manualBreakRows, maxRow, maxColumn);
+	const tableAttributes = {
+		"table:name": require_xml_entities.encodeXmlText(sheet.name),
+		"table:style-name": require_xml_entities.encodeXmlText(tableStyleName)
+	};
+	if (sheet.printSettings.printRange !== void 0) tableAttributes["table:print-ranges"] = require_xml_entities.encodeXmlText(formatPrintRange(sheet.printSettings.printRange, sheet.name));
+	return require_xml_fragment.el("table:table", tableAttributes, [...columns, ...rows]);
+}
+function canonicalColor(color) {
+	return (0, document_schema_js.rgbHexToColor)((0, document_schema_js.colorToRgbHex)(color));
+}
+function canonicalRun(run) {
+	const canonical = { text: run.text };
+	if (run.bold !== void 0) canonical.bold = run.bold;
+	if (run.italic !== void 0) canonical.italic = run.italic;
+	if (run.underline !== void 0) canonical.underline = run.underline;
+	if (run.strike !== void 0) canonical.strike = run.strike;
+	if (run.fontFamily !== void 0) canonical.fontFamily = run.fontFamily;
+	if (run.sizePt !== void 0) canonical.sizePt = run.sizePt;
+	if (run.color !== void 0) canonical.color = canonicalColor(run.color);
+	if (run.hyperlink !== void 0) canonical.hyperlink = run.hyperlink;
+	return canonical;
+}
+function canonicalCellRuns(cell) {
+	const groups = planCellTextGroups(cell).map((group) => require_typed_shared_paragraph.segmentOdfParagraphRuns(group).map(canonicalRun));
+	const combined = [];
+	groups.forEach((group, index) => {
+		if (index > 0) combined.push({ text: "\n" });
+		combined.push(...group);
+	});
+	return combined;
+}
+function canonicalCellValue(value) {
+	switch (value.kind) {
+		case "number": return {
+			kind: "number",
+			value: Number(formatCellNumberLiteral(value))
+		};
+		case "percentage": return {
+			kind: "percentage",
+			value: Number(formatCellNumberLiteral(value))
+		};
+		case "currency": {
+			const canonical = {
+				kind: "currency",
+				value: Number(formatCellNumberLiteral(value))
+			};
+			if (value.currency !== void 0) canonical.currency = value.currency;
+			return canonical;
+		}
+		case "boolean": return {
+			kind: "boolean",
+			value: value.value
+		};
+		case "date": return {
+			kind: "date",
+			value: value.value
+		};
+		case "time": return {
+			kind: "time",
+			value: formatOdfDuration(value.value)
+		};
+		case "string": return {
+			kind: "string",
+			value: value.value
+		};
+		case "empty": return { kind: "empty" };
+		case "dateTime":
+		case "error": throw unsupportedCellValueKind(value.kind);
+	}
+}
+function canonicalCell(cell) {
+	const runs = canonicalCellRuns(cell);
+	const displayText = runs.map((run) => run.text).join("");
+	if (cell.value.kind === "empty" && cell.formula === void 0 && displayText.length === 0) return;
+	const canonical = {
+		row: cell.row,
+		column: cell.column,
+		value: canonicalCellValue(cell.value),
+		displayText
+	};
+	if (cell.formula !== void 0) canonical.formula = cell.formula;
+	if (runs.length > 0) canonical.runs = runs;
+	if (cell.colSpan !== void 0) canonical.colSpan = cell.colSpan;
+	if (cell.rowSpan !== void 0) canonical.rowSpan = cell.rowSpan;
+	if (cell.background !== void 0) canonical.background = canonicalColor(cell.background);
+	if (cell.borders !== void 0) {
+		const borders = {};
+		for (const edge of require_typed_shared_table.BORDER_EDGE_KEYS) {
+			const border = cell.borders[edge];
+			if (border !== void 0) borders[edge] = {
+				color: canonicalColor(border.color),
+				widthPt: border.widthPt,
+				style: border.style ?? "solid"
+			};
+		}
+		canonical.borders = borders;
+	}
+	if (cell.alignment !== void 0) canonical.alignment = cell.alignment;
+	if (cell.verticalAlignment !== void 0) canonical.verticalAlignment = cell.verticalAlignment;
+	return canonical;
+}
+function canonicalCells(sheet, maxRow, maxColumn) {
+	if (maxRow === void 0 || maxColumn === void 0) return [];
+	const cellByPosition = new Map(sheet.cells.map((cell) => [coverageKey(cell.row, cell.column), cell]));
+	const covered = computeCoveredPositions(sheet.cells);
+	const result = [];
+	for (let row = 0; row <= maxRow; row += 1) for (let column = 0; column <= maxColumn; column += 1) {
+		const key = coverageKey(row, column);
+		if (covered.has(key)) continue;
+		const cell = cellByPosition.get(key);
+		if (cell === void 0) continue;
+		const canonical = canonicalCell(cell);
+		if (canonical !== void 0) result.push(canonical);
+	}
+	return result;
+}
+function canonicalColumns(sheet, maxColumn) {
+	if (maxColumn === void 0) return [];
+	const byIndex = new Map(sheet.columns.map((column) => [column.index, column]));
+	const result = [];
+	for (let index = 0; index <= maxColumn; index += 1) {
+		const declared = byIndex.get(index);
+		result.push({
+			index,
+			widthPt: declared?.widthPt ?? 64,
+			hidden: declared?.hidden === true ? true : void 0
+		});
+	}
+	return result;
+}
+function canonicalRows(sheet, maxRow) {
+	if (maxRow === void 0) return [];
+	const byIndex = new Map(sheet.rows.map((row) => [row.index, row]));
+	const result = [];
+	for (let index = 0; index <= maxRow; index += 1) {
+		const declared = byIndex.get(index);
+		result.push({
+			index,
+			heightPt: declared?.heightPt ?? 15,
+			hidden: declared?.hidden === true ? true : void 0
+		});
+	}
+	return result;
+}
+function canonicalSheetImage(image) {
+	const canonical = {
+		kind: "image",
+		format: image.format,
+		base64: image.base64,
+		widthPt: image.widthPt,
+		heightPt: image.heightPt,
+		anchorRow: image.anchorRow,
+		anchorColumn: image.anchorColumn,
+		offsetXPt: image.offsetXPt,
+		offsetYPt: image.offsetYPt
+	};
+	if (image.altText !== void 0) canonical.altText = image.altText;
+	return canonical;
+}
+function canonicalImages(sheet) {
+	return sheet.images.map((image, originalIndex) => ({
+		image,
+		originalIndex
+	})).sort((a, b) => a.image.anchorRow - b.image.anchorRow || a.image.anchorColumn - b.image.anchorColumn || a.originalIndex - b.originalIndex).map(({ image }) => canonicalSheetImage(image));
+}
+function canonicalPrintSettings(printSettings) {
+	const canonical = {
+		pageSize: printSettings.pageSize,
+		margins: printSettings.margins,
+		gridlines: printSettings.gridlines,
+		headers: printSettings.headers,
+		pageOrder: printSettings.pageOrder
+	};
+	if (printSettings.printRange !== void 0) canonical.printRange = printSettings.printRange;
+	if (printSettings.scalePercent !== void 0) canonical.scalePercent = printSettings.scalePercent;
+	if (printSettings.fitToPages !== void 0) canonical.fitToPages = printSettings.fitToPages;
+	if (printSettings.repeatRows !== void 0) canonical.repeatRows = printSettings.repeatRows;
+	if (printSettings.repeatColumns !== void 0) canonical.repeatColumns = printSettings.repeatColumns;
+	if (printSettings.manualBreaks !== void 0) canonical.manualBreaks = printSettings.manualBreaks;
+	return canonical;
+}
+function canonicalSheet(sheet) {
+	const { maxRow, maxColumn } = computeUsedRange(sheet);
+	return {
+		name: sheet.name,
+		cells: canonicalCells(sheet, maxRow, maxColumn),
+		columns: canonicalColumns(sheet, maxColumn),
+		rows: canonicalRows(sheet, maxRow),
+		images: canonicalImages(sheet),
+		printSettings: canonicalPrintSettings(sheet.printSettings)
+	};
+}
+function normaliseOdsContent(document) {
+	if (document.kind !== "spreadsheet") throw new Error(`normaliseOdsContent: expected a 'spreadsheet' document, got '${document.kind}'`);
+	return {
+		kind: "spreadsheet",
+		metadata: document.metadata,
+		sheets: document.sheets.map(canonicalSheet)
+	};
+}
+function writeOdsContent(document, options = {}) {
+	if (document.kind !== "spreadsheet") throw new Error(`writeOdsContent: expected a 'spreadsheet' document, got '${document.kind}' -- odf.js writes .ods from the spreadsheet arm only`);
+	const version = options.version ?? "1.3";
+	const spreadsheetElement = require_xml_fragment.el("office:spreadsheet");
+	const pkg = require_package_io_scaffold.createOdfPackage(options.template ? require_media_type.ODF_MEDIA_TYPES.ots : require_media_type.ODF_MEDIA_TYPES.ods, spreadsheetElement, version);
+	const state = {
+		pkg,
+		registry: require_styles_registry.StyleRegistry.forPart(pkg, CONTENT_PART, { otherPart: {
+			pkg,
+			partPath: STYLES_PART
+		} }),
+		contentAutomaticStyles: require_package_io_scaffold.odfPartContainer(pkg, CONTENT_PART, "office:automatic-styles"),
+		stylesAutomaticStyles: require_package_io_scaffold.odfPartContainer(pkg, STYLES_PART, "office:automatic-styles"),
+		masterStyles: require_package_io_scaffold.odfPartContainer(pkg, STYLES_PART, "office:master-styles"),
+		nextImage: 1,
+		nextZIndex: 0,
+		nextSheetStyle: 1
+	};
+	for (const sheet of document.sheets) spreadsheetElement.children.push(writeSheet(sheet, state));
+	require_typed_shared_metadata.writeOdfMetadata(pkg, document.metadata, version);
+	require_manifest.syncManifest(pkg, { version });
+	return pkg;
+}
+function writeOds(document, options = {}) {
+	return writeOdsContent((0, document_schema_js.flattenTree)(document), options);
+}
+//#endregion
+exports.normaliseOdsContent = normaliseOdsContent;
+exports.writeOds = writeOds;
+exports.writeOdsContent = writeOdsContent;

package/dist/typed/ods/write.d.cts

@@ -0,0 +1,2 @@
+import { i as writeOdsContent, n as normaliseOdsContent, r as writeOds, t as OdsWriteOptions } from "../../write-BuLQmwLD.cjs";
+export { OdsWriteOptions, normaliseOdsContent, writeOds, writeOdsContent };

package/dist/typed/ods/write.d.ts

@@ -0,0 +1,2 @@
+import { i as writeOdsContent, n as normaliseOdsContent, r as writeOds, t as OdsWriteOptions } from "../../write-DttX1rTC.js";
+export { OdsWriteOptions, normaliseOdsContent, writeOds, writeOdsContent };