documents.js 1.61.0 → 1.63.0

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

package/dist/omml/write.cjs

@@ -0,0 +1,258 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_fragment = require("../xml/fragment.cjs");
+const require_mathml_length = require("../mathml/length.cjs");
+const require_mathml_nodes = require("../mathml/nodes.cjs");
+const require_mathml_operators = require("../mathml/operators.cjs");
+const require_mathml_variant = require("../mathml/variant.cjs");
+const require_xml_entities = require("../xml/entities.cjs");
+//#region src/omml/write.ts
+const OMML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+const VARIANT_RUN_PROPERTIES = {
+	normal: { sty: "p" },
+	bold: { sty: "b" },
+	italic: { sty: "i" },
+	"bold-italic": { sty: "bi" },
+	"double-struck": {
+		scr: "double-struck",
+		sty: "p"
+	},
+	script: {
+		scr: "script",
+		sty: "p"
+	},
+	"bold-script": {
+		scr: "script",
+		sty: "b"
+	},
+	fraktur: {
+		scr: "fraktur",
+		sty: "p"
+	},
+	"bold-fraktur": {
+		scr: "fraktur",
+		sty: "b"
+	},
+	"sans-serif": {
+		scr: "sans-serif",
+		sty: "p"
+	},
+	"bold-sans-serif": {
+		scr: "sans-serif",
+		sty: "b"
+	},
+	"sans-serif-italic": {
+		scr: "sans-serif",
+		sty: "i"
+	},
+	"sans-serif-bold-italic": {
+		scr: "sans-serif",
+		sty: "bi"
+	},
+	monospace: {
+		scr: "monospace",
+		sty: "p"
+	}
+};
+function columnJustification(align) {
+	return align === "left" || align === "right" || align === "center" ? align : "center";
+}
+function diagnose(ctx, kind, element) {
+	ctx.diagnostics.push({
+		kind,
+		detail: require_mathml_nodes.elementLocalName(element)
+	});
+}
+function mathRun(text, properties) {
+	const tAttrs = require_xml_entities.needsSpacePreserve(text) ? { "xml:space": "preserve" } : {};
+	const children = [];
+	if (properties !== void 0) children.push(properties);
+	children.push(require_xml_fragment.el("m:t", tAttrs, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(text))]));
+	return require_xml_fragment.el("m:r", {}, children);
+}
+function variantRunProperties(variant) {
+	const mapped = VARIANT_RUN_PROPERTIES[variant];
+	const children = [];
+	if (mapped.scr !== void 0) children.push(require_xml_fragment.el("m:scr", { "m:val": mapped.scr }));
+	children.push(require_xml_fragment.el("m:sty", { "m:val": mapped.sty }));
+	return require_xml_fragment.el("m:rPr", {}, children);
+}
+function miIntrinsicDefault(content) {
+	return [...content].length === 1 ? "italic" : "normal";
+}
+function tokenVariant(element, intrinsicDefault, ctx) {
+	const attr = require_mathml_nodes.attrValue(element, "mathvariant");
+	if (attr !== void 0 && require_mathml_variant.isMathVariant(attr)) return attr;
+	return ctx.inheritedVariant ?? intrinsicDefault;
+}
+function tokenRun(element, rawText, intrinsicDefault, ctx, normalText) {
+	if (rawText.length === 0) return [];
+	if (normalText && require_mathml_nodes.attrValue(element, "mathvariant") === void 0) return [mathRun(rawText, require_xml_fragment.el("m:rPr", {}, [require_xml_fragment.el("m:nor")]))];
+	return [mathRun(rawText, variantRunProperties(tokenVariant(element, intrinsicDefault, ctx)))];
+}
+function argSlot(tag, child, ctx) {
+	return require_xml_fragment.el(tag, {}, child === void 0 ? [] : convertElement(child, ctx));
+}
+function argSlotFromChildren(tag, children, ctx) {
+	return require_xml_fragment.el(tag, {}, children.flatMap((child) => convertElement(child, ctx)));
+}
+function convertFraction(element, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	const lineThickness = require_mathml_nodes.attrValue(element, "linethickness");
+	const barless = lineThickness !== void 0 && require_mathml_length.parseMathLength(lineThickness, 1) === 0;
+	const parts = [];
+	if (barless) parts.push(require_xml_fragment.el("m:fPr", {}, [require_xml_fragment.el("m:type", { "m:val": "noBar" })]));
+	parts.push(argSlot("m:num", children[0], ctx), argSlot("m:den", children[1], ctx));
+	return require_xml_fragment.el("m:f", {}, parts);
+}
+function convertRadical(element, kind, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	if (kind === "msqrt") return require_xml_fragment.el("m:rad", {}, [
+		require_xml_fragment.el("m:radPr", {}, [require_xml_fragment.el("m:degHide", { "m:val": "1" })]),
+		require_xml_fragment.el("m:deg"),
+		argSlotFromChildren("m:e", children, ctx)
+	]);
+	return require_xml_fragment.el("m:rad", {}, [argSlot("m:deg", children[1], ctx), argSlot("m:e", children[0], ctx)]);
+}
+function convertScripts(element, kind, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	const base = argSlot("m:e", children[0], ctx);
+	if (kind === "msub") return require_xml_fragment.el("m:sSub", {}, [base, argSlot("m:sub", children[1], ctx)]);
+	if (kind === "msup") return require_xml_fragment.el("m:sSup", {}, [base, argSlot("m:sup", children[1], ctx)]);
+	return require_xml_fragment.el("m:sSubSup", {}, [
+		base,
+		argSlot("m:sub", children[1], ctx),
+		argSlot("m:sup", children[2], ctx)
+	]);
+}
+function isMovableLimitsOperator(element) {
+	return element !== void 0 && require_mathml_nodes.elementLocalName(element) === "mo" && require_mathml_operators.operatorProperties(require_mathml_nodes.textContent(element).trim()).movablelimits;
+}
+function convertUnderOver(element, kind, ctx) {
+	const children = require_mathml_nodes.elementChildren(element);
+	if (!ctx.displayStyle && isMovableLimitsOperator(children[0])) return convertScripts(element, kind === "munder" ? "msub" : kind === "mover" ? "msup" : "msubsup", ctx);
+	if (kind === "munder") return require_xml_fragment.el("m:limLow", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	if (kind === "mover") return require_xml_fragment.el("m:limUpp", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	const lower = require_xml_fragment.el("m:limLow", {}, [argSlot("m:e", children[0], ctx), argSlot("m:lim", children[1], ctx)]);
+	return require_xml_fragment.el("m:limUpp", {}, [require_xml_fragment.el("m:e", {}, [lower]), argSlot("m:lim", children[2], ctx)]);
+}
+function convertTable(element, ctx) {
+	const rows = require_mathml_nodes.elementChildren(element).filter((child) => require_mathml_nodes.elementLocalName(child) === "mtr");
+	const columnAligns = (require_mathml_nodes.attrValue(element, "columnalign") ?? "").trim().split(/\s+/).filter((token) => token.length > 0);
+	const rowCells = rows.map((row) => require_mathml_nodes.elementChildren(row).filter((child) => require_mathml_nodes.elementLocalName(child) === "mtd"));
+	const columnCount = rowCells.reduce((max, cells) => Math.max(max, cells.length), 0);
+	const children = [];
+	if (columnCount > 0) {
+		const columns = [];
+		for (let column = 0; column < columnCount; column++) {
+			const align = columnJustification(columnAligns[column] ?? columnAligns[columnAligns.length - 1]);
+			columns.push(require_xml_fragment.el("m:mc", {}, [require_xml_fragment.el("m:mcPr", {}, [require_xml_fragment.el("m:count", { "m:val": "1" }), require_xml_fragment.el("m:mcJc", { "m:val": align })])]));
+		}
+		children.push(require_xml_fragment.el("m:mPr", {}, [require_xml_fragment.el("m:mcs", {}, columns)]));
+	}
+	for (const cells of rowCells) {
+		const slots = cells.map((cell) => argSlotFromChildren("m:e", require_mathml_nodes.elementChildren(cell), ctx));
+		children.push(require_xml_fragment.el("m:mr", {}, slots.length === 0 ? [require_xml_fragment.el("m:e")] : slots));
+	}
+	return require_xml_fragment.el("m:m", {}, children);
+}
+function convertSpace(element, ctx) {
+	const width = require_mathml_nodes.attrValue(element, "width");
+	const widthValue = width === void 0 ? void 0 : require_mathml_length.parseMathLength(width, 1);
+	if (widthValue === void 0 || widthValue <= 0) return [];
+	diagnose(ctx, "approximated-element", element);
+	return [mathRun(" ", require_xml_fragment.el("m:rPr", {}, [require_xml_fragment.el("m:nor")]))];
+}
+function convertSemantics(element, ctx) {
+	const content = require_mathml_nodes.elementChildren(element).find((child) => {
+		const name = require_mathml_nodes.elementLocalName(child);
+		return name !== "annotation" && name !== "annotation-xml";
+	});
+	return content === void 0 ? [] : convertElement(content, ctx);
+}
+function mstyleContext(element, ctx) {
+	let next = ctx;
+	const displayAttr = require_mathml_nodes.attrValue(element, "displaystyle");
+	if (displayAttr === "true" || displayAttr === "false") next = {
+		...next,
+		displayStyle: displayAttr === "true"
+	};
+	const variantAttr = require_mathml_nodes.attrValue(element, "mathvariant");
+	if (variantAttr !== void 0 && require_mathml_variant.isMathVariant(variantAttr)) next = {
+		...next,
+		inheritedVariant: variantAttr
+	};
+	return next;
+}
+function convertElement(node, ctx) {
+	const name = require_mathml_nodes.elementLocalName(node);
+	switch (name) {
+		case "mrow": return convertNodes(node.children, ctx);
+		case "mstyle": return convertNodes(node.children, mstyleContext(node, ctx));
+		case "semantics": return convertSemantics(node, ctx);
+		case "mi": {
+			const text = require_mathml_nodes.textContent(node);
+			return tokenRun(node, text, miIntrinsicDefault(text), ctx, false);
+		}
+		case "mn": return tokenRun(node, require_mathml_nodes.textContent(node), "normal", ctx, false);
+		case "mo": return tokenRun(node, require_mathml_nodes.textContent(node).trim(), "normal", ctx, false);
+		case "mtext": return tokenRun(node, require_mathml_nodes.textContent(node), "normal", ctx, true);
+		case "mspace": return convertSpace(node, ctx);
+		case "mfrac": return [convertFraction(node, ctx)];
+		case "msqrt": return [convertRadical(node, "msqrt", ctx)];
+		case "mroot": return [convertRadical(node, "mroot", ctx)];
+		case "msub":
+		case "msup":
+		case "msubsup": return [convertScripts(node, name, ctx)];
+		case "munder":
+		case "mover":
+		case "munderover": return [convertUnderOver(node, name, ctx)];
+		case "mtable": return [convertTable(node, ctx)];
+		case "mtr":
+		case "mtd": return convertNodes(node.children, ctx);
+		default:
+			diagnose(ctx, "unsupported-element", node);
+			return tokenRun(node, require_mathml_nodes.textContent(node), "normal", ctx, true);
+	}
+}
+function convertNodes(nodes, ctx) {
+	const out = [];
+	for (const node of nodes) {
+		if (!require_mathml_nodes.isMathMlElement(node)) continue;
+		out.push(...convertElement(node, ctx));
+	}
+	return out;
+}
+function rootContext(diagnostics) {
+	return {
+		inheritedVariant: void 0,
+		displayStyle: true,
+		diagnostics
+	};
+}
+function buildOfficeMath(mathml) {
+	const diagnostics = [];
+	const children = convertNodes(mathml, rootContext(diagnostics));
+	if (children.length === 0) return {
+		element: void 0,
+		diagnostics
+	};
+	return {
+		element: require_xml_fragment.el("m:oMath", { "xmlns:m": OMML_NS }, children),
+		diagnostics
+	};
+}
+function buildOfficeMathParagraph(mathml) {
+	const diagnostics = [];
+	const children = convertNodes(mathml, rootContext(diagnostics));
+	if (children.length === 0) return {
+		element: void 0,
+		diagnostics
+	};
+	return {
+		element: require_xml_fragment.el("m:oMathPara", { "xmlns:m": OMML_NS }, [require_xml_fragment.el("m:oMath", {}, children)]),
+		diagnostics
+	};
+}
+//#endregion
+exports.buildOfficeMath = buildOfficeMath;
+exports.buildOfficeMathParagraph = buildOfficeMathParagraph;

package/dist/omml/write.d.cts

@@ -0,0 +1,2 @@
+import { a as buildOfficeMathParagraph, i as buildOfficeMath, n as OmmlDiagnosticKind, r as OmmlWriteResult, t as OmmlDiagnostic } from "../write-DuyfnbL_.cjs";
+export { OmmlDiagnostic, OmmlDiagnosticKind, OmmlWriteResult, buildOfficeMath, buildOfficeMathParagraph };

package/dist/omml/write.d.ts

@@ -0,0 +1,2 @@
+import { a as buildOfficeMathParagraph, i as buildOfficeMath, n as OmmlDiagnosticKind, r as OmmlWriteResult, t as OmmlDiagnostic } from "../write-Zqwx6pka.js";
+export { OmmlDiagnostic, OmmlDiagnosticKind, OmmlWriteResult, buildOfficeMath, buildOfficeMathParagraph };