odf.js 5.1.2 → 5.2.0

package/dist/embedded-BBJoUl86.js

@@ -0,0 +1,777 @@
+import { parseOdfLength } from "./typed/shared/units.js";
+import { attrValue, childrenWithTag, elementsWithTag, findChildElement, rootElement } from "./xml/query.js";
+import { TableCursor, parseCellReference as parseCellReference$1 } from "./typed/shared/a1.js";
+import { parseMargins, parsePageSize } from "./typed/shared/geometry.js";
+import { findStyleElement, resolveStyleElementChain } from "./typed/shared/cascade.js";
+import { readOdfMetadata } from "./typed/shared/metadata.js";
+import { mintOdfListNumId, readOdfListParagraphs } from "./typed/shared/list.js";
+import { collectOdfDataStyleDefinitions, collectOdfFieldMasterDefinitions, collectOdfFontFaceDefinitions, collectOdfNamedExpressions, collectOdfProvenanceRegions, insertOdfConstructMarkers, isOdfIndexWrapper, odfDivisionDescriptor, odfIndexControlDescriptor, odfMarkerHalfEventIndex, odfResidue, resolveOdfMarkerEvents } from "./typed/shared/constructs.js";
+import { readOdfParagraph } from "./typed/shared/paragraph.js";
+import { readCellStyleDecoration, readOdfTable } from "./typed/shared/table.js";
+import { parseOdfTransform } from "./typed/shared/transform.js";
+import { resolvePageLayoutProperties } from "./typed/shared/masterpage.js";
+import { readDrawFrame } from "./typed/draw/shapes.js";
+import { findMathRoot, readOdfFormulaContent } from "./typed/formula/read.js";
+import { subDocumentPackage } from "./typed/odb/subdocument.js";
+import { readOdgContent } from "./typed/odg/read.js";
+import { readOdpContent } from "./typed/odp/read.js";
+import { readOdfFormControlConstructs } from "./typed/shared/forms.js";
+import { PAGE_SIZE_A4, assemblePackage } from "document-schema.js";
+//#region src/typed/ods/read.ts
+const CONTENT_PART$2 = "content.xml";
+function parseKnownOdfLength$1(value) {
+	const parsed = parseOdfLength(value);
+	if (parsed === void 0) throw new Error(`readOdsContent: internal error -- "${value}" is not a valid ODF length literal`);
+	return parsed;
+}
+const DEFAULT_MARGIN_PT$1 = parseKnownOdfLength$1("2cm");
+const DEFAULT_MARGINS$1 = {
+	topPt: DEFAULT_MARGIN_PT$1,
+	rightPt: DEFAULT_MARGIN_PT$1,
+	bottomPt: DEFAULT_MARGIN_PT$1,
+	leftPt: DEFAULT_MARGIN_PT$1
+};
+function readRepeatCount(element, attrName) {
+	const raw = attrValue(element, attrName);
+	if (raw === void 0) return 1;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : 1;
+}
+function isHidden(element) {
+	return attrValue(element, "table:visibility") === "collapse";
+}
+const DEFAULT_COLUMN_WIDTH_PT = 64;
+const DEFAULT_ROW_HEIGHT_PT = 15;
+function readColumnLayout(columnElement, pkg) {
+	const styleName = attrValue(columnElement, "table:style-name");
+	const styleElement = styleName === void 0 ? void 0 : findStyleElement(styleName, "table-column", pkg);
+	const properties = styleElement === void 0 ? void 0 : childrenWithTag(styleElement, "style:table-column-properties")[0];
+	const widthValue = properties === void 0 ? void 0 : attrValue(properties, "style:column-width");
+	return {
+		widthPt: widthValue === void 0 ? DEFAULT_COLUMN_WIDTH_PT : parseOdfLength(widthValue) ?? DEFAULT_COLUMN_WIDTH_PT,
+		manualBreak: (properties === void 0 ? void 0 : attrValue(properties, "fo:break-before")) === "page"
+	};
+}
+function readRowLayout(rowElement, pkg) {
+	const styleName = attrValue(rowElement, "table:style-name");
+	const styleElement = styleName === void 0 ? void 0 : findStyleElement(styleName, "table-row", pkg);
+	const properties = styleElement === void 0 ? void 0 : childrenWithTag(styleElement, "style:table-row-properties")[0];
+	const heightValue = properties === void 0 ? void 0 : attrValue(properties, "style:row-height");
+	return {
+		heightPt: heightValue === void 0 ? DEFAULT_ROW_HEIGHT_PT : parseOdfLength(heightValue) ?? DEFAULT_ROW_HEIGHT_PT,
+		manualBreak: (properties === void 0 ? void 0 : attrValue(properties, "fo:break-before")) === "page"
+	};
+}
+function readCellText(cellElement, pkg) {
+	const paragraphs = childrenWithTag(cellElement, "text:p");
+	const runs = [];
+	paragraphs.forEach((paragraph, index) => {
+		if (index > 0) runs.push({ text: "\n" });
+		runs.push(...readOdfParagraph(paragraph, pkg).runs);
+	});
+	return {
+		runs,
+		displayText: runs.map((run) => run.text).join("")
+	};
+}
+function readCellValue(cellElement, displayText) {
+	const valueType = attrValue(cellElement, "office:value-type");
+	const stringFallback = {
+		kind: "string",
+		value: displayText
+	};
+	switch (valueType) {
+		case "float": {
+			const value = parseRequiredNumber(attrValue(cellElement, "office:value"));
+			return value === void 0 ? stringFallback : {
+				kind: "number",
+				value
+			};
+		}
+		case "percentage": {
+			const value = parseRequiredNumber(attrValue(cellElement, "office:value"));
+			return value === void 0 ? stringFallback : {
+				kind: "percentage",
+				value
+			};
+		}
+		case "currency": {
+			const value = parseRequiredNumber(attrValue(cellElement, "office:value"));
+			if (value === void 0) return stringFallback;
+			const currency = attrValue(cellElement, "office:currency");
+			return currency === void 0 ? {
+				kind: "currency",
+				value
+			} : {
+				kind: "currency",
+				value,
+				currency
+			};
+		}
+		case "boolean": {
+			const raw = attrValue(cellElement, "office:boolean-value");
+			return raw === void 0 ? stringFallback : {
+				kind: "boolean",
+				value: raw === "true"
+			};
+		}
+		case "date": return {
+			kind: "date",
+			value: attrValue(cellElement, "office:date-value") ?? displayText
+		};
+		case "time": return {
+			kind: "time",
+			value: attrValue(cellElement, "office:time-value") ?? displayText
+		};
+		case "string": return {
+			kind: "string",
+			value: attrValue(cellElement, "office:string-value") ?? displayText
+		};
+		default: return { kind: "empty" };
+	}
+}
+function parseRequiredNumber(raw) {
+	if (raw === void 0) return;
+	const value = Number(raw);
+	return Number.isNaN(value) ? void 0 : value;
+}
+function parsePrintRanges(value) {
+	const first = value.split(" ").find((part) => part.length > 0);
+	if (first === void 0) return;
+	const separatorIndex = first.indexOf(":");
+	if (separatorIndex === -1) return;
+	const start = parseA1WithOptionalSheetPrefix(first.slice(0, separatorIndex));
+	const end = parseA1WithOptionalSheetPrefix(first.slice(separatorIndex + 1));
+	if (start === void 0 || end === void 0) return;
+	return {
+		startRow: start.row,
+		startColumn: start.column,
+		endRow: end.row,
+		endColumn: end.column
+	};
+}
+function parseA1WithOptionalSheetPrefix(cellPart) {
+	const dotIndex = cellPart.lastIndexOf(".");
+	const bareReference = dotIndex === -1 ? cellPart : cellPart.slice(dotIndex + 1);
+	return parseCellReference$1(bareReference);
+}
+function parseScalePercentage(value) {
+	const match = /^(\d+(?:\.\d+)?)%$/.exec(value);
+	if (match === null) return;
+	const numeric = match[1];
+	return numeric === void 0 ? void 0 : Number(numeric);
+}
+function parseNonNegativeInteger(value) {
+	if (value === void 0) return;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function collectAnchoredFrame(frameElement, groupFunctions, pkg, anchorRow, anchorColumn, images, embeddedObjects) {
+	const shape = readDrawFrame(frameElement, groupFunctions, pkg);
+	if (shape === void 0) return;
+	const reference = readDrawObjectReference(frameElement, pkg);
+	if (reference !== void 0) {
+		const { document, residue } = readEmbeddedObjectDocument(reference, shape.frame, "ods");
+		const object = {
+			objectKind: reference.objectKind,
+			document,
+			frame: shape.frame,
+			anchorRow,
+			anchorColumn,
+			offsetXPt: shape.frame.xPt,
+			offsetYPt: shape.frame.yPt
+		};
+		if (residue !== void 0) object.source = residue;
+		embeddedObjects.push(object);
+		return;
+	}
+	for (const block of shape.blocks) if (block.kind === "image") images.push({
+		...block,
+		anchorRow,
+		anchorColumn,
+		offsetXPt: shape.frame.xPt,
+		offsetYPt: shape.frame.yPt
+	});
+}
+function collectAnchoredFrames(children, groupFunctions, pkg, anchorRow, anchorColumn, images, embeddedObjects) {
+	for (const child of children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "draw:frame") collectAnchoredFrame(child, groupFunctions, pkg, anchorRow, anchorColumn, images, embeddedObjects);
+		else if (child.tag === "draw:g") {
+			const ownValue = attrValue(child, "draw:transform");
+			const ownFunctions = ownValue === void 0 ? [] : parseOdfTransform(ownValue);
+			const nested = ownFunctions.length === 0 ? groupFunctions : [...ownFunctions, ...groupFunctions];
+			collectAnchoredFrames(child.children, nested, pkg, anchorRow, anchorColumn, images, embeddedObjects);
+		}
+	}
+}
+function readTable(tableElement, pkg) {
+	const columns = [];
+	const rows = [];
+	const cells = [];
+	const images = [];
+	const embeddedObjects = [];
+	const manualBreakRows = [];
+	const manualBreakColumns = [];
+	let repeatColumns;
+	let repeatRows;
+	let columnCursor = 0;
+	const cursor = new TableCursor();
+	function processColumn(columnElement) {
+		const { widthPt, manualBreak } = readColumnLayout(columnElement, pkg);
+		columns.push({
+			index: columnCursor,
+			widthPt,
+			hidden: isHidden(columnElement) ? true : void 0
+		});
+		if (manualBreak) manualBreakColumns.push(columnCursor);
+		columnCursor += readRepeatCount(columnElement, "table:number-columns-repeated");
+	}
+	function processRowCells(rowElement) {
+		for (const child of rowElement.children) {
+			if (child.type !== "element") continue;
+			if (child.tag === "table:covered-table-cell") cursor.nextCell(readRepeatCount(child, "table:number-columns-repeated"));
+			else if (child.tag === "table:table-cell") {
+				const columnIndex = cursor.columnIndex;
+				const rowIndex = cursor.rowIndex;
+				cursor.nextCell(readRepeatCount(child, "table:number-columns-repeated"));
+				collectAnchoredFrames(child.children, [], pkg, rowIndex, columnIndex, images, embeddedObjects);
+				const formula = attrValue(child, "table:formula");
+				const { runs, displayText } = readCellText(child, pkg);
+				if (!(attrValue(child, "office:value-type") !== void 0) && formula === void 0 && displayText.length === 0) continue;
+				const value = readCellValue(child, displayText);
+				const colSpan = parseNonNegativeInteger(attrValue(child, "table:number-columns-spanned"));
+				const rowSpan = parseNonNegativeInteger(attrValue(child, "table:number-rows-spanned"));
+				const cell = {
+					row: rowIndex,
+					column: columnIndex,
+					value,
+					displayText
+				};
+				if (formula !== void 0) cell.formula = formula;
+				if (runs.length > 0) cell.runs = runs;
+				if (colSpan !== void 0) cell.colSpan = colSpan;
+				if (rowSpan !== void 0) cell.rowSpan = rowSpan;
+				const cellStyleName = attrValue(child, "table:style-name");
+				const { elements: cellStyleChain } = resolveStyleElementChain(cellStyleName, "table-cell", pkg);
+				const decoration = readCellStyleDecoration(cellStyleChain);
+				if (decoration.background !== void 0) cell.background = decoration.background;
+				if (decoration.borders !== void 0) cell.borders = decoration.borders;
+				if (decoration.alignment !== void 0) cell.alignment = decoration.alignment;
+				if (decoration.verticalAlignment !== void 0) cell.verticalAlignment = decoration.verticalAlignment;
+				cells.push(cell);
+			}
+		}
+	}
+	function processRow(rowElement) {
+		const startIndex = cursor.rowIndex;
+		processRowCells(rowElement);
+		const { heightPt, manualBreak } = readRowLayout(rowElement, pkg);
+		rows.push({
+			index: startIndex,
+			heightPt,
+			hidden: isHidden(rowElement) ? true : void 0
+		});
+		if (manualBreak) manualBreakRows.push(startIndex);
+		cursor.nextRow(readRepeatCount(rowElement, "table:number-rows-repeated"));
+	}
+	for (const child of tableElement.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "table:shapes") collectAnchoredFrames(child.children, [], pkg, 0, 0, images, embeddedObjects);
+		else if (child.tag === "table:table-column") processColumn(child);
+		else if (child.tag === "table:table-header-columns") {
+			const startIndex = columnCursor;
+			for (const headerChild of child.children) if (headerChild.type === "element" && headerChild.tag === "table:table-column") processColumn(headerChild);
+			if (columnCursor > startIndex) repeatColumns = {
+				start: startIndex,
+				end: columnCursor - 1
+			};
+		} else if (child.tag === "table:table-row") processRow(child);
+		else if (child.tag === "table:table-header-rows") {
+			const startIndex = cursor.rowIndex;
+			for (const headerChild of child.children) if (headerChild.type === "element" && headerChild.tag === "table:table-row") processRow(headerChild);
+			if (cursor.rowIndex > startIndex) repeatRows = {
+				start: startIndex,
+				end: cursor.rowIndex - 1
+			};
+		}
+	}
+	return {
+		columns,
+		rows,
+		cells,
+		images,
+		embeddedObjects,
+		repeatColumns,
+		repeatRows,
+		manualBreakRows,
+		manualBreakColumns
+	};
+}
+function readPrintSettings(tableElement, pkg, repeatColumns, repeatRows, manualBreakRows, manualBreakColumns) {
+	const tableStyleName = attrValue(tableElement, "table:style-name");
+	const tableStyleElement = tableStyleName === void 0 ? void 0 : findStyleElement(tableStyleName, "table", pkg);
+	const masterPageName = tableStyleElement === void 0 ? void 0 : attrValue(tableStyleElement, "style:master-page-name");
+	const layoutProperties = resolvePageLayoutProperties(pkg, masterPageName);
+	const pageSize = layoutProperties === void 0 ? void 0 : parsePageSize(layoutProperties);
+	const margins = layoutProperties === void 0 ? void 0 : parseMargins(layoutProperties);
+	const printTokens = new Set((layoutProperties === void 0 ? void 0 : attrValue(layoutProperties, "style:print"))?.split(" ").filter((token) => token.length > 0));
+	const pageOrder = (layoutProperties === void 0 ? void 0 : attrValue(layoutProperties, "style:print-page-order")) === "ltr" ? "overThenDown" : "downThenOver";
+	const scaleToRaw = layoutProperties === void 0 ? void 0 : attrValue(layoutProperties, "style:scale-to");
+	const scale = scaleToRaw === void 0 ? void 0 : parseScalePercentage(scaleToRaw);
+	const scaleToXRaw = layoutProperties === void 0 ? void 0 : attrValue(layoutProperties, "style:scale-to-X");
+	const scaleToYRaw = layoutProperties === void 0 ? void 0 : attrValue(layoutProperties, "style:scale-to-Y");
+	const fitWidth = parseNonNegativeInteger(scaleToXRaw);
+	const fitHeight = parseNonNegativeInteger(scaleToYRaw);
+	const fitToPages = fitWidth === void 0 || fitHeight === void 0 ? void 0 : {
+		width: fitWidth,
+		height: fitHeight
+	};
+	const printRangesRaw = attrValue(tableElement, "table:print-ranges");
+	const printRange = printRangesRaw === void 0 ? void 0 : parsePrintRanges(printRangesRaw);
+	const manualBreaks = manualBreakRows.length > 0 || manualBreakColumns.length > 0 ? {
+		rows: manualBreakRows,
+		columns: manualBreakColumns
+	} : void 0;
+	const settings = {
+		pageSize: pageSize ?? PAGE_SIZE_A4,
+		margins: margins ?? DEFAULT_MARGINS$1,
+		gridlines: printTokens.has("grid"),
+		headers: printTokens.has("headers"),
+		pageOrder
+	};
+	if (printRange !== void 0) settings.printRange = printRange;
+	if (scale !== void 0) settings.scalePercent = scale;
+	if (fitToPages !== void 0) settings.fitToPages = fitToPages;
+	if (repeatRows !== void 0) settings.repeatRows = repeatRows;
+	if (repeatColumns !== void 0) settings.repeatColumns = repeatColumns;
+	if (manualBreaks !== void 0) settings.manualBreaks = manualBreaks;
+	return settings;
+}
+function readSheet(tableElement, pkg) {
+	const name = attrValue(tableElement, "table:name");
+	if (name === void 0) return;
+	const { columns, rows, cells, images, embeddedObjects, repeatColumns, repeatRows, manualBreakRows, manualBreakColumns } = readTable(tableElement, pkg);
+	const sheet = {
+		name,
+		cells,
+		columns,
+		rows,
+		images,
+		printSettings: readPrintSettings(tableElement, pkg, repeatColumns, repeatRows, manualBreakRows, manualBreakColumns)
+	};
+	if (embeddedObjects.length > 0) sheet.embeddedObjects = embeddedObjects;
+	return sheet;
+}
+function readOdsContent(pkg) {
+	const contentPart = pkg.parts[CONTENT_PART$2];
+	const root = contentPart?.kind === "xml" ? rootElement(contentPart.nodes) : void 0;
+	const body = root === void 0 ? void 0 : findChildElement(root.children, "office:body");
+	const spreadsheet = body === void 0 ? void 0 : findChildElement(body.children, "office:spreadsheet");
+	const tables = spreadsheet === void 0 ? [] : childrenWithTag(spreadsheet, "table:table");
+	const sheets = [];
+	for (const table of tables) {
+		const sheet = readSheet(table, pkg);
+		if (sheet !== void 0) sheets.push(sheet);
+	}
+	const definitions = {};
+	if (spreadsheet !== void 0) collectOdfNamedExpressions(spreadsheet.children, definitions);
+	return {
+		metadata: readOdfMetadata(pkg),
+		sheets,
+		...Object.keys(definitions).length > 0 ? { definitions } : {}
+	};
+}
+function readOds(pkg) {
+	const { metadata, sheets, definitions } = readOdsContent(pkg);
+	const assembled = assemblePackage({
+		kind: "spreadsheet",
+		metadata,
+		sheets
+	});
+	if (definitions !== void 0) assembled.definitions = definitions;
+	return assembled;
+}
+//#endregion
+//#region src/typed/odt/read.ts
+const CONTENT_PART$1 = "content.xml";
+const STYLES_PART = "styles.xml";
+const AUTOMATIC_STYLE_PARTS = [CONTENT_PART$1, STYLES_PART];
+function readOutlineLevel(headingElement) {
+	const raw = attrValue(headingElement, "text:outline-level");
+	if (raw === void 0) return 1;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : 1;
+}
+function readParagraphOrHeading(element, paragraph) {
+	if (element.tag === "text:h") {
+		const outlineLevel = readOutlineLevel(element);
+		paragraph.styleId = `Heading${outlineLevel}`;
+		paragraph.headingLevel = outlineLevel;
+	}
+	return paragraph;
+}
+function readAnchoredFrameSources(paragraphElement, pkg, state) {
+	if (!state.liftFrames) return [];
+	const sources = [];
+	const readFrameInto = (blocks, frameElement) => {
+		const shape = readDrawFrame(frameElement, [], pkg, state.listIdState, true);
+		if (shape === void 0) return;
+		const reference = readDrawObjectReference(frameElement, pkg);
+		if (reference !== void 0) {
+			const { document, residue } = readEmbeddedObjectDocument(reference, shape.frame, "odt");
+			const embeddedBlock = {
+				kind: "embeddedObject",
+				objectKind: reference.objectKind,
+				document,
+				frame: shape.frame
+			};
+			if (residue !== void 0) embeddedBlock.source = residue;
+			blocks.push(embeddedBlock);
+			return;
+		}
+		blocks.push(...shape.blocks);
+	};
+	for (const child of paragraphElement.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "draw:frame") {
+			const blocks = [];
+			readFrameInto(blocks, child);
+			if (blocks.length > 0) sources.push({
+				child,
+				blocks
+			});
+		} else if (child.tag === "draw:g") {
+			const blocks = [];
+			for (const grandChild of child.children) if (grandChild.type === "element" && grandChild.tag === "draw:frame") readFrameInto(blocks, grandChild);
+			if (blocks.length > 0) sources.push({
+				child,
+				blocks
+			});
+		}
+	}
+	return sources;
+}
+function liftedBlocksBeforeHalf(read, half) {
+	const halfIndex = read.element.children.indexOf(half);
+	if (halfIndex === -1) return 0;
+	let count = 0;
+	for (const source of read.liftedSources) if (read.element.children.indexOf(source.child) < halfIndex) count += source.blocks.length;
+	return count;
+}
+function readBlocks(nodes, pkg, state, baseIndex = 0) {
+	const blocks = [];
+	const emitParagraphs = (reads) => {
+		let cursor = baseIndex + blocks.length;
+		for (const read of reads) {
+			const lifted = read.liftedSources.flatMap((source) => source.blocks);
+			for (const half of read.halves) {
+				const eventIndex = odfMarkerHalfEventIndex(half, read.element, cursor, liftedBlocksBeforeHalf(read, half.element));
+				if (eventIndex !== void 0) state.markerEvents.push({
+					kind: half.kind,
+					side: half.side,
+					key: half.key,
+					index: eventIndex,
+					qualified: true,
+					order: state.order++,
+					descriptor: half.descriptor,
+					element: half.element
+				});
+			}
+			blocks.push(read.paragraph);
+			for (const block of lifted) blocks.push(block);
+			cursor += 1 + lifted.length;
+		}
+	};
+	const readOneParagraph = (element) => {
+		const halves = [];
+		return {
+			element,
+			paragraph: readParagraphOrHeading(element, readOdfParagraph(element, pkg, {
+				provenanceRegions: state.provenanceRegions,
+				markersOut: halves,
+				definitions: state.definitions,
+				listIdState: state.listIdState,
+				format: "odt"
+			})),
+			halves,
+			liftedSources: readAnchoredFrameSources(element, pkg, state)
+		};
+	};
+	for (const node of nodes) {
+		if (node.type !== "element") continue;
+		if (node.tag === "text:p" || node.tag === "text:h") emitParagraphs([readOneParagraph(node)]);
+		else if (node.tag === "text:list") {
+			const numId = mintOdfListNumId(pkg, node, state.listIdState);
+			const reads = [];
+			readOdfListParagraphs(node, {
+				numId,
+				level: 0
+			}, (element) => {
+				const read = readOneParagraph(element);
+				reads.push(read);
+				return read.paragraph;
+			});
+			emitParagraphs(reads);
+		} else if (node.tag === "table:table") blocks.push(readOdfTable(node, pkg));
+		else if (node.tag === "text:section") {
+			const startIndex = baseIndex + blocks.length;
+			const order = state.order++;
+			blocks.push(...readBlocks(node.children, pkg, state, startIndex));
+			state.wrapperExtents.push({
+				startIndex,
+				endIndex: baseIndex + blocks.length,
+				order,
+				descriptor: odfDivisionDescriptor(node, pkg)
+			});
+		} else if (isOdfIndexWrapper(node)) {
+			const startIndex = baseIndex + blocks.length;
+			const order = state.order++;
+			const body = node.children.find((child) => child.type === "element" && child.tag === "text:index-body");
+			blocks.push(...body === void 0 ? [] : readBlocks(body.children, pkg, state, startIndex));
+			state.wrapperExtents.push({
+				startIndex,
+				endIndex: baseIndex + blocks.length,
+				order,
+				descriptor: odfIndexControlDescriptor(node)
+			});
+		} else if (node.tag === "text:index-title") blocks.push(...readBlocks(node.children, pkg, state, baseIndex + blocks.length));
+		else if (node.tag === "office:forms") blocks.push(...readOdfFormControlConstructs(node, "odt"));
+	}
+	return blocks;
+}
+function parseKnownOdfLength(value) {
+	const parsed = parseOdfLength(value);
+	if (parsed === void 0) throw new Error(`readOdtContent: internal error -- "${value}" is not a valid ODF length literal`);
+	return parsed;
+}
+const DEFAULT_MARGIN_PT = parseKnownOdfLength("2cm");
+const DEFAULT_MARGINS = {
+	topPt: DEFAULT_MARGIN_PT,
+	rightPt: DEFAULT_MARGIN_PT,
+	bottomPt: DEFAULT_MARGIN_PT,
+	leftPt: DEFAULT_MARGIN_PT
+};
+function findPageLayoutElement(pkg, pageLayoutName) {
+	if (pageLayoutName === void 0) return;
+	for (const partPath of AUTOMATIC_STYLE_PARTS) {
+		const part = pkg.parts[partPath];
+		if (part?.kind !== "xml") continue;
+		const root = rootElement(part.nodes);
+		const automaticStyles = root === void 0 ? void 0 : findChildElement(root.children, "office:automatic-styles");
+		if (automaticStyles === void 0) continue;
+		const found = childrenWithTag(automaticStyles, "style:page-layout").find((element) => attrValue(element, "style:name") === pageLayoutName);
+		if (found !== void 0) return found;
+	}
+}
+function readFirstMasterPageGeometry(pkg) {
+	const stylesPart = pkg.parts[STYLES_PART];
+	const stylesRoot = stylesPart?.kind === "xml" ? rootElement(stylesPart.nodes) : void 0;
+	const masterStyles = stylesRoot === void 0 ? void 0 : findChildElement(stylesRoot.children, "office:master-styles");
+	const masterPage = masterStyles === void 0 ? void 0 : findChildElement(masterStyles.children, "style:master-page");
+	const layout = findPageLayoutElement(pkg, masterPage === void 0 ? void 0 : attrValue(masterPage, "style:page-layout-name"));
+	const properties = layout === void 0 ? void 0 : findChildElement(layout.children, "style:page-layout-properties");
+	const pageSize = properties === void 0 ? void 0 : parsePageSize(properties);
+	const margins = properties === void 0 ? void 0 : parseMargins(properties);
+	return {
+		pageSize: pageSize ?? PAGE_SIZE_A4,
+		margins: margins ?? DEFAULT_MARGINS
+	};
+}
+function readOdtContent(pkg, options = {}) {
+	const contentPart = pkg.parts[CONTENT_PART$1];
+	if (contentPart?.kind !== "xml") throw new Error(`readOdtContent: package has no ${CONTENT_PART$1} part`);
+	const contentRoot = rootElement(contentPart.nodes);
+	const body = contentRoot === void 0 ? void 0 : findChildElement(contentRoot.children, "office:body");
+	const textElement = body === void 0 ? void 0 : findChildElement(body.children, "office:text");
+	if (textElement === void 0) throw new Error(`readOdtContent: ${CONTENT_PART$1} has no office:body/office:text element`);
+	const metadata = readOdfMetadata(pkg);
+	const { pageSize, margins } = readFirstMasterPageGeometry(pkg);
+	const provenanceRegions = /* @__PURE__ */ new Map();
+	collectOdfProvenanceRegions(textElement.children, provenanceRegions);
+	const definitions = {
+		entries: {},
+		nextNoteOrdinal: 1,
+		nextAnnotationOrdinal: 1
+	};
+	collectOdfFieldMasterDefinitions(textElement.children, definitions.entries);
+	for (const partPath of AUTOMATIC_STYLE_PARTS) {
+		const part = pkg.parts[partPath];
+		if (part?.kind !== "xml") continue;
+		collectOdfDataStyleDefinitions(part.nodes, definitions.entries);
+		collectOdfFontFaceDefinitions(part.nodes, definitions.entries);
+	}
+	const state = {
+		listIdState: { next: 1 },
+		provenanceRegions,
+		definitions,
+		wrapperExtents: [],
+		markerEvents: [],
+		liftFrames: options.frames !== "none",
+		order: 0
+	};
+	const walked = readBlocks(textElement.children, pkg, state);
+	const { extents: markerExtents, paired } = resolveOdfMarkerEvents(state.markerEvents);
+	const extents = [...state.wrapperExtents, ...markerExtents];
+	for (const event of state.markerEvents) if (event.kind === "annotation" && event.side === "start" && !paired.has(event.element)) {
+		const descriptor = event.descriptor();
+		if (descriptor !== void 0) extents.push({
+			startIndex: event.index,
+			endIndex: event.index,
+			order: event.order,
+			descriptor
+		});
+	}
+	return {
+		metadata,
+		sections: [{
+			pageSize,
+			margins,
+			blocks: insertOdfConstructMarkers(walked, extents)
+		}],
+		...Object.keys(definitions.entries).length > 0 ? { definitions: definitions.entries } : {}
+	};
+}
+function readOdt(pkg, options = {}) {
+	const { metadata, sections, definitions } = readOdtContent(pkg, options);
+	const assembled = assemblePackage({
+		kind: "wordprocessing",
+		metadata,
+		sections
+	});
+	if (definitions !== void 0) assembled.definitions = definitions;
+	return assembled;
+}
+//#endregion
+//#region src/typed/draw/embedded.ts
+const CONTENT_PART = "content.xml";
+function embeddedKindFor(bodyChildTag) {
+	switch (bodyChildTag) {
+		case "office:text": return "wordprocessing";
+		case "office:spreadsheet": return "spreadsheet";
+		case "office:presentation": return "presentation";
+		case "office:drawing": return "drawing";
+		case "office:chart": return "chart";
+		default: return;
+	}
+}
+function readOdfChartContent(chartPackage, frame, format) {
+	const contentPart = chartPackage.parts[CONTENT_PART];
+	const contentRoot = contentPart?.kind === "xml" ? rootElement(contentPart.nodes) : void 0;
+	const chartElement = contentRoot === void 0 ? void 0 : elementsWithTag(contentRoot.children, "chart:chart")[0];
+	const localTable = chartElement === void 0 ? void 0 : elementsWithTag(chartElement.children, "table:table")[0];
+	const blocks = localTable === void 0 ? [] : [readOdfTable(localTable, chartPackage)];
+	return {
+		document: {
+			kind: "drawing",
+			metadata: {},
+			pages: [{
+				size: {
+					widthPt: frame.widthPt,
+					heightPt: frame.heightPt
+				},
+				shapes: [{
+					frame: {
+						xPt: 0,
+						yPt: 0,
+						widthPt: frame.widthPt,
+						heightPt: frame.heightPt
+					},
+					insetLeftPt: 0,
+					insetTopPt: 0,
+					insetRightPt: 0,
+					insetBottomPt: 0,
+					blocks
+				}],
+				vectors: []
+			}]
+		},
+		residue: chartElement === void 0 ? void 0 : odfResidue(format, chartElement)
+	};
+}
+function readEmbeddedObjectDocument(reference, frame, format) {
+	switch (reference.objectKind) {
+		case "wordprocessing": {
+			const { metadata, sections } = readOdtContent(reference.package);
+			return {
+				document: {
+					kind: "wordprocessing",
+					metadata,
+					sections
+				},
+				residue: void 0
+			};
+		}
+		case "presentation": {
+			const { metadata, slides } = readOdpContent(reference.package);
+			return {
+				document: {
+					kind: "presentation",
+					metadata,
+					slides
+				},
+				residue: void 0
+			};
+		}
+		case "drawing": {
+			const { metadata, pages } = readOdgContent(reference.package);
+			return {
+				document: {
+					kind: "drawing",
+					metadata,
+					pages
+				},
+				residue: void 0
+			};
+		}
+		case "spreadsheet": {
+			const { metadata, sheets } = readOdsContent(reference.package);
+			return {
+				document: {
+					kind: "spreadsheet",
+					metadata,
+					sheets
+				},
+				residue: void 0
+			};
+		}
+		case "formula": return {
+			document: readOdfFormulaContent(reference.package),
+			residue: void 0
+		};
+		case "chart": return readOdfChartContent(reference.package, frame, format);
+	}
+}
+function subDocumentKind(nodes) {
+	const root = rootElement(nodes);
+	const body = root === void 0 ? void 0 : findChildElement(root.children, "office:body");
+	const bodyChild = body === void 0 ? void 0 : rootElement(body.children);
+	const bodyKind = bodyChild === void 0 ? void 0 : embeddedKindFor(bodyChild.tag);
+	if (bodyKind !== void 0) return bodyKind;
+	return findMathRoot(nodes) === void 0 ? void 0 : "formula";
+}
+function normaliseObjectHref(raw) {
+	const withoutPrefix = raw.startsWith("./") ? raw.slice(2) : raw;
+	const trimmed = withoutPrefix.endsWith("/") ? withoutPrefix.slice(0, -1) : withoutPrefix;
+	if (trimmed.length === 0 || trimmed.startsWith("..") || trimmed.startsWith("/") || trimmed.includes("://")) return;
+	return trimmed;
+}
+function readDrawObjectReference(frame, pkg) {
+	const object = childrenWithTag(frame, "draw:object")[0];
+	if (object === void 0) return;
+	const rawHref = attrValue(object, "xlink:href");
+	const href = rawHref === void 0 ? void 0 : normaliseObjectHref(rawHref);
+	if (href === void 0) return;
+	const subPackage = subDocumentPackage(pkg, href, { allowMissingContent: true });
+	const contentPart = subPackage.parts[CONTENT_PART];
+	if (contentPart?.kind !== "xml") return;
+	const objectKind = subDocumentKind(contentPart.nodes);
+	if (objectKind === void 0) return;
+	return {
+		objectKind,
+		package: subPackage,
+		href
+	};
+}
+//#endregion
+export { readOdtContent as a, readOdt as i, readEmbeddedObjectDocument as n, readOds as o, readOdfChartContent as r, readOdsContent as s, readDrawObjectReference as t };