documents.js 1.63.0 → 1.64.0

package/dist/omml/read.cjs

@@ -0,0 +1,265 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_mathml_nodes = require("../mathml/nodes.cjs");
+const require_omml_shared = require("./shared.cjs");
+let ooxml_js = require("ooxml.js");
+//#region src/omml/read.ts
+const ARGUMENT_SLOTS = /* @__PURE__ */ new Set([
+	"e",
+	"num",
+	"den",
+	"sub",
+	"sup",
+	"lim",
+	"deg",
+	"fName"
+]);
+function isPropertiesElement(name) {
+	return name.endsWith("Pr");
+}
+function elementLocalName(element) {
+	return require_mathml_nodes.localName(element.tag);
+}
+function elementChildren(element) {
+	return element.children.filter((child) => child.type === "element");
+}
+function childByLocalName(element, name) {
+	return element === void 0 ? void 0 : elementChildren(element).find((child) => elementLocalName(child) === name);
+}
+function childrenByLocalName(element, name) {
+	return elementChildren(element).filter((child) => elementLocalName(child) === name);
+}
+function attrByLocalName(element, name) {
+	const raw = element?.attributes.find((attribute) => require_mathml_nodes.localName(attribute.name) === name)?.value;
+	return raw === void 0 ? void 0 : (0, ooxml_js.decodeEntities)(raw);
+}
+function propertyValue(properties, name) {
+	return attrByLocalName(childByLocalName(properties, name), "val");
+}
+function isPropertyOn(properties, name) {
+	const element = childByLocalName(properties, name);
+	if (element === void 0) return false;
+	const value = attrByLocalName(element, "val");
+	return value === void 0 || value === "1" || value === "true" || value === "on";
+}
+function textOf(node) {
+	if (node.type === "text") return (0, ooxml_js.decodeEntities)(node.value);
+	if (node.type !== "element") return "";
+	let out = "";
+	for (const child of node.children) out += textOf(child);
+	return out;
+}
+function mathElement(tag, attributes, children) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attributes).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function mathToken(tag, attributes, text) {
+	return mathElement(tag, attributes, [{
+		type: "text",
+		value: text
+	}]);
+}
+function operator(character) {
+	return mathToken("mo", {}, character);
+}
+function diagnose(ctx, kind, element) {
+	ctx.diagnostics.push({
+		kind,
+		detail: elementLocalName(element)
+	});
+}
+const NUMBER_RUN = /^\d+(?:[.,]\d+)?$/u;
+const LETTER_RUN = /^\p{L}+$/u;
+const SYMBOL_RUN = /^[^\p{L}\p{N}\s]+$/u;
+function tokenTag(text) {
+	if (NUMBER_RUN.test(text)) return "mn";
+	if (LETTER_RUN.test(text)) return "mi";
+	return SYMBOL_RUN.test(text) ? "mo" : "mi";
+}
+function convertRun(run, ctx) {
+	const text = childrenByLocalName(run, "t").map((t) => textOf(t)).join("");
+	if (text.length === 0) return [];
+	const properties = childByLocalName(run, "rPr");
+	if (isPropertyOn(properties, "nor")) return [mathToken("mtext", {}, text)];
+	const script = propertyValue(properties, "scr");
+	const style = propertyValue(properties, "sty");
+	const variant = require_omml_shared.variantFromRunProperties(script, style);
+	if (variant === void 0) diagnose(ctx, "approximated-element", run);
+	const tag = tokenTag(text);
+	const intrinsic = tag === "mi" ? require_omml_shared.miIntrinsicDefault(text) : "normal";
+	return [mathToken(tag, variant !== void 0 && variant !== intrinsic ? { mathvariant: variant } : {}, text)];
+}
+function slotArgument(parent, slot, ctx) {
+	const nodes = slotContent(parent, slot, ctx);
+	const [only] = nodes;
+	return nodes.length === 1 && only !== void 0 ? only : mathElement("mrow", {}, nodes);
+}
+function slotContent(parent, slot, ctx) {
+	const element = childByLocalName(parent, slot);
+	return element === void 0 ? [] : convertNodes(element.children, ctx);
+}
+function convertFraction(element, ctx) {
+	return mathElement("mfrac", propertyValue(childByLocalName(element, "fPr"), "type") === "noBar" ? { linethickness: "0" } : {}, [slotArgument(element, "num", ctx), slotArgument(element, "den", ctx)]);
+}
+function convertRadical(element, ctx) {
+	const degree = childByLocalName(element, "deg");
+	if (isPropertyOn(childByLocalName(element, "radPr"), "degHide") || degree === void 0 || elementChildren(degree).length === 0) return mathElement("msqrt", {}, slotContent(element, "e", ctx));
+	return mathElement("mroot", {}, [slotArgument(element, "e", ctx), slotArgument(element, "deg", ctx)]);
+}
+function nestedLimLow(element) {
+	const base = childByLocalName(element, "e");
+	if (base === void 0) return;
+	const children = elementChildren(base);
+	const [only] = children;
+	return children.length === 1 && only !== void 0 && elementLocalName(only) === "limLow" ? only : void 0;
+}
+function convertDelimiter(element, ctx) {
+	const properties = childByLocalName(element, "dPr");
+	const beginChar = propertyValue(properties, "begChr") ?? "(";
+	const endChar = propertyValue(properties, "endChr") ?? ")";
+	const separatorChar = propertyValue(properties, "sepChr") ?? "|";
+	const children = [];
+	if (beginChar.length > 0) children.push(operator(beginChar));
+	childrenByLocalName(element, "e").forEach((slot, index) => {
+		if (index > 0 && separatorChar.length > 0) children.push(operator(separatorChar));
+		children.push(...convertNodes(slot.children, ctx));
+	});
+	if (endChar.length > 0) children.push(operator(endChar));
+	return mathElement("mrow", {}, children);
+}
+function convertNary(element, ctx) {
+	const properties = childByLocalName(element, "naryPr");
+	const character = propertyValue(properties, "chr") ?? "∫";
+	const underOver = propertyValue(properties, "limLoc") === "undOvr";
+	const hasLower = !isPropertyOn(properties, "subHide");
+	const hasUpper = !isPropertyOn(properties, "supHide");
+	const base = operator(character);
+	let scripted = base;
+	if (hasLower && hasUpper) scripted = mathElement(underOver ? "munderover" : "msubsup", {}, [
+		base,
+		slotArgument(element, "sub", ctx),
+		slotArgument(element, "sup", ctx)
+	]);
+	else if (hasLower) scripted = mathElement(underOver ? "munder" : "msub", {}, [base, slotArgument(element, "sub", ctx)]);
+	else if (hasUpper) scripted = mathElement(underOver ? "mover" : "msup", {}, [base, slotArgument(element, "sup", ctx)]);
+	return mathElement("mrow", {}, [scripted, ...slotContent(element, "e", ctx)]);
+}
+function convertAccent(element, ctx) {
+	const character = propertyValue(childByLocalName(element, "accPr"), "chr") ?? "̂";
+	return mathElement("mover", { accent: "true" }, [slotArgument(element, "e", ctx), operator(character)]);
+}
+function convertBar(element, ctx) {
+	const top = propertyValue(childByLocalName(element, "barPr"), "pos") === "top";
+	return mathElement(top ? "mover" : "munder", { accent: "true" }, [slotArgument(element, "e", ctx), operator(top ? "‾" : "_")]);
+}
+function convertMatrix(element, ctx) {
+	const columns = childByLocalName(childByLocalName(element, "mPr"), "mcs");
+	const alignments = [];
+	for (const column of columns === void 0 ? [] : childrenByLocalName(columns, "mc")) {
+		const properties = childByLocalName(column, "mcPr");
+		const justification = propertyValue(properties, "mcJc") ?? "center";
+		const count = Number.parseInt(propertyValue(properties, "count") ?? "1", 10);
+		for (let index = 0; index < (Number.isFinite(count) && count > 0 ? count : 1); index++) alignments.push(justification);
+	}
+	const rows = childrenByLocalName(element, "mr").map((row) => mathElement("mtr", {}, childrenByLocalName(row, "e").map((cell) => mathElement("mtd", {}, convertNodes(cell.children, ctx)))));
+	return mathElement("mtable", alignments.some((alignment) => alignment !== "center") ? { columnalign: alignments.join(" ") } : {}, rows);
+}
+function convertUnknownContainer(element, ctx) {
+	const slots = elementChildren(element).filter((child) => ARGUMENT_SLOTS.has(elementLocalName(child)));
+	if (slots.length > 0) {
+		diagnose(ctx, "approximated-element", element);
+		return [mathElement("mrow", {}, slots.flatMap((slot) => convertNodes(slot.children, ctx)))];
+	}
+	diagnose(ctx, "unsupported-element", element);
+	const text = textOf(element);
+	return text.length === 0 ? [] : [mathToken("mtext", {}, text)];
+}
+function convertElement(element, ctx) {
+	const name = elementLocalName(element);
+	if (isPropertiesElement(name)) return [];
+	switch (name) {
+		case "oMathPara":
+		case "oMath": return convertNodes(element.children, ctx);
+		case "r": return convertRun(element, ctx);
+		case "f": return [convertFraction(element, ctx)];
+		case "rad": return [convertRadical(element, ctx)];
+		case "sSub": return [mathElement("msub", {}, [slotArgument(element, "e", ctx), slotArgument(element, "sub", ctx)])];
+		case "sSup": return [mathElement("msup", {}, [slotArgument(element, "e", ctx), slotArgument(element, "sup", ctx)])];
+		case "sSubSup": return [mathElement("msubsup", {}, [
+			slotArgument(element, "e", ctx),
+			slotArgument(element, "sub", ctx),
+			slotArgument(element, "sup", ctx)
+		])];
+		case "sPre": return [mathElement("mmultiscripts", {}, [
+			slotArgument(element, "e", ctx),
+			mathElement("mprescripts", {}, []),
+			slotArgument(element, "sub", ctx),
+			slotArgument(element, "sup", ctx)
+		])];
+		case "limLow": return [mathElement("munder", {}, [slotArgument(element, "e", ctx), slotArgument(element, "lim", ctx)])];
+		case "limUpp": {
+			const inner = nestedLimLow(element);
+			if (inner !== void 0) return [mathElement("munderover", {}, [
+				slotArgument(inner, "e", ctx),
+				slotArgument(inner, "lim", ctx),
+				slotArgument(element, "lim", ctx)
+			])];
+			return [mathElement("mover", {}, [slotArgument(element, "e", ctx), slotArgument(element, "lim", ctx)])];
+		}
+		case "m": return [convertMatrix(element, ctx)];
+		case "d": return [convertDelimiter(element, ctx)];
+		case "nary": return [convertNary(element, ctx)];
+		case "acc": return [convertAccent(element, ctx)];
+		case "bar": return [convertBar(element, ctx)];
+		case "func": return [mathElement("mrow", {}, [...slotContent(element, "fName", ctx), ...slotContent(element, "e", ctx)])];
+		case "e":
+		case "num":
+		case "den":
+		case "sub":
+		case "sup":
+		case "lim":
+		case "deg":
+		case "fName":
+		case "mr": return convertNodes(element.children, ctx);
+		default: return convertUnknownContainer(element, ctx);
+	}
+}
+function convertNodes(nodes, ctx) {
+	const out = [];
+	for (const node of nodes) {
+		if (node.type !== "element") continue;
+		out.push(...convertElement(node, ctx));
+	}
+	return out;
+}
+function readOfficeMath(element) {
+	const diagnostics = [];
+	return {
+		mathml: convertNodes([element], { diagnostics }),
+		diagnostics
+	};
+}
+function collectOfficeMathElements(nodes) {
+	const out = [];
+	const walk = (candidates) => {
+		for (const node of candidates) {
+			if (node.type !== "element") continue;
+			if (require_mathml_nodes.localName(node.tag) === "oMath") {
+				out.push(node);
+				continue;
+			}
+			walk(node.children);
+		}
+	};
+	walk(nodes);
+	return out;
+}
+//#endregion
+exports.collectOfficeMathElements = collectOfficeMathElements;
+exports.readOfficeMath = readOfficeMath;

package/dist/omml/read.d.cts

@@ -0,0 +1,12 @@
+import { t as OmmlDiagnostic } from "../shared-DLZ3IQUl.cjs";
+import { MathMlNode } from "document-schema.js";
+import { XmlElement, XmlNode } from "ooxml.js";
+//#region src/omml/read.d.ts
+interface OmmlReadResult {
+  readonly mathml: MathMlNode[];
+  readonly diagnostics: readonly OmmlDiagnostic[];
+}
+declare function readOfficeMath(element: XmlElement): OmmlReadResult;
+declare function collectOfficeMathElements(nodes: readonly XmlNode[]): readonly XmlElement[];
+//#endregion
+export { OmmlReadResult, collectOfficeMathElements, readOfficeMath };

package/dist/omml/read.d.ts

@@ -0,0 +1,12 @@
+import { t as OmmlDiagnostic } from "../shared-DUOzjwcL.js";
+import { XmlElement, XmlNode } from "ooxml.js";
+import { MathMlNode } from "document-schema.js";
+//#region src/omml/read.d.ts
+interface OmmlReadResult {
+  readonly mathml: MathMlNode[];
+  readonly diagnostics: readonly OmmlDiagnostic[];
+}
+declare function readOfficeMath(element: XmlElement): OmmlReadResult;
+declare function collectOfficeMathElements(nodes: readonly XmlNode[]): readonly XmlElement[];
+//#endregion
+export { OmmlReadResult, collectOfficeMathElements, readOfficeMath };

package/dist/omml/read.js

@@ -0,0 +1,263 @@
+import { localName } from "../mathml/nodes.js";
+import { miIntrinsicDefault, variantFromRunProperties } from "./shared.js";
+import { decodeEntities } from "ooxml.js";
+//#region src/omml/read.ts
+const ARGUMENT_SLOTS = /* @__PURE__ */ new Set([
+	"e",
+	"num",
+	"den",
+	"sub",
+	"sup",
+	"lim",
+	"deg",
+	"fName"
+]);
+function isPropertiesElement(name) {
+	return name.endsWith("Pr");
+}
+function elementLocalName(element) {
+	return localName(element.tag);
+}
+function elementChildren(element) {
+	return element.children.filter((child) => child.type === "element");
+}
+function childByLocalName(element, name) {
+	return element === void 0 ? void 0 : elementChildren(element).find((child) => elementLocalName(child) === name);
+}
+function childrenByLocalName(element, name) {
+	return elementChildren(element).filter((child) => elementLocalName(child) === name);
+}
+function attrByLocalName(element, name) {
+	const raw = element?.attributes.find((attribute) => localName(attribute.name) === name)?.value;
+	return raw === void 0 ? void 0 : decodeEntities(raw);
+}
+function propertyValue(properties, name) {
+	return attrByLocalName(childByLocalName(properties, name), "val");
+}
+function isPropertyOn(properties, name) {
+	const element = childByLocalName(properties, name);
+	if (element === void 0) return false;
+	const value = attrByLocalName(element, "val");
+	return value === void 0 || value === "1" || value === "true" || value === "on";
+}
+function textOf(node) {
+	if (node.type === "text") return decodeEntities(node.value);
+	if (node.type !== "element") return "";
+	let out = "";
+	for (const child of node.children) out += textOf(child);
+	return out;
+}
+function mathElement(tag, attributes, children) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attributes).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function mathToken(tag, attributes, text) {
+	return mathElement(tag, attributes, [{
+		type: "text",
+		value: text
+	}]);
+}
+function operator(character) {
+	return mathToken("mo", {}, character);
+}
+function diagnose(ctx, kind, element) {
+	ctx.diagnostics.push({
+		kind,
+		detail: elementLocalName(element)
+	});
+}
+const NUMBER_RUN = /^\d+(?:[.,]\d+)?$/u;
+const LETTER_RUN = /^\p{L}+$/u;
+const SYMBOL_RUN = /^[^\p{L}\p{N}\s]+$/u;
+function tokenTag(text) {
+	if (NUMBER_RUN.test(text)) return "mn";
+	if (LETTER_RUN.test(text)) return "mi";
+	return SYMBOL_RUN.test(text) ? "mo" : "mi";
+}
+function convertRun(run, ctx) {
+	const text = childrenByLocalName(run, "t").map((t) => textOf(t)).join("");
+	if (text.length === 0) return [];
+	const properties = childByLocalName(run, "rPr");
+	if (isPropertyOn(properties, "nor")) return [mathToken("mtext", {}, text)];
+	const script = propertyValue(properties, "scr");
+	const style = propertyValue(properties, "sty");
+	const variant = variantFromRunProperties(script, style);
+	if (variant === void 0) diagnose(ctx, "approximated-element", run);
+	const tag = tokenTag(text);
+	const intrinsic = tag === "mi" ? miIntrinsicDefault(text) : "normal";
+	return [mathToken(tag, variant !== void 0 && variant !== intrinsic ? { mathvariant: variant } : {}, text)];
+}
+function slotArgument(parent, slot, ctx) {
+	const nodes = slotContent(parent, slot, ctx);
+	const [only] = nodes;
+	return nodes.length === 1 && only !== void 0 ? only : mathElement("mrow", {}, nodes);
+}
+function slotContent(parent, slot, ctx) {
+	const element = childByLocalName(parent, slot);
+	return element === void 0 ? [] : convertNodes(element.children, ctx);
+}
+function convertFraction(element, ctx) {
+	return mathElement("mfrac", propertyValue(childByLocalName(element, "fPr"), "type") === "noBar" ? { linethickness: "0" } : {}, [slotArgument(element, "num", ctx), slotArgument(element, "den", ctx)]);
+}
+function convertRadical(element, ctx) {
+	const degree = childByLocalName(element, "deg");
+	if (isPropertyOn(childByLocalName(element, "radPr"), "degHide") || degree === void 0 || elementChildren(degree).length === 0) return mathElement("msqrt", {}, slotContent(element, "e", ctx));
+	return mathElement("mroot", {}, [slotArgument(element, "e", ctx), slotArgument(element, "deg", ctx)]);
+}
+function nestedLimLow(element) {
+	const base = childByLocalName(element, "e");
+	if (base === void 0) return;
+	const children = elementChildren(base);
+	const [only] = children;
+	return children.length === 1 && only !== void 0 && elementLocalName(only) === "limLow" ? only : void 0;
+}
+function convertDelimiter(element, ctx) {
+	const properties = childByLocalName(element, "dPr");
+	const beginChar = propertyValue(properties, "begChr") ?? "(";
+	const endChar = propertyValue(properties, "endChr") ?? ")";
+	const separatorChar = propertyValue(properties, "sepChr") ?? "|";
+	const children = [];
+	if (beginChar.length > 0) children.push(operator(beginChar));
+	childrenByLocalName(element, "e").forEach((slot, index) => {
+		if (index > 0 && separatorChar.length > 0) children.push(operator(separatorChar));
+		children.push(...convertNodes(slot.children, ctx));
+	});
+	if (endChar.length > 0) children.push(operator(endChar));
+	return mathElement("mrow", {}, children);
+}
+function convertNary(element, ctx) {
+	const properties = childByLocalName(element, "naryPr");
+	const character = propertyValue(properties, "chr") ?? "∫";
+	const underOver = propertyValue(properties, "limLoc") === "undOvr";
+	const hasLower = !isPropertyOn(properties, "subHide");
+	const hasUpper = !isPropertyOn(properties, "supHide");
+	const base = operator(character);
+	let scripted = base;
+	if (hasLower && hasUpper) scripted = mathElement(underOver ? "munderover" : "msubsup", {}, [
+		base,
+		slotArgument(element, "sub", ctx),
+		slotArgument(element, "sup", ctx)
+	]);
+	else if (hasLower) scripted = mathElement(underOver ? "munder" : "msub", {}, [base, slotArgument(element, "sub", ctx)]);
+	else if (hasUpper) scripted = mathElement(underOver ? "mover" : "msup", {}, [base, slotArgument(element, "sup", ctx)]);
+	return mathElement("mrow", {}, [scripted, ...slotContent(element, "e", ctx)]);
+}
+function convertAccent(element, ctx) {
+	const character = propertyValue(childByLocalName(element, "accPr"), "chr") ?? "̂";
+	return mathElement("mover", { accent: "true" }, [slotArgument(element, "e", ctx), operator(character)]);
+}
+function convertBar(element, ctx) {
+	const top = propertyValue(childByLocalName(element, "barPr"), "pos") === "top";
+	return mathElement(top ? "mover" : "munder", { accent: "true" }, [slotArgument(element, "e", ctx), operator(top ? "‾" : "_")]);
+}
+function convertMatrix(element, ctx) {
+	const columns = childByLocalName(childByLocalName(element, "mPr"), "mcs");
+	const alignments = [];
+	for (const column of columns === void 0 ? [] : childrenByLocalName(columns, "mc")) {
+		const properties = childByLocalName(column, "mcPr");
+		const justification = propertyValue(properties, "mcJc") ?? "center";
+		const count = Number.parseInt(propertyValue(properties, "count") ?? "1", 10);
+		for (let index = 0; index < (Number.isFinite(count) && count > 0 ? count : 1); index++) alignments.push(justification);
+	}
+	const rows = childrenByLocalName(element, "mr").map((row) => mathElement("mtr", {}, childrenByLocalName(row, "e").map((cell) => mathElement("mtd", {}, convertNodes(cell.children, ctx)))));
+	return mathElement("mtable", alignments.some((alignment) => alignment !== "center") ? { columnalign: alignments.join(" ") } : {}, rows);
+}
+function convertUnknownContainer(element, ctx) {
+	const slots = elementChildren(element).filter((child) => ARGUMENT_SLOTS.has(elementLocalName(child)));
+	if (slots.length > 0) {
+		diagnose(ctx, "approximated-element", element);
+		return [mathElement("mrow", {}, slots.flatMap((slot) => convertNodes(slot.children, ctx)))];
+	}
+	diagnose(ctx, "unsupported-element", element);
+	const text = textOf(element);
+	return text.length === 0 ? [] : [mathToken("mtext", {}, text)];
+}
+function convertElement(element, ctx) {
+	const name = elementLocalName(element);
+	if (isPropertiesElement(name)) return [];
+	switch (name) {
+		case "oMathPara":
+		case "oMath": return convertNodes(element.children, ctx);
+		case "r": return convertRun(element, ctx);
+		case "f": return [convertFraction(element, ctx)];
+		case "rad": return [convertRadical(element, ctx)];
+		case "sSub": return [mathElement("msub", {}, [slotArgument(element, "e", ctx), slotArgument(element, "sub", ctx)])];
+		case "sSup": return [mathElement("msup", {}, [slotArgument(element, "e", ctx), slotArgument(element, "sup", ctx)])];
+		case "sSubSup": return [mathElement("msubsup", {}, [
+			slotArgument(element, "e", ctx),
+			slotArgument(element, "sub", ctx),
+			slotArgument(element, "sup", ctx)
+		])];
+		case "sPre": return [mathElement("mmultiscripts", {}, [
+			slotArgument(element, "e", ctx),
+			mathElement("mprescripts", {}, []),
+			slotArgument(element, "sub", ctx),
+			slotArgument(element, "sup", ctx)
+		])];
+		case "limLow": return [mathElement("munder", {}, [slotArgument(element, "e", ctx), slotArgument(element, "lim", ctx)])];
+		case "limUpp": {
+			const inner = nestedLimLow(element);
+			if (inner !== void 0) return [mathElement("munderover", {}, [
+				slotArgument(inner, "e", ctx),
+				slotArgument(inner, "lim", ctx),
+				slotArgument(element, "lim", ctx)
+			])];
+			return [mathElement("mover", {}, [slotArgument(element, "e", ctx), slotArgument(element, "lim", ctx)])];
+		}
+		case "m": return [convertMatrix(element, ctx)];
+		case "d": return [convertDelimiter(element, ctx)];
+		case "nary": return [convertNary(element, ctx)];
+		case "acc": return [convertAccent(element, ctx)];
+		case "bar": return [convertBar(element, ctx)];
+		case "func": return [mathElement("mrow", {}, [...slotContent(element, "fName", ctx), ...slotContent(element, "e", ctx)])];
+		case "e":
+		case "num":
+		case "den":
+		case "sub":
+		case "sup":
+		case "lim":
+		case "deg":
+		case "fName":
+		case "mr": return convertNodes(element.children, ctx);
+		default: return convertUnknownContainer(element, ctx);
+	}
+}
+function convertNodes(nodes, ctx) {
+	const out = [];
+	for (const node of nodes) {
+		if (node.type !== "element") continue;
+		out.push(...convertElement(node, ctx));
+	}
+	return out;
+}
+function readOfficeMath(element) {
+	const diagnostics = [];
+	return {
+		mathml: convertNodes([element], { diagnostics }),
+		diagnostics
+	};
+}
+function collectOfficeMathElements(nodes) {
+	const out = [];
+	const walk = (candidates) => {
+		for (const node of candidates) {
+			if (node.type !== "element") continue;
+			if (localName(node.tag) === "oMath") {
+				out.push(node);
+				continue;
+			}
+			walk(node.children);
+		}
+	};
+	walk(nodes);
+	return out;
+}
+//#endregion
+export { collectOfficeMathElements, readOfficeMath };

package/dist/omml/shared.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_mathml_variant = require("../mathml/variant.cjs");
+//#region src/omml/shared.ts
+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"
+	}
+};
+const DEFAULT_SCRIPT = "roman";
+const DEFAULT_STYLE = "i";
+function buildVariantLookup() {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const [variant, mapped] of Object.entries(VARIANT_RUN_PROPERTIES)) if (require_mathml_variant.isMathVariant(variant)) lookup.set(`${mapped.scr ?? DEFAULT_SCRIPT}|${mapped.sty}`, variant);
+	return lookup;
+}
+const VARIANT_BY_RUN_PROPERTIES = buildVariantLookup();
+function variantFromRunProperties(script, style) {
+	return VARIANT_BY_RUN_PROPERTIES.get(`${script ?? DEFAULT_SCRIPT}|${style ?? DEFAULT_STYLE}`);
+}
+function miIntrinsicDefault(content) {
+	return [...content].length === 1 ? "italic" : "normal";
+}
+//#endregion
+exports.VARIANT_RUN_PROPERTIES = VARIANT_RUN_PROPERTIES;
+exports.miIntrinsicDefault = miIntrinsicDefault;
+exports.variantFromRunProperties = variantFromRunProperties;

package/dist/omml/shared.d.cts

@@ -0,0 +1,2 @@
+import { a as variantFromRunProperties, i as miIntrinsicDefault, n as OmmlDiagnosticKind, r as VARIANT_RUN_PROPERTIES, t as OmmlDiagnostic } from "../shared-DLZ3IQUl.cjs";
+export { OmmlDiagnostic, OmmlDiagnosticKind, VARIANT_RUN_PROPERTIES, miIntrinsicDefault, variantFromRunProperties };

package/dist/omml/shared.d.ts

@@ -0,0 +1,2 @@
+import { a as variantFromRunProperties, i as miIntrinsicDefault, n as OmmlDiagnosticKind, r as VARIANT_RUN_PROPERTIES, t as OmmlDiagnostic } from "../shared-DUOzjwcL.js";
+export { OmmlDiagnostic, OmmlDiagnosticKind, VARIANT_RUN_PROPERTIES, miIntrinsicDefault, variantFromRunProperties };