documents.js 1.60.3 → 1.62.0

package/dist/odf/formula/detect.d.cts

@@ -1,12 +1,16 @@
-import { t as Box } from "../../geometry-DvwdrIij.cjs";
-import { EmbeddedFormula } from "../../model/formula.cjs";
+import { t as Box$1 } from "../../geometry-DaJr8yQW.cjs";
+import { ContentFormula } from "document-schema.js";
 import { Package, XmlElement, XmlNode } from "odf.js";
 //#region src/odf/formula/detect.d.ts
 interface DetectedFormulaFrame {
   readonly frameElement: XmlElement;
-  readonly formula: EmbeddedFormula;
-  readonly frame: Box;
+  readonly formula: ContentFormula;
+  readonly frame: Box$1;
 }
-declare function detectEmbeddedFormulaFrames(containerChildren: readonly XmlNode[], pkg: Package): readonly DetectedFormulaFrame[];
+interface DetectedSlideFormulaFrame extends DetectedFormulaFrame {
+  readonly shapeIndex: number;
+}
+declare function collectFormulaFrames(nodes: readonly XmlNode[], pkg: Package): readonly DetectedFormulaFrame[];
+declare function collectSlideFormulaFrames(pageChildren: readonly XmlNode[], pkg: Package): readonly DetectedSlideFormulaFrame[];
 //#endregion
-export { DetectedFormulaFrame, detectEmbeddedFormulaFrames };
+export { DetectedFormulaFrame, DetectedSlideFormulaFrame, collectFormulaFrames, collectSlideFormulaFrames };

package/dist/odf/formula/detect.d.ts

@@ -1,12 +1,16 @@
-import { t as Box } from "../../geometry-DvwdrIij.js";
-import { EmbeddedFormula } from "../../model/formula.js";
+import { t as Box$1 } from "../../geometry-DaJr8yQW.js";
+import { ContentFormula } from "document-schema.js";
 import { Package, XmlElement, XmlNode } from "odf.js";
 //#region src/odf/formula/detect.d.ts
 interface DetectedFormulaFrame {
   readonly frameElement: XmlElement;
-  readonly formula: EmbeddedFormula;
-  readonly frame: Box;
+  readonly formula: ContentFormula;
+  readonly frame: Box$1;
 }
-declare function detectEmbeddedFormulaFrames(containerChildren: readonly XmlNode[], pkg: Package): readonly DetectedFormulaFrame[];
+interface DetectedSlideFormulaFrame extends DetectedFormulaFrame {
+  readonly shapeIndex: number;
+}
+declare function collectFormulaFrames(nodes: readonly XmlNode[], pkg: Package): readonly DetectedFormulaFrame[];
+declare function collectSlideFormulaFrames(pageChildren: readonly XmlNode[], pkg: Package): readonly DetectedSlideFormulaFrame[];
 //#endregion
-export { DetectedFormulaFrame, detectEmbeddedFormulaFrames };
+export { DetectedFormulaFrame, DetectedSlideFormulaFrame, collectFormulaFrames, collectSlideFormulaFrames };

package/dist/odf/formula/detect.js

@@ -1,28 +1,95 @@
 import { readOdfEmbeddedFormula } from "./read.js";
-import { attrValue, childrenWithTag, readDrawFrame } from "odf.js";
+import { attrValue, childrenWithTag, parseOdfLength, parseOdfTransform, readDrawFrame } from "odf.js";
 //#region src/odf/formula/detect.ts
 function subPackagePathFromHref(href) {
 	return href.replace(/^#?\.\//, "");
 }
-function detectEmbeddedFormulaFrames(containerChildren, pkg) {
-	const out = [];
-	for (const child of containerChildren) {
-		if (child.type !== "element" || child.tag !== "draw:frame") continue;
-		const objectElement = childrenWithTag(child, "draw:object")[0];
-		if (objectElement === void 0) continue;
-		const href = attrValue(objectElement, "xlink:href");
-		if (href === void 0) continue;
-		const formula = readOdfEmbeddedFormula(pkg, subPackagePathFromHref(href));
-		if (formula === void 0) continue;
-		const shape = readDrawFrame(child, [], pkg);
-		if (shape === void 0) continue;
-		out.push({
-			frameElement: child,
-			formula,
-			frame: shape.frame
-		});
+function formulaOfFrame(frame, pkg) {
+	const objectElement = childrenWithTag(frame, "draw:object")[0];
+	if (objectElement === void 0) return;
+	const href = attrValue(objectElement, "xlink:href");
+	if (href === void 0) return;
+	return readOdfEmbeddedFormula(pkg, subPackagePathFromHref(href));
+}
+function flowAnchoredFrameBox(frame) {
+	const widthValue = attrValue(frame, "svg:width");
+	const heightValue = attrValue(frame, "svg:height");
+	if (widthValue === void 0 || heightValue === void 0) return;
+	const widthPt = parseOdfLength(widthValue);
+	const heightPt = parseOdfLength(heightValue);
+	if (widthPt === void 0 || heightPt === void 0) return;
+	return {
+		xPt: 0,
+		yPt: 0,
+		widthPt,
+		heightPt
+	};
+}
+function nestedGroupFunctions(group, groupFunctions) {
+	const value = attrValue(group, "draw:transform");
+	const own = value === void 0 ? [] : parseOdfTransform(value);
+	return own.length === 0 ? groupFunctions : [...own, ...groupFunctions];
+}
+function readFormulaFrame(frame, groupFunctions, pkg, allowFlowAnchored) {
+	const formula = formulaOfFrame(frame, pkg);
+	if (formula === void 0) return;
+	const box = readDrawFrame(frame, groupFunctions, pkg)?.frame ?? (allowFlowAnchored ? flowAnchoredFrameBox(frame) : void 0);
+	if (box === void 0) return;
+	return {
+		frameElement: frame,
+		formula,
+		frame: box
+	};
+}
+function walkForFormulaFrames(nodes, groupFunctions, pkg, out) {
+	for (const node of nodes) {
+		if (node.type !== "element") continue;
+		if (node.tag === "draw:frame") {
+			const detected = readFormulaFrame(node, groupFunctions, pkg, true);
+			if (detected !== void 0) {
+				out.push(detected);
+				continue;
+			}
+			walkForFormulaFrames(node.children, groupFunctions, pkg, out);
+			continue;
+		}
+		if (node.tag === "draw:g") {
+			walkForFormulaFrames(node.children, nestedGroupFunctions(node, groupFunctions), pkg, out);
+			continue;
+		}
+		walkForFormulaFrames(node.children, groupFunctions, pkg, out);
 	}
+}
+function collectFormulaFrames(nodes, pkg) {
+	const out = [];
+	walkForFormulaFrames(nodes, [], pkg, out);
+	return out;
+}
+function collectSlideFormulaFrames(pageChildren, pkg) {
+	const out = [];
+	const state = { nextShapeIndex: 0 };
+	const walk = (nodes, groupFunctions) => {
+		for (const node of nodes) {
+			if (node.type !== "element") continue;
+			if (node.tag === "draw:frame") {
+				const shape = readDrawFrame(node, groupFunctions, pkg);
+				if (shape === void 0) continue;
+				const shapeIndex = state.nextShapeIndex;
+				state.nextShapeIndex += 1;
+				const formula = formulaOfFrame(node, pkg);
+				if (formula !== void 0) out.push({
+					frameElement: node,
+					formula,
+					frame: shape.frame,
+					shapeIndex
+				});
+				continue;
+			}
+			if (node.tag === "draw:g") walk(node.children, nestedGroupFunctions(node, groupFunctions));
+		}
+	};
+	walk(pageChildren, []);
 	return out;
 }
 //#endregion
-export { detectEmbeddedFormulaFrames };
+export { collectFormulaFrames, collectSlideFormulaFrames };

package/dist/odf/formula/read.cjs

@@ -2,27 +2,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let odf_js = require("odf.js");
 //#region src/odf/formula/read.ts
 function readOdfFormulaContent(pkg) {
-	const formula = (0, odf_js.readOdfFormula)(pkg);
-	return {
-		mathml: formula.mathml,
-		starMath: formula.starMath,
-		metadata: formula.metadata
-	};
+	return (0, odf_js.readOdfFormulaDocument)(pkg);
 }
 function readOdfEmbeddedFormula(outerPkg, subPackagePath) {
 	const contentPart = outerPkg.parts[`${subPackagePath}/content.xml`];
 	if (contentPart?.kind !== "xml") return;
-	const metaPart = outerPkg.parts[`${subPackagePath}/meta.xml`];
-	const subPkg = { parts: metaPart?.kind === "xml" ? {
-		"content.xml": contentPart,
-		"meta.xml": metaPart
-	} : { "content.xml": contentPart } };
+	const subPkg = { parts: { "content.xml": contentPart } };
 	try {
-		const formula = (0, odf_js.readOdfFormula)(subPkg);
-		return {
-			mathml: formula.mathml,
-			starMath: formula.starMath
-		};
+		const document = (0, odf_js.readOdfFormulaDocument)(subPkg);
+		return document.kind === "formula" ? document.formula : void 0;
 	} catch {
 		return;
 	}

package/dist/odf/formula/read.d.cts

@@ -1,11 +1,7 @@
-import { EmbeddedFormula } from "../../model/formula.cjs";
-import { LayoutMetadata } from "document-schema.js";
+import { ContentDocument, ContentFormula } from "document-schema.js";
 import { Package } from "odf.js";
 //#region src/odf/formula/read.d.ts
-interface StandaloneFormulaContent extends EmbeddedFormula {
-  readonly metadata: LayoutMetadata;
-}
-declare function readOdfFormulaContent(pkg: Package): StandaloneFormulaContent;
-declare function readOdfEmbeddedFormula(outerPkg: Package, subPackagePath: string): EmbeddedFormula | undefined;
+declare function readOdfFormulaContent(pkg: Package): ContentDocument;
+declare function readOdfEmbeddedFormula(outerPkg: Package, subPackagePath: string): ContentFormula | undefined;
 //#endregion
-export { StandaloneFormulaContent, readOdfEmbeddedFormula, readOdfFormulaContent };
+export { readOdfEmbeddedFormula, readOdfFormulaContent };

package/dist/odf/formula/read.d.ts

@@ -1,11 +1,7 @@
-import { EmbeddedFormula } from "../../model/formula.js";
-import { LayoutMetadata } from "document-schema.js";
+import { ContentDocument, ContentFormula } from "document-schema.js";
 import { Package } from "odf.js";
 //#region src/odf/formula/read.d.ts
-interface StandaloneFormulaContent extends EmbeddedFormula {
-  readonly metadata: LayoutMetadata;
-}
-declare function readOdfFormulaContent(pkg: Package): StandaloneFormulaContent;
-declare function readOdfEmbeddedFormula(outerPkg: Package, subPackagePath: string): EmbeddedFormula | undefined;
+declare function readOdfFormulaContent(pkg: Package): ContentDocument;
+declare function readOdfEmbeddedFormula(outerPkg: Package, subPackagePath: string): ContentFormula | undefined;
 //#endregion
-export { StandaloneFormulaContent, readOdfEmbeddedFormula, readOdfFormulaContent };
+export { readOdfEmbeddedFormula, readOdfFormulaContent };

package/dist/odf/formula/read.js

@@ -1,27 +1,15 @@
-import { readOdfFormula } from "odf.js";
+import { readOdfFormulaDocument } from "odf.js";
 //#region src/odf/formula/read.ts
 function readOdfFormulaContent(pkg) {
-	const formula = readOdfFormula(pkg);
-	return {
-		mathml: formula.mathml,
-		starMath: formula.starMath,
-		metadata: formula.metadata
-	};
+	return readOdfFormulaDocument(pkg);
 }
 function readOdfEmbeddedFormula(outerPkg, subPackagePath) {
 	const contentPart = outerPkg.parts[`${subPackagePath}/content.xml`];
 	if (contentPart?.kind !== "xml") return;
-	const metaPart = outerPkg.parts[`${subPackagePath}/meta.xml`];
-	const subPkg = { parts: metaPart?.kind === "xml" ? {
-		"content.xml": contentPart,
-		"meta.xml": metaPart
-	} : { "content.xml": contentPart } };
+	const subPkg = { parts: { "content.xml": contentPart } };
 	try {
-		const formula = readOdfFormula(subPkg);
-		return {
-			mathml: formula.mathml,
-			starMath: formula.starMath
-		};
+		const document = readOdfFormulaDocument(subPkg);
+		return document.kind === "formula" ? document.formula : void 0;
 	} catch {
 		return;
 	}

package/dist/odf/odp/read.cjs

@@ -1,44 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_formula = require("../../model/formula.cjs");
 const require_odf_formula_detect = require("../formula/detect.cjs");
-const require_odf_formula_placeholder = require("../formula/placeholder.cjs");
 let document_schema_js = require("document-schema.js");
 let odf_js = require("odf.js");
 //#region src/odf/odp/read.ts
 function readOdpContent(pkg) {
 	const odpDoc = (0, odf_js.readOdp)(pkg);
-	const formulas = /* @__PURE__ */ new Map();
 	const contentPart = pkg.parts["content.xml"];
 	if (contentPart?.kind === "xml") {
 		const root = (0, odf_js.rootElement)(contentPart.nodes);
 		const body = root === void 0 ? void 0 : (0, odf_js.findChildElement)(root.children, "office:body");
 		const presentation = body === void 0 ? void 0 : (0, odf_js.findChildElement)(body.children, "office:presentation");
 		(presentation === void 0 ? [] : (0, odf_js.childrenWithTag)(presentation, "draw:page")).forEach((pageElement, slideIndex) => {
-			if ((0, odf_js.childrenWithTag)(pageElement, "draw:g").length > 0) return;
 			const slide = odpDoc.slides[slideIndex];
 			if (slide === void 0) return;
-			const frameElements = (0, odf_js.childrenWithTag)(pageElement, "draw:frame");
-			const detected = require_odf_formula_detect.detectEmbeddedFormulaFrames(frameElements, pkg);
-			for (const found of detected) {
-				const shapeIndex = frameElements.indexOf(found.frameElement);
-				const shape = slide.shapes[shapeIndex];
+			for (const found of require_odf_formula_detect.collectSlideFormulaFrames(pageElement.children, pkg)) {
+				const shape = slide.shapes[found.shapeIndex];
 				if (shape === void 0) continue;
-				const sourcePath = `slides[${slideIndex}].shapes[${shapeIndex}]`;
-				slide.shapes[shapeIndex] = {
+				slide.shapes[found.shapeIndex] = {
 					...shape,
-					blocks: [require_odf_formula_placeholder.buildFormulaPlaceholderBlock(found.formula, found.frame, sourcePath)]
+					blocks: [require_model_formula.buildFormulaBlock(found.formula, found.frame, `slides[${slideIndex}].shapes[${found.shapeIndex}]`)]
 				};
-				formulas.set(sourcePath, found.formula);
 			}
 		});
 	}
 	return {
-		document: {
-			kind: "presentation",
-			formatVersion: document_schema_js.CONTENT_FORMAT_VERSION,
-			metadata: { ...odpDoc.metadata },
-			slides: odpDoc.slides
-		},
-		formulas
+		kind: "presentation",
+		formatVersion: document_schema_js.CONTENT_FORMAT_VERSION,
+		metadata: { ...odpDoc.metadata },
+		slides: odpDoc.slides
 	};
 }
 //#endregion

package/dist/odf/odp/read.d.cts

@@ -1,11 +1,6 @@
-import { EmbeddedFormula } from "../../model/formula.cjs";
 import { ContentDocument } from "document-schema.js";
 import { Package } from "odf.js";
 //#region src/odf/odp/read.d.ts
-interface OdpContentResult {
-  readonly document: ContentDocument;
-  readonly formulas: ReadonlyMap<string, EmbeddedFormula>;
-}
-declare function readOdpContent(pkg: Package): OdpContentResult;
+declare function readOdpContent(pkg: Package): ContentDocument;
 //#endregion
-export { OdpContentResult, readOdpContent };
+export { readOdpContent };

package/dist/odf/odp/read.d.ts

@@ -1,11 +1,6 @@
-import { EmbeddedFormula } from "../../model/formula.js";
 import { ContentDocument } from "document-schema.js";
 import { Package } from "odf.js";
 //#region src/odf/odp/read.d.ts
-interface OdpContentResult {
-  readonly document: ContentDocument;
-  readonly formulas: ReadonlyMap<string, EmbeddedFormula>;
-}
-declare function readOdpContent(pkg: Package): OdpContentResult;
+declare function readOdpContent(pkg: Package): ContentDocument;
 //#endregion
-export { OdpContentResult, readOdpContent };
+export { readOdpContent };

package/dist/odf/odp/read.js

@@ -1,43 +1,33 @@
-import { detectEmbeddedFormulaFrames } from "../formula/detect.js";
-import { buildFormulaPlaceholderBlock } from "../formula/placeholder.js";
+import { buildFormulaBlock } from "../../model/formula.js";
+import { collectSlideFormulaFrames } from "../formula/detect.js";
 import { CONTENT_FORMAT_VERSION } from "document-schema.js";
 import { childrenWithTag, findChildElement, readOdp, rootElement } from "odf.js";
 //#region src/odf/odp/read.ts
 function readOdpContent(pkg) {
 	const odpDoc = readOdp(pkg);
-	const formulas = /* @__PURE__ */ new Map();
 	const contentPart = pkg.parts["content.xml"];
 	if (contentPart?.kind === "xml") {
 		const root = rootElement(contentPart.nodes);
 		const body = root === void 0 ? void 0 : findChildElement(root.children, "office:body");
 		const presentation = body === void 0 ? void 0 : findChildElement(body.children, "office:presentation");
 		(presentation === void 0 ? [] : childrenWithTag(presentation, "draw:page")).forEach((pageElement, slideIndex) => {
-			if (childrenWithTag(pageElement, "draw:g").length > 0) return;
 			const slide = odpDoc.slides[slideIndex];
 			if (slide === void 0) return;
-			const frameElements = childrenWithTag(pageElement, "draw:frame");
-			const detected = detectEmbeddedFormulaFrames(frameElements, pkg);
-			for (const found of detected) {
-				const shapeIndex = frameElements.indexOf(found.frameElement);
-				const shape = slide.shapes[shapeIndex];
+			for (const found of collectSlideFormulaFrames(pageElement.children, pkg)) {
+				const shape = slide.shapes[found.shapeIndex];
 				if (shape === void 0) continue;
-				const sourcePath = `slides[${slideIndex}].shapes[${shapeIndex}]`;
-				slide.shapes[shapeIndex] = {
+				slide.shapes[found.shapeIndex] = {
 					...shape,
-					blocks: [buildFormulaPlaceholderBlock(found.formula, found.frame, sourcePath)]
+					blocks: [buildFormulaBlock(found.formula, found.frame, `slides[${slideIndex}].shapes[${found.shapeIndex}]`)]
 				};
-				formulas.set(sourcePath, found.formula);
 			}
 		});
 	}
 	return {
-		document: {
-			kind: "presentation",
-			formatVersion: CONTENT_FORMAT_VERSION,
-			metadata: { ...odpDoc.metadata },
-			slides: odpDoc.slides
-		},
-		formulas
+		kind: "presentation",
+		formatVersion: CONTENT_FORMAT_VERSION,
+		metadata: { ...odpDoc.metadata },
+		slides: odpDoc.slides
 	};
 }
 //#endregion

package/dist/odf/odt/read.cjs

@@ -1,43 +1,83 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_formula = require("../../model/formula.cjs");
 const require_odf_formula_detect = require("../formula/detect.cjs");
-const require_odf_formula_placeholder = require("../formula/placeholder.cjs");
 let document_schema_js = require("document-schema.js");
 let odf_js = require("odf.js");
 //#region src/odf/odt/read.ts
 function readOdtContent(pkg) {
 	const odtDoc = (0, odf_js.readOdt)(pkg);
-	const formulas = /* @__PURE__ */ new Map();
 	const contentPart = pkg.parts["content.xml"];
 	if (contentPart?.kind === "xml" && odtDoc.sections.length === 1) {
 		const root = (0, odf_js.rootElement)(contentPart.nodes);
 		const body = root === void 0 ? void 0 : (0, odf_js.findChildElement)(root.children, "office:body");
 		const text = body === void 0 ? void 0 : (0, odf_js.findChildElement)(body.children, "office:text");
 		if (text !== void 0) {
-			const detected = require_odf_formula_detect.detectEmbeddedFormulaFrames(text.children, pkg);
-			if (detected.length > 0) {
-				const section = odtDoc.sections[0];
-				const blocks = [...section.blocks];
-				for (const found of detected) {
-					const sourcePath = `sections[0].blocks[${blocks.length}]`;
-					blocks.push(require_odf_formula_placeholder.buildFormulaPlaceholderBlock(found.formula, found.frame, sourcePath));
-					formulas.set(sourcePath, found.formula);
-				}
-				odtDoc.sections[0] = {
-					...section,
-					blocks
-				};
-			}
+			const section = odtDoc.sections[0];
+			const placements = collectFormulaPlacements(text.children, pkg);
+			if (placements.length > 0) odtDoc.sections[0] = {
+				...section,
+				blocks: spliceFormulaBlocks(section.blocks, placements)
+			};
 		}
 	}
 	return {
-		document: {
-			kind: "wordprocessing",
-			formatVersion: document_schema_js.CONTENT_FORMAT_VERSION,
-			metadata: { ...odtDoc.metadata },
-			sections: odtDoc.sections
-		},
-		formulas
+		kind: "wordprocessing",
+		formatVersion: document_schema_js.CONTENT_FORMAT_VERSION,
+		metadata: { ...odtDoc.metadata },
+		sections: odtDoc.sections
 	};
 }
+function pushPlacements(out, index, detected) {
+	for (const frame of detected) out.push({
+		index,
+		detected: frame
+	});
+}
+function collectFormulaPlacements(nodes, pkg) {
+	const out = [];
+	walkForPlacements(nodes, pkg, { blockCount: 0 }, out);
+	return out;
+}
+function walkForPlacements(nodes, pkg, state, out) {
+	for (const node of nodes) {
+		if (node.type !== "element") continue;
+		if (node.tag === "text:p" || node.tag === "text:h") {
+			state.blockCount += 1;
+			pushPlacements(out, state.blockCount, require_odf_formula_detect.collectFormulaFrames(node.children, pkg));
+		} else if (node.tag === "text:list") walkListForPlacements(node.children, pkg, state, out);
+		else if (node.tag === "table:table") {
+			state.blockCount += 1;
+			pushPlacements(out, state.blockCount, require_odf_formula_detect.collectFormulaFrames(node.children, pkg));
+		} else if (node.tag === "text:section") walkForPlacements(node.children, pkg, state, out);
+		else pushPlacements(out, state.blockCount, require_odf_formula_detect.collectFormulaFrames([node], pkg));
+	}
+}
+function walkListForPlacements(itemNodes, pkg, state, out) {
+	for (const item of itemNodes) {
+		if (item.type !== "element" || item.tag !== "text:list-item") continue;
+		for (const itemChild of item.children) {
+			if (itemChild.type !== "element") continue;
+			if (itemChild.tag === "text:p" || itemChild.tag === "text:h") {
+				state.blockCount += 1;
+				pushPlacements(out, state.blockCount, require_odf_formula_detect.collectFormulaFrames(itemChild.children, pkg));
+			} else if (itemChild.tag === "text:list") walkListForPlacements(itemChild.children, pkg, state, out);
+			else pushPlacements(out, state.blockCount, require_odf_formula_detect.collectFormulaFrames([itemChild], pkg));
+		}
+	}
+}
+function spliceFormulaBlocks(blocks, placements) {
+	const out = [];
+	let next = 0;
+	for (let index = 0; index <= blocks.length; index++) {
+		while (next < placements.length && placements[next].index === index) {
+			const { detected } = placements[next];
+			out.push(require_model_formula.buildFormulaBlock(detected.formula, detected.frame, `sections[0].blocks[${out.length}]`));
+			next += 1;
+		}
+		const block = blocks[index];
+		if (block !== void 0) out.push(block);
+	}
+	return out;
+}
 //#endregion
 exports.readOdtContent = readOdtContent;

package/dist/odf/odt/read.d.cts

@@ -1,11 +1,6 @@
-import { EmbeddedFormula } from "../../model/formula.cjs";
 import { ContentDocument } from "document-schema.js";
 import { Package } from "odf.js";
 //#region src/odf/odt/read.d.ts
-interface OdtContentResult {
-  readonly document: ContentDocument;
-  readonly formulas: ReadonlyMap<string, EmbeddedFormula>;
-}
-declare function readOdtContent(pkg: Package): OdtContentResult;
+declare function readOdtContent(pkg: Package): ContentDocument;
 //#endregion
-export { OdtContentResult, readOdtContent };
+export { readOdtContent };

package/dist/odf/odt/read.d.ts

@@ -1,11 +1,6 @@
-import { EmbeddedFormula } from "../../model/formula.js";
 import { ContentDocument } from "document-schema.js";
 import { Package } from "odf.js";
 //#region src/odf/odt/read.d.ts
-interface OdtContentResult {
-  readonly document: ContentDocument;
-  readonly formulas: ReadonlyMap<string, EmbeddedFormula>;
-}
-declare function readOdtContent(pkg: Package): OdtContentResult;
+declare function readOdtContent(pkg: Package): ContentDocument;
 //#endregion
-export { OdtContentResult, readOdtContent };
+export { readOdtContent };

package/dist/odf/odt/read.js

@@ -1,42 +1,82 @@
-import { detectEmbeddedFormulaFrames } from "../formula/detect.js";
-import { buildFormulaPlaceholderBlock } from "../formula/placeholder.js";
+import { buildFormulaBlock } from "../../model/formula.js";
+import { collectFormulaFrames } from "../formula/detect.js";
 import { CONTENT_FORMAT_VERSION } from "document-schema.js";
 import { findChildElement, readOdt, rootElement } from "odf.js";
 //#region src/odf/odt/read.ts
 function readOdtContent(pkg) {
 	const odtDoc = readOdt(pkg);
-	const formulas = /* @__PURE__ */ new Map();
 	const contentPart = pkg.parts["content.xml"];
 	if (contentPart?.kind === "xml" && odtDoc.sections.length === 1) {
 		const root = rootElement(contentPart.nodes);
 		const body = root === void 0 ? void 0 : findChildElement(root.children, "office:body");
 		const text = body === void 0 ? void 0 : findChildElement(body.children, "office:text");
 		if (text !== void 0) {
-			const detected = detectEmbeddedFormulaFrames(text.children, pkg);
-			if (detected.length > 0) {
-				const section = odtDoc.sections[0];
-				const blocks = [...section.blocks];
-				for (const found of detected) {
-					const sourcePath = `sections[0].blocks[${blocks.length}]`;
-					blocks.push(buildFormulaPlaceholderBlock(found.formula, found.frame, sourcePath));
-					formulas.set(sourcePath, found.formula);
-				}
-				odtDoc.sections[0] = {
-					...section,
-					blocks
-				};
-			}
+			const section = odtDoc.sections[0];
+			const placements = collectFormulaPlacements(text.children, pkg);
+			if (placements.length > 0) odtDoc.sections[0] = {
+				...section,
+				blocks: spliceFormulaBlocks(section.blocks, placements)
+			};
 		}
 	}
 	return {
-		document: {
-			kind: "wordprocessing",
-			formatVersion: CONTENT_FORMAT_VERSION,
-			metadata: { ...odtDoc.metadata },
-			sections: odtDoc.sections
-		},
-		formulas
+		kind: "wordprocessing",
+		formatVersion: CONTENT_FORMAT_VERSION,
+		metadata: { ...odtDoc.metadata },
+		sections: odtDoc.sections
 	};
 }
+function pushPlacements(out, index, detected) {
+	for (const frame of detected) out.push({
+		index,
+		detected: frame
+	});
+}
+function collectFormulaPlacements(nodes, pkg) {
+	const out = [];
+	walkForPlacements(nodes, pkg, { blockCount: 0 }, out);
+	return out;
+}
+function walkForPlacements(nodes, pkg, state, out) {
+	for (const node of nodes) {
+		if (node.type !== "element") continue;
+		if (node.tag === "text:p" || node.tag === "text:h") {
+			state.blockCount += 1;
+			pushPlacements(out, state.blockCount, collectFormulaFrames(node.children, pkg));
+		} else if (node.tag === "text:list") walkListForPlacements(node.children, pkg, state, out);
+		else if (node.tag === "table:table") {
+			state.blockCount += 1;
+			pushPlacements(out, state.blockCount, collectFormulaFrames(node.children, pkg));
+		} else if (node.tag === "text:section") walkForPlacements(node.children, pkg, state, out);
+		else pushPlacements(out, state.blockCount, collectFormulaFrames([node], pkg));
+	}
+}
+function walkListForPlacements(itemNodes, pkg, state, out) {
+	for (const item of itemNodes) {
+		if (item.type !== "element" || item.tag !== "text:list-item") continue;
+		for (const itemChild of item.children) {
+			if (itemChild.type !== "element") continue;
+			if (itemChild.tag === "text:p" || itemChild.tag === "text:h") {
+				state.blockCount += 1;
+				pushPlacements(out, state.blockCount, collectFormulaFrames(itemChild.children, pkg));
+			} else if (itemChild.tag === "text:list") walkListForPlacements(itemChild.children, pkg, state, out);
+			else pushPlacements(out, state.blockCount, collectFormulaFrames([itemChild], pkg));
+		}
+	}
+}
+function spliceFormulaBlocks(blocks, placements) {
+	const out = [];
+	let next = 0;
+	for (let index = 0; index <= blocks.length; index++) {
+		while (next < placements.length && placements[next].index === index) {
+			const { detected } = placements[next];
+			out.push(buildFormulaBlock(detected.formula, detected.frame, `sections[0].blocks[${out.length}]`));
+			next += 1;
+		}
+		const block = blocks[index];
+		if (block !== void 0) out.push(block);
+	}
+	return out;
+}
 //#endregion
 export { readOdtContent };