documents.js 1.61.0 → 1.63.0

package/dist/odb/components.js

@@ -0,0 +1,10 @@
+import { readOdbForm, readOdbInventory, readOdbReport } from "odf.js";
+//#region src/odb/components.ts
+function readOdbForms(pkg) {
+	return readOdbInventory(pkg).forms.map((component) => readOdbForm(pkg, component.name));
+}
+function readOdbReports(pkg) {
+	return readOdbInventory(pkg).reports.map((component) => readOdbReport(pkg, component.name));
+}
+//#endregion
+export { readOdbForms, readOdbReports };

package/dist/odb/read.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_hsqldb_script = require("../hsqldb/script.cjs");
+const require_hsqldb_binary_script = require("../hsqldb/binary-script.cjs");
 const require_hsqldb_cache = require("../hsqldb/cache.cjs");
 const require_firebird_backup = require("../firebird/backup.cjs");
 let odf_js = require("odf.js");
@@ -44,7 +45,7 @@ function classifyScriptBytes(bytes) {
 	}
 	return "text";
 }
-function readOdbTables(pkg) {
+function readOdbTables(pkg, options) {
 	const inventory = (0, odf_js.readOdbInventory)(pkg);
 	if (inventory.connection === void 0 || inventory.connection.type === "external") throw new OdbNoEmbeddedDataSourceError(inventory.connection?.url);
 	const url = inventory.connection.url;
@@ -65,21 +66,24 @@ function readOdbTables(pkg) {
 	if (scriptPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_SCRIPT_PART} is not a binary part (found kind "${scriptPart.kind}") -- malformed .odb package`);
 	const scriptBytes = (0, odf_js.base64ToBytes)(scriptPart.base64);
 	const classification = classifyScriptBytes(scriptBytes);
-	if (classification === "compressed") throw new OdbUnsupportedFormatError("hsqldb-compressed", "HSQLDB's compressed whole-script format (hsqldb.script_format=3) -- a zlib-wrapped copy of the same length-prefixed binary DDL/DML statement encoding hsqldb.script_format=1 uses, not compressed SQL text");
-	if (classification === "binary") throw new OdbUnsupportedFormatError("hsqldb-binary", "HSQLDB's binary whole-script format (hsqldb.script_format=1) -- a length-prefixed, COMMAND-tagged binary encoding of the script's own DDL/DML statements themselves, a materially different and larger undertaking than CACHED-table row-store decoding (Tier 2)");
-	return withCachedTableRows(pkg, require_hsqldb_script.parseHsqldbScript(scriptBytes), scriptBytes);
+	if (classification !== "text") {
+		const binaryBytes = classification === "compressed" ? require_hsqldb_binary_script.inflateHsqldbCompressedScript(scriptBytes) : scriptBytes;
+		const { scriptText, tables } = require_hsqldb_binary_script.parseHsqldbBinaryScript(binaryBytes, options);
+		return withCachedTableRows(pkg, tables, scriptText, options);
+	}
+	const scriptText = new TextDecoder("utf-8", { fatal: true }).decode(scriptBytes);
+	return withCachedTableRows(pkg, require_hsqldb_script.parseHsqldbScript(scriptBytes), scriptText, options);
 }
-function withCachedTableRows(pkg, tables, scriptBytes) {
+function withCachedTableRows(pkg, tables, scriptText, options) {
 	const dataPart = pkg.parts[DATABASE_DATA_PART];
 	if (dataPart === void 0) return tables;
 	if (dataPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_DATA_PART} is not a binary part (found kind "${dataPart.kind}") -- malformed .odb package`);
 	const propertiesPart = pkg.parts[DATABASE_PROPERTIES_PART];
 	if (propertiesPart === void 0) throw new Error(`readOdbTables: ${DATABASE_DATA_PART} is present but ${DATABASE_PROPERTIES_PART} is not -- malformed .odb package (a CACHED-table row store always ships alongside its own properties file, which this decoder needs for the cache file's own scale)`);
 	if (propertiesPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_PROPERTIES_PART} is not a binary part (found kind "${propertiesPart.kind}") -- malformed .odb package`);
-	const scriptText = new TextDecoder("utf-8", { fatal: true }).decode(scriptBytes);
 	const dataBytes = (0, odf_js.base64ToBytes)(dataPart.base64);
 	const propertiesText = new TextDecoder("utf-8", { fatal: true }).decode((0, odf_js.base64ToBytes)(propertiesPart.base64));
-	return require_hsqldb_cache.decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText);
+	return require_hsqldb_cache.decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText, options);
 }
 //#endregion
 exports.OdbNoEmbeddedDataSourceError = OdbNoEmbeddedDataSourceError;

package/dist/odb/read.d.cts

@@ -1,3 +1,4 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
 import { HsqldbTable } from "../hsqldb/script.cjs";
 import { Package } from "odf.js";
 //#region src/odb/read.d.ts
@@ -5,11 +6,11 @@ declare class OdbNoEmbeddedDataSourceError extends Error {
   readonly url: string | undefined;
   constructor(url: string | undefined);
 }
-type OdbUnsupportedFormat = 'hsqldb-binary' | 'hsqldb-compressed' | 'unrecognised-engine';
+type OdbUnsupportedFormat = 'unrecognised-engine';
 declare class OdbUnsupportedFormatError extends Error {
   readonly format: OdbUnsupportedFormat;
   constructor(format: OdbUnsupportedFormat, detail: string);
 }
-declare function readOdbTables(pkg: Package): readonly HsqldbTable[];
+declare function readOdbTables(pkg: Package, options?: HsqldbDecodeOptions): readonly HsqldbTable[];
 //#endregion
 export { OdbNoEmbeddedDataSourceError, OdbUnsupportedFormat, OdbUnsupportedFormatError, readOdbTables };

package/dist/odb/read.d.ts

@@ -1,3 +1,4 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.js";
 import { HsqldbTable } from "../hsqldb/script.js";
 import { Package } from "odf.js";
 //#region src/odb/read.d.ts
@@ -5,11 +6,11 @@ declare class OdbNoEmbeddedDataSourceError extends Error {
   readonly url: string | undefined;
   constructor(url: string | undefined);
 }
-type OdbUnsupportedFormat = 'hsqldb-binary' | 'hsqldb-compressed' | 'unrecognised-engine';
+type OdbUnsupportedFormat = 'unrecognised-engine';
 declare class OdbUnsupportedFormatError extends Error {
   readonly format: OdbUnsupportedFormat;
   constructor(format: OdbUnsupportedFormat, detail: string);
 }
-declare function readOdbTables(pkg: Package): readonly HsqldbTable[];
+declare function readOdbTables(pkg: Package, options?: HsqldbDecodeOptions): readonly HsqldbTable[];
 //#endregion
 export { OdbNoEmbeddedDataSourceError, OdbUnsupportedFormat, OdbUnsupportedFormatError, readOdbTables };

package/dist/odb/read.js

@@ -1,5 +1,6 @@
 import { readManifest } from "../odf-package/manifest.js";
 import { parseHsqldbScript } from "../hsqldb/script.js";
+import { inflateHsqldbCompressedScript, parseHsqldbBinaryScript } from "../hsqldb/binary-script.js";
 import { decodeHsqldbCachedTables } from "../hsqldb/cache.js";
 import { readFirebirdBackup } from "../firebird/backup.js";
 import { base64ToBytes, readOdbInventory } from "odf.js";
@@ -44,7 +45,7 @@ function classifyScriptBytes(bytes) {
 	}
 	return "text";
 }
-function readOdbTables(pkg) {
+function readOdbTables(pkg, options) {
 	const inventory = readOdbInventory(pkg);
 	if (inventory.connection === void 0 || inventory.connection.type === "external") throw new OdbNoEmbeddedDataSourceError(inventory.connection?.url);
 	const url = inventory.connection.url;
@@ -65,21 +66,24 @@ function readOdbTables(pkg) {
 	if (scriptPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_SCRIPT_PART} is not a binary part (found kind "${scriptPart.kind}") -- malformed .odb package`);
 	const scriptBytes = base64ToBytes(scriptPart.base64);
 	const classification = classifyScriptBytes(scriptBytes);
-	if (classification === "compressed") throw new OdbUnsupportedFormatError("hsqldb-compressed", "HSQLDB's compressed whole-script format (hsqldb.script_format=3) -- a zlib-wrapped copy of the same length-prefixed binary DDL/DML statement encoding hsqldb.script_format=1 uses, not compressed SQL text");
-	if (classification === "binary") throw new OdbUnsupportedFormatError("hsqldb-binary", "HSQLDB's binary whole-script format (hsqldb.script_format=1) -- a length-prefixed, COMMAND-tagged binary encoding of the script's own DDL/DML statements themselves, a materially different and larger undertaking than CACHED-table row-store decoding (Tier 2)");
-	return withCachedTableRows(pkg, parseHsqldbScript(scriptBytes), scriptBytes);
+	if (classification !== "text") {
+		const binaryBytes = classification === "compressed" ? inflateHsqldbCompressedScript(scriptBytes) : scriptBytes;
+		const { scriptText, tables } = parseHsqldbBinaryScript(binaryBytes, options);
+		return withCachedTableRows(pkg, tables, scriptText, options);
+	}
+	const scriptText = new TextDecoder("utf-8", { fatal: true }).decode(scriptBytes);
+	return withCachedTableRows(pkg, parseHsqldbScript(scriptBytes), scriptText, options);
 }
-function withCachedTableRows(pkg, tables, scriptBytes) {
+function withCachedTableRows(pkg, tables, scriptText, options) {
 	const dataPart = pkg.parts[DATABASE_DATA_PART];
 	if (dataPart === void 0) return tables;
 	if (dataPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_DATA_PART} is not a binary part (found kind "${dataPart.kind}") -- malformed .odb package`);
 	const propertiesPart = pkg.parts[DATABASE_PROPERTIES_PART];
 	if (propertiesPart === void 0) throw new Error(`readOdbTables: ${DATABASE_DATA_PART} is present but ${DATABASE_PROPERTIES_PART} is not -- malformed .odb package (a CACHED-table row store always ships alongside its own properties file, which this decoder needs for the cache file's own scale)`);
 	if (propertiesPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_PROPERTIES_PART} is not a binary part (found kind "${propertiesPart.kind}") -- malformed .odb package`);
-	const scriptText = new TextDecoder("utf-8", { fatal: true }).decode(scriptBytes);
 	const dataBytes = base64ToBytes(dataPart.base64);
 	const propertiesText = new TextDecoder("utf-8", { fatal: true }).decode(base64ToBytes(propertiesPart.base64));
-	return decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText);
+	return decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText, options);
 }
 //#endregion
 export { OdbNoEmbeddedDataSourceError, OdbUnsupportedFormatError, readOdbTables };

package/dist/odf/formula/detect.cjs

@@ -5,25 +5,93 @@ let odf_js = require("odf.js");
 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 = (0, odf_js.childrenWithTag)(child, "draw:object")[0];
-		if (objectElement === void 0) continue;
-		const href = (0, odf_js.attrValue)(objectElement, "xlink:href");
-		if (href === void 0) continue;
-		const formula = require_odf_formula_read.readOdfEmbeddedFormula(pkg, subPackagePathFromHref(href));
-		if (formula === void 0) continue;
-		const shape = (0, odf_js.readDrawFrame)(child, [], pkg);
-		if (shape === void 0) continue;
-		out.push({
-			frameElement: child,
-			formula,
-			frame: shape.frame
-		});
+function formulaOfFrame(frame, pkg) {
+	const objectElement = (0, odf_js.childrenWithTag)(frame, "draw:object")[0];
+	if (objectElement === void 0) return;
+	const href = (0, odf_js.attrValue)(objectElement, "xlink:href");
+	if (href === void 0) return;
+	return require_odf_formula_read.readOdfEmbeddedFormula(pkg, subPackagePathFromHref(href));
+}
+function flowAnchoredFrameBox(frame) {
+	const widthValue = (0, odf_js.attrValue)(frame, "svg:width");
+	const heightValue = (0, odf_js.attrValue)(frame, "svg:height");
+	if (widthValue === void 0 || heightValue === void 0) return;
+	const widthPt = (0, odf_js.parseOdfLength)(widthValue);
+	const heightPt = (0, odf_js.parseOdfLength)(heightValue);
+	if (widthPt === void 0 || heightPt === void 0) return;
+	return {
+		xPt: 0,
+		yPt: 0,
+		widthPt,
+		heightPt
+	};
+}
+function nestedGroupFunctions(group, groupFunctions) {
+	const value = (0, odf_js.attrValue)(group, "draw:transform");
+	const own = value === void 0 ? [] : (0, odf_js.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 = (0, odf_js.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 = (0, odf_js.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
-exports.detectEmbeddedFormulaFrames = detectEmbeddedFormulaFrames;
+exports.collectFormulaFrames = collectFormulaFrames;
+exports.collectSlideFormulaFrames = collectSlideFormulaFrames;

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 };