@fiduswriter/document 0.1.0-alpha.1

package/src/importer/docx/omml2mathml.js

@@ -0,0 +1,1448 @@
+// Converted version of https://github.com/scienceai/omml2mathml/blob/master/index.js
+// that works with our xml dom.
+
+import {xmlDOM} from "../../exporter/tools/xml.js"
+const MATH_NS = "http://www.w3.org/1998/Math/MathML"
+
+// Regular expression matching mathematical operators
+const oprx =
+    /[\+\-\*\/\^\&\|\!\~\<\>\=\:\u2208\u2209\u220B\u220C\u2218\u2219\u221D\u2223\u2224\u2225\u2226\u2227\u2228\u2229\u222A\u222B\u222C\u222D\u2234\u2235\u2236\u2237\u2238\u2239\u223A\u223B\u223C\u223D\u223E\u223F\u2240\u2241\u2242\u2243\u2244\u2245\u2246\u2247\u2248\u2249\u224A\u224B\u224C\u224D\u224E\u224F\u2250\u2251\u2252\u2253\u2254\u2255\u2256\u2257\u2258\u2259\u225A\u225B\u225C\u225D\u225E\u225F\u2260\u2261\u2262\u2263\u2264\u2265\u2266\u2267\u2268\u2269\u226A\u226B\u226C\u226D\u226E\u226F\u2270\u2271\u2272\u2273\u2274\u2275\u2276\u2277\u2278\u2279\u227A\u227B\u227C\u227D\u227E\u227F\u2280\u2281\u2282\u2283\u2284\u2285\u2286\u2287\u2288\u2289\u228A\u228B\u228C\u228D\u228E\u228F\u2290\u2291\u2292\u2293\u2294\u2295\u2296\u2297\u2298\u2299\u229A\u229B\u229C\u229D\u229E\u229F\u22A0\u22A1\u22A2\u22A3\u22A4\u22A5\u22A6\u22A7\u22A8\u22A9\u22AA\u22AB\u22AC\u22AD\u22AE\u22AF\u22B0\u22B1\u22B2\u22B3\u22B4\u22B5\u22B6\u22B7\u22B8\u22B9\u22BA\u22BB\u22BC\u22BD\u22C0\u22C1\u22C2\u22C3\u22C4\u22C5\u22C6\u22C7\u22C8\u22C9\u22CA\u22CB\u22CC\u22CD\u22CE\u22CF\u22D0\u22D1\u22D2\u22D3\u22D4\u22D5\u22D6\u22D7\u22D8\u22D9\u22DA\u22DB\u22DC\u22DD\u22DE\u22DF\u22E0\u22E1\u22E2\u22E3\u22E4\u22E5\u22E6\u22E7\u22E8\u22E9\u22EA\u22EB\u22EC\u22ED\u22EE\u22EF\u22F0\u22F1\u22F2\u22F3\u22F4\u22F5\u22F6\u22F7\u22F8\u22F9\u22FA\u22FB\u22FC\u22FD\u22FE\u22FF]/
+
+/**
+ * Converts OMML to MathML
+ * @param {XMLElement} omml - OMML XML element
+ * @return {string} MathML XML string
+ */
+export function omml2mathml(omml) {
+    // Create the root math element
+    const math = xmlDOM(`<math xmlns="${MATH_NS}" display="inline"></math>`)
+
+    // Process the OMML document
+    processOMML(omml, math)
+
+    return math
+}
+
+/**
+ * Process the OMML document and convert to MathML
+ * @param {XMLElement} omml - The OMML element to process
+ * @param {XMLElement} math - The parent MathML element
+ */
+function processOMML(omml, math) {
+    // Handle different OMML elements
+    if (omml.tagName === "m:oMathPara") {
+        math.setAttribute("display", "block")
+        omml.queryAll("m:oMath").forEach(omath => {
+            processOMML(omath, math)
+        })
+    } else if (omml.tagName === "m:oMath") {
+        const mrow = createMathElement("mrow", {}, math)
+        processChildren(omml, mrow)
+    } else {
+        processElement(omml, math)
+    }
+}
+
+/**
+ * Process an OMML element and create corresponding MathML
+ * @param {XMLElement} element - The OMML element to process
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processElement(element, parent) {
+    if (!element || !element.tagName) {
+        return
+    }
+
+    switch (element.tagName) {
+        case "m:f":
+            processFraction(element, parent)
+            break
+        case "m:r":
+            processRun(element, parent)
+            break
+        case "m:limLow":
+            processLimLow(element, parent)
+            break
+        case "m:limUpp":
+            processLimUpp(element, parent)
+            break
+        case "m:sSub":
+            processSubscript(element, parent)
+            break
+        case "m:sSup":
+            processSuperscript(element, parent)
+            break
+        case "m:sSubSup":
+            processSubSuperscript(element, parent)
+            break
+        case "m:sPre":
+            processPreScript(element, parent)
+            break
+        case "m:m":
+            processMatrix(element, parent)
+            break
+        case "m:rad":
+            processRadical(element, parent)
+            break
+        case "m:nary":
+            processNary(element, parent)
+            break
+        case "m:d":
+            processDelimiter(element, parent)
+            break
+        case "m:eqArr":
+            processEqArr(element, parent)
+            break
+        case "m:func":
+            processFunction(element, parent)
+            break
+        case "m:acc":
+            processAccent(element, parent)
+            break
+        case "m:groupChr":
+            processGroupChar(element, parent)
+            break
+        case "m:borderBox":
+            processBorderBox(element, parent)
+            break
+        case "m:bar":
+            processBar(element, parent)
+            break
+        case "m:phant":
+            processPhantom(element, parent)
+            break
+        case "m:e":
+        case "m:den":
+        case "m:num":
+        case "m:lim":
+        case "m:sup":
+        case "m:sub":
+            processArgument(element, parent)
+            break
+        default:
+            // Process children for unhandled elements
+            processChildren(element, parent)
+    }
+}
+
+/**
+ * Process all children of an element
+ * @param {XMLElement} element - The element whose children to process
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processChildren(element, parent) {
+    if (!element || !element.children) {
+        return
+    }
+
+    element.children.forEach(child => {
+        if (typeof child === "object") {
+            processElement(child, parent)
+        }
+    })
+}
+
+/**
+ * Create a MathML element with specified attributes
+ * @param {string} tag - The MathML tag name
+ * @param {Object} attrs - The attributes to set
+ * @param {XMLElement} parent - The parent element
+ * @return {XMLElement} The created element
+ */
+function createMathElement(tag, attrs = {}, parent = null) {
+    const elem = xmlDOM(`<${tag}></${tag}>`)
+
+    // Set attributes
+    Object.entries(attrs).forEach(([key, value]) => {
+        if (value !== undefined && value !== "") {
+            elem.setAttribute(key, value)
+        }
+    })
+
+    if (parent) {
+        parent.appendChild(elem)
+    }
+
+    return elem
+}
+
+/**
+ * Process a fraction element
+ * @param {XMLElement} element - The OMML fraction element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processFraction(element, parent) {
+    const type = getAttr(element, "m:fPr/m:type", "m:val") || ""
+
+    if (type.toLowerCase() === "lin") {
+        const mrow = createMathElement("mrow", {}, parent)
+        const numRow = createMathElement("mrow", {}, mrow)
+        const num = element.query("m:num")
+        if (num) {
+            processElement(num, numRow)
+        }
+        const mo = createMathElement("mo", {}, mrow)
+        mo.textContent = "/"
+
+        const denRow = createMathElement("mrow", {}, mrow)
+        const den = element.query("m:den")
+        if (den) {
+            processElement(den, denRow)
+        }
+    } else {
+        const attr = getFracProps(type.toLowerCase())
+        const mfrac = createMathElement("mfrac", attr, parent)
+
+        const numRow = createMathElement("mrow", {}, mfrac)
+        const num = element.query("m:num")
+        if (num) {
+            processElement(num, numRow)
+        }
+        const denRow = createMathElement("mrow", {}, mfrac)
+        const den = element.query("m:den")
+        if (den) {
+            processElement(den, denRow)
+        }
+    }
+}
+
+/**
+ * Process a run of text
+ * @param {XMLElement} element - The OMML run element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processRun(element, parent) {
+    const nor = forceFalse(getAttr(element, "m:rPr/m:nor", "m:val") || "false")
+    if (nor) {
+        const mtext = createMathElement("mtext", {}, parent)
+        const textContent = element
+            .queryAll("m:t")
+            .map(t => t.textContent)
+            .join("")
+        mtext.textContent = nbsp(textContent)
+    } else {
+        element.queryAll("m:t").forEach(t => {
+            const toParse = t.textContent
+            const scr = getAttr(element, "m:rPr/m:scr", "m:val")
+            const sty = getAttr(element, "m:rPr/m:sty", "m:val")
+            parseMT(element, parent, {
+                toParse,
+                scr,
+                sty,
+                nor: false
+            })
+        })
+    }
+}
+
+/**
+ * Process a lower limit element
+ * @param {XMLElement} element - The OMML limLow element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processLimLow(element, parent) {
+    const munder = createMathElement("munder", {}, parent)
+    const row1 = createMathElement("mrow", {}, munder)
+    const row2 = createMathElement("mrow", {}, munder)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row1)
+    }
+
+    const lim = element.query("m:lim")
+    if (lim) {
+        processElement(lim, row2)
+    }
+}
+
+/**
+ * Process an upper limit element
+ * @param {XMLElement} element - The OMML limUpp element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processLimUpp(element, parent) {
+    const mover = createMathElement("mover", {}, parent)
+    const row1 = createMathElement("mrow", {}, mover)
+    const row2 = createMathElement("mrow", {}, mover)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row1)
+    }
+
+    const lim = element.query("m:lim")
+    if (lim) {
+        processElement(lim, row2)
+    }
+}
+
+/**
+ * Process a subscript element
+ * @param {XMLElement} element - The OMML sSub element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processSubscript(element, parent) {
+    const msub = createMathElement("msub", {}, parent)
+    const row1 = createMathElement("mrow", {}, msub)
+    const row2 = createMathElement("mrow", {}, msub)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row1)
+    }
+
+    const sub = element.query("m:sub")
+    if (sub) {
+        processElement(sub, row2)
+    }
+}
+
+/**
+ * Process a superscript element
+ * @param {XMLElement} element - The OMML sSup element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processSuperscript(element, parent) {
+    const msup = createMathElement("msup", {}, parent)
+    const row1 = createMathElement("mrow", {}, msup)
+    const row2 = createMathElement("mrow", {}, msup)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row1)
+    }
+
+    const sup = element.query("m:sup")
+    if (sup) {
+        processElement(sup, row2)
+    }
+}
+
+/**
+ * Process a subscript-superscript element
+ * @param {XMLElement} element - The OMML sSubSup element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processSubSuperscript(element, parent) {
+    const msubsup = createMathElement("msubsup", {}, parent)
+    const row1 = createMathElement("mrow", {}, msubsup)
+    const row2 = createMathElement("mrow", {}, msubsup)
+    const row3 = createMathElement("mrow", {}, msubsup)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row1)
+    }
+
+    const sub = element.query("m:sub")
+    if (sub) {
+        processElement(sub, row2)
+    }
+
+    const sup = element.query("m:sup")
+    if (sup) {
+        processElement(sup, row3)
+    }
+}
+
+/**
+ * Process a prescripted element
+ * @param {XMLElement} element - The OMML sPre element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processPreScript(element, parent) {
+    const mmultiscripts = createMathElement("mmultiscripts", {}, parent)
+    const row = createMathElement("mrow", {}, mmultiscripts)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row)
+    }
+
+    createMathElement("mprescripts", {}, mmultiscripts)
+
+    const sub = element.query("m:sub")
+    outputScript(mmultiscripts, sub)
+
+    const sup = element.query("m:sup")
+    outputScript(mmultiscripts, sup)
+}
+
+/**
+ * Process a matrix element
+ * @param {XMLElement} element - The OMML matrix element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processMatrix(element, parent) {
+    const mcjc = getAttr(element, "m:mPr/m:mcs/m:mc/m:mcPr/m:mcJc", "m:val")
+
+    const attrs = {}
+    if (mcjc && mcjc.toLowerCase() !== "center") {
+        attrs.columnalign = mcjc.toLowerCase()
+    }
+
+    const mtable = createMathElement("mtable", attrs, parent)
+
+    element.queryAll("m:mr").forEach(mr => {
+        const mtr = createMathElement("mtr", {}, mtable)
+
+        mr.queryAll("m:e").forEach(me => {
+            const mtd = createMathElement("mtd", {}, mtr)
+            processElement(me, mtd)
+        })
+    })
+}
+
+/**
+ * Process a radical element
+ * @param {XMLElement} element - The OMML radical element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processRadical(element, parent) {
+    const degHide = forceFalse(
+        getAttr(element, "m:radPr/m:degHide", "m:val") || "false"
+    )
+
+    if (degHide) {
+        const msqrt = createMathElement("msqrt", {}, parent)
+        const e = element.query("m:e")
+        if (e) {
+            processElement(e, msqrt)
+        }
+    } else {
+        const mroot = createMathElement("mroot", {}, parent)
+        const row1 = createMathElement("mrow", {}, mroot)
+        const row2 = createMathElement("mrow", {}, mroot)
+
+        const e = element.query("m:e")
+        if (e) {
+            processElement(e, row1)
+        }
+
+        const deg = element.query("m:deg")
+        if (deg) {
+            processElement(deg, row2)
+        }
+    }
+}
+
+/**
+ * Process an n-ary operator element
+ * @param {XMLElement} element - The OMML nary element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processNary(element, parent) {
+    const subHide = forceFalse(
+        getAttr(element, "m:naryPr/m:subHide", "m:val") || "false"
+    )
+    const supHide = forceFalse(
+        getAttr(element, "m:naryPr/m:supHide", "m:val") || "false"
+    )
+    const limLocSubSup =
+        (getAttr(element, "m:naryPr/m:limLoc", "m:val") || "").toLowerCase() ===
+            "" ||
+        (getAttr(element, "m:naryPr/m:limLoc", "m:val") || "").toLowerCase() ===
+            "subsup"
+    const grow = forceFalse(
+        getAttr(element, "m:naryPr/m:grow", "m:val") || "false"
+    )
+
+    const mrow = createMathElement("mrow", {}, parent)
+
+    if (supHide && subHide) {
+        outputNAryMO(element, mrow, grow)
+    } else if (subHide) {
+        const outer = createMathElement(
+            limLocSubSup ? "msup" : "mover",
+            {},
+            mrow
+        )
+        outputNAryMO(element, outer, grow)
+
+        const suprow = createMathElement("mrow", {}, outer)
+        const sup = element.query("m:sup")
+        if (sup) {
+            processElement(sup, suprow)
+        }
+    } else if (supHide) {
+        const outer = createMathElement(
+            limLocSubSup ? "msub" : "munder",
+            {},
+            mrow
+        )
+        outputNAryMO(element, outer, grow)
+
+        const subrow = createMathElement("mrow", {}, outer)
+        const sub = element.query("m:sub")
+        if (sub) {
+            processElement(sub, subrow)
+        }
+    } else {
+        const outer = createMathElement(
+            limLocSubSup ? "msubsup" : "munderover",
+            {},
+            mrow
+        )
+        outputNAryMO(element, outer, grow)
+
+        const subrow1 = createMathElement("mrow", {}, outer)
+        const sub = element.query("m:sub")
+        if (sub) {
+            processElement(sub, subrow1)
+        }
+
+        const subrow2 = createMathElement("mrow", {}, outer)
+        const sup = element.query("m:sup")
+        if (sup) {
+            processElement(sup, subrow2)
+        }
+    }
+
+    const erow = createMathElement("mrow", {}, mrow)
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, erow)
+    }
+}
+
+/**
+ * Process a delimiter element
+ * @param {XMLElement} element - The OMML delimiter element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processDelimiter(element, parent) {
+    const begChr = getAttr(element, "m:dPr/m:begChr", "m:val")
+    const endChr = getAttr(element, "m:dPr/m:endChr", "m:val")
+    const sepChr = getAttr(element, "m:dPr/m:sepChr", "m:val") || "|"
+
+    const attr = {}
+    if (begChr !== undefined && begChr !== "(") {
+        attr.open = begChr
+    }
+    if (endChr !== undefined && endChr !== ")") {
+        attr.close = endChr
+    }
+    if (sepChr !== ",") {
+        attr.separators = sepChr
+    }
+
+    const mfenced = createMathElement("mfenced", attr, parent)
+
+    element.queryAll("m:e").forEach(me => {
+        const row = createMathElement("mrow", {}, mfenced)
+        processElement(me, row)
+    })
+}
+
+/**
+ * Process an equation array element
+ * @param {XMLElement} element - The OMML eqArr element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processEqArr(element, parent) {
+    const mtable = createMathElement("mtable", {}, parent)
+
+    element.queryAll("m:e").forEach(me => {
+        const mtr = createMathElement("mtr", {}, mtable)
+        const mtd = createMathElement("mtd", {}, mtr)
+
+        const scrLvl = getAttr(me, "m:argPr/m:scrLvl", "m:val")
+        const outer =
+            scrLvl !== "0" && scrLvl
+                ? createMathElement("mrow", {}, mtd)
+                : createMathElement("mstyle", {scriptlevel: scrLvl}, mtd)
+
+        createMathElement("maligngroup", {}, outer)
+
+        const firstChild = me.children[0]
+        if (firstChild) {
+            createEqArrRow(outer, element, firstChild, 1)
+        }
+    })
+}
+
+/**
+ * Process a function element
+ * @param {XMLElement} element - The OMML function element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processFunction(element, parent) {
+    const outer = createMathElement("mrow", {}, parent)
+    const row1 = createMathElement("mrow", {}, outer)
+
+    element.queryAll("m:fName").forEach(fn => {
+        processElement(fn, row1)
+    })
+
+    const mo = createMathElement("mo", {}, outer)
+    mo.textContent = "\u2061" // Function application
+
+    const row2 = createMathElement("mrow", {}, outer)
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row2)
+    }
+}
+
+/**
+ * Process an accent element
+ * @param {XMLElement} element - The OMML accent element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processAccent(element, parent) {
+    const mover = createMathElement("mover", {accent: "true"}, parent)
+    const row = createMathElement("mrow", {}, mover)
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row)
+    }
+
+    const acc = (getAttr(element, "m:accPr/m:chr", "m:val") || "\u0302").substr(
+        0,
+        1
+    )
+    const nonComb = toNonCombining(acc)
+
+    if (acc.length === 0) {
+        createMathElement("mo", {}, mover)
+    } else {
+        const nor = forceFalse(
+            getAttr(element, "m:rPr/m:nor", "m:val") || "false"
+        )
+        parseMT(element, mover, {
+            toParse: nonComb,
+            scr: getAttr(element, "m:e/*/m:rPr/m:scr", "m:val"),
+            sty: getAttr(element, "m:e/*/m:rPr/m:sty", "m:val"),
+            nor
+        })
+    }
+}
+
+/**
+ * Process a group character element
+ * @param {XMLElement} element - The OMML groupChr element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processGroupChar(element, parent) {
+    const lastGroupChrPr = element.query("m:groupChrPr")
+    if (!lastGroupChrPr) {
+        return
+    }
+
+    const pos = (getAttr(lastGroupChrPr, "m:pos", "m:val") || "").toLowerCase()
+    const vertJc = (
+        getAttr(lastGroupChrPr, "m:vertJc", "m:val") || ""
+    ).toLowerCase()
+    const chr = getAttr(lastGroupChrPr, "m:chr", "m:val") || "\u23DF"
+
+    const mkMrow = parent => {
+        const mrow = createMathElement("mrow", {}, parent)
+        const e = element.query("m:e")
+        if (e) {
+            processElement(e, mrow)
+        }
+        return mrow
+    }
+
+    const mkMo = parent => {
+        const mo = createMathElement("mo", {}, parent)
+        mo.textContent = chr.substr(0, 1)
+        return mo
+    }
+
+    if (pos === "top") {
+        if (vertJc === "bot") {
+            const outer = createMathElement("mover", {accent: "false"}, parent)
+            mkMrow(outer)
+            mkMo(outer)
+        } else {
+            const outer = createMathElement(
+                "munder",
+                {accentunder: "false"},
+                parent
+            )
+            mkMo(outer)
+            mkMrow(outer)
+        }
+    } else {
+        if (vertJc === "bot") {
+            const outer = createMathElement("mover", {accent: "false"}, parent)
+            mkMo(outer)
+            mkMrow(outer)
+        } else {
+            const outer = createMathElement(
+                "munder",
+                {accentunder: "false"},
+                parent
+            )
+            mkMrow(outer)
+            mkMo(outer)
+        }
+    }
+}
+
+/**
+ * Process a border box element
+ * @param {XMLElement} element - The OMML borderBox element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processBorderBox(element, parent) {
+    const hideTop = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:hideTop", "m:val") || "false"
+    )
+    const hideBot = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:hideBot", "m:val") || "false"
+    )
+    const hideLeft = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:hideLeft", "m:val") || "false"
+    )
+    const hideRight = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:hideRight", "m:val") || "false"
+    )
+    const strikeH = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:strikeH", "m:val") || "false"
+    )
+    const strikeV = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:strikeV", "m:val") || "false"
+    )
+    const strikeBLTR = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:strikeBLTR", "m:val") || "false"
+    )
+    const strikeTLBR = forceTrue(
+        getAttr(element, "m:borderBoxPr/m:strikeTLBR", "m:val") || "false"
+    )
+
+    let outer
+
+    if (
+        hideTop &&
+        hideBot &&
+        hideLeft &&
+        hideRight &&
+        !strikeH &&
+        !strikeV &&
+        !strikeBLTR &&
+        !strikeTLBR
+    ) {
+        outer = createMathElement("mrow", {}, parent)
+    } else {
+        const notation = createMEnclodeNotation({
+            hideTop,
+            hideBot,
+            hideLeft,
+            hideRight,
+            strikeH,
+            strikeV,
+            strikeBLTR,
+            strikeTLBR
+        })
+        outer = createMathElement("menclose", notation, parent)
+    }
+
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, outer)
+    }
+}
+
+/**
+ * Process a bar element
+ * @param {XMLElement} element - The OMML bar element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processBar(element, parent) {
+    const pos = (getAttr(element, "m:barPr/m:pos", "m:val") || "").toLowerCase()
+
+    if (pos === "top") {
+        const outer = createMathElement("mover", {accent: "false"}, parent)
+        const row = createMathElement("mrow", {}, outer)
+        const mo = createMathElement("mo", {}, outer)
+
+        const e = element.query("m:e")
+        if (e) {
+            processElement(e, row)
+        }
+
+        mo.textContent = "\u00af" // Macron
+    } else {
+        const outer = createMathElement(
+            "munder",
+            {underaccent: "false"},
+            parent
+        )
+        const row = createMathElement("mrow", {}, outer)
+        const mo = createMathElement("mo", {}, outer)
+
+        const e = element.query("m:e")
+        if (e) {
+            processElement(e, row)
+        }
+
+        mo.textContent = "\u005f" // Underscore
+    }
+}
+
+/**
+ * Process a phantom element
+ * @param {XMLElement} element - The OMML phantom element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processPhantom(element, parent) {
+    const zeroWid = forceFalse(
+        getAttr(element, "m:phantPr/m:zeroWid", "m:val") || "false"
+    )
+    const zeroAsc = forceFalse(
+        getAttr(element, "m:phantPr/m:zeroAsc", "m:val") || "false"
+    )
+    const zeroDesc = forceFalse(
+        getAttr(element, "m:phantPr/m:zeroDesc", "m:val") || "false"
+    )
+    const showVal = forceFalse(
+        getAttr(element, "m:phantPr/m:show", "m:val") || "false"
+    )
+
+    let container
+
+    if (showVal) {
+        container = createMathElement(
+            "mpadded",
+            createMPaddedAttr({zeroWid, zeroAsc, zeroDesc}),
+            parent
+        )
+    } else if (!zeroWid && !zeroAsc && !zeroDesc) {
+        container = createMathElement("mphantom", {}, parent)
+    } else {
+        const phant = createMathElement("mphantom", {}, parent)
+        container = createMathElement(
+            "mpadded",
+            createMPaddedAttr({zeroWid, zeroAsc, zeroDesc}),
+            phant
+        )
+    }
+
+    const row = createMathElement("mrow", {}, container)
+    const e = element.query("m:e")
+    if (e) {
+        processElement(e, row)
+    }
+}
+
+/**
+ * Process an argument element
+ * @param {XMLElement} element - The OMML argument element
+ * @param {XMLElement} parent - The parent MathML element
+ */
+function processArgument(element, parent) {
+    const scriptlevel = getAttr(element, "m:argPr/m:scrLvl", "m:val")
+
+    if (!scriptlevel) {
+        processChildren(element, parent)
+    } else {
+        const style = createMathElement("mstyle", {scriptlevel}, parent)
+        processChildren(element, style)
+    }
+}
+
+/**
+ * Get attribute value from an element using a simplified XPath-like path
+ * @param {XMLElement} element - The element to query
+ * @param {string} path - The simplified path to the attribute
+ * @param {string} attrName - The attribute name
+ * @return {string} The attribute value or empty string
+ */
+function getAttr(element, path, attrName) {
+    if (!element) {
+        return ""
+    }
+
+    const parts = path.split("/")
+    let current = element
+
+    for (let i = 0; i < parts.length; i++) {
+        if (!current) {
+            return ""
+        }
+
+        const part = parts[i]
+        if (part.includes("[last()]")) {
+            const tagName = part.replace("[last()]", "")
+            const elements = current.queryAll(tagName)
+            current = elements.length ? elements[elements.length - 1] : null
+        } else if (part.includes("[")) {
+            const match = part.match(/([^[]+)\[(\d+)\]/)
+            if (match) {
+                const tagName = match[1]
+                const index = parseInt(match[2], 10) - 1
+                const elements = current.queryAll(tagName)
+                current = elements[index] || null
+            } else {
+                current = current.query(part) || null
+            }
+        } else {
+            current = current.query(part) || null
+        }
+    }
+
+    return current ? current.getAttribute(attrName) || "" : ""
+}
+
+/**
+ * Output a script element, or "none" if not provided
+ * @param {XMLElement} parent - The parent element
+ * @param {XMLElement} element - The script element to output
+ */
+function outputScript(parent, element) {
+    if (element) {
+        const row = createMathElement("mrow", {}, parent)
+        processElement(element, row)
+    } else {
+        createMathElement("none", {}, parent)
+    }
+}
+
+/**
+ * Output an n-ary operator
+ * @param {XMLElement} element - The OMML nary element
+ * @param {XMLElement} parent - The parent MathML element
+ * @param {boolean} grow - Whether the operator should stretch
+ */
+function outputNAryMO(element, parent, grow = false) {
+    const mo = createMathElement(
+        "mo",
+        {stretchy: grow ? "true" : "false"},
+        parent
+    )
+    const val = getAttr(element, "m:naryPr/m:chr", "m:val")
+    mo.textContent = val || "\u222b" // Integral symbol by default
+}
+
+/**
+ * Create an equation array row
+ * @param {XMLElement} parent - The parent MathML element
+ * @param {XMLElement} src - The source OMML element
+ * @param {XMLElement} cur - The current OMML element
+ * @param {number} align - Alignment indicator
+ */
+function createEqArrRow(parent, src, cur, align) {
+    if (!cur) {
+        return
+    }
+
+    if (cur.tagName === "m:r") {
+        const allMt = cur
+            .queryAll("m:t")
+            .map(t => t.textContent)
+            .join("")
+        const nor = forceFalse(getAttr(cur, "m:rPr/m:nor", "m:val") || "false")
+
+        parseEqArrMr(parent, {
+            toParse: allMt,
+            scr: getAttr(cur, "m:rPr/m:scr", "m:val"),
+            sty: getAttr(cur, "m:rPr/m:sty", "m:val"),
+            nor,
+            align
+        })
+    } else {
+        processElement(cur, parent)
+    }
+
+    // Get the next sibling if available
+    const siblings = cur.parentElement ? cur.parentElement.children : []
+    const index = siblings.indexOf(cur)
+    const nextSibling = index < siblings.length - 1 ? siblings[index + 1] : null
+
+    if (nextSibling) {
+        const allMt = cur
+            .queryAll("m:t")
+            .map(t => t.textContent)
+            .join("")
+        const amp = countAmp(allMt)
+        createEqArrRow(parent, src, nextSibling, (align + (amp % 2)) % 2)
+    }
+}
+
+/**
+ * Parse equation array run text
+ * @param {XMLElement} parent - The parent MathML element
+ * @param {Object} options - Parsing options
+ */
+function parseEqArrMr(parent, {toParse = "", scr, sty, nor, align}) {
+    if (!toParse.length) {
+        return
+    }
+
+    if (toParse[0] === "&") {
+        createMathElement(align ? "malignmark" : "maligngroup", {}, parent)
+        parseEqArrMr(parent, {
+            toParse: toParse.substr(1),
+            align: !align,
+            scr,
+            sty,
+            nor
+        })
+    } else {
+        const firstOper = rxIndexOf(toParse, oprx)
+        const firstNum = rxIndexOf(toParse, /\d/)
+        const startsWithOper = firstOper === 1
+        const startsWithNum = firstNum === 1
+
+        if (!startsWithOper && !startsWithNum) {
+            if (!nor) {
+                const mi = createMathElement(
+                    "mi",
+                    tokenAttributes({
+                        scr,
+                        sty,
+                        nor,
+                        charToPrint: 1,
+                        tokenType: "mi"
+                    }),
+                    parent
+                )
+                mi.textContent = nbsp(toParse.substr(0, 1))
+            } else {
+                const mt = createMathElement("mtext", {}, parent)
+                mt.textContent = nbsp(toParse.substr(0, 1))
+            }
+            parseEqArrMr(parent, {
+                toParse: toParse.substr(1),
+                scr,
+                sty,
+                nor,
+                align
+            })
+        } else if (startsWithOper) {
+            if (!nor) {
+                const mo = createMathElement(
+                    "mo",
+                    tokenAttributes({
+                        nor,
+                        charToPrint: 1,
+                        tokenType: "mo"
+                    }),
+                    parent
+                )
+                mo.textContent = toParse.substr(0, 1)
+            } else {
+                const mt = createMathElement("mtext", {}, parent)
+                mt.textContent = toParse.substr(0, 1)
+            }
+            parseEqArrMr(parent, {
+                toParse: toParse.substr(1),
+                scr,
+                sty,
+                nor,
+                align
+            })
+        } else {
+            const num = numStart(toParse)
+            if (!nor) {
+                const mn = createMathElement(
+                    "mn",
+                    tokenAttributes({
+                        sty: "p",
+                        nor,
+                        charToPrint: 1,
+                        tokenType: "mn"
+                    }),
+                    parent
+                )
+                mn.textContent = num
+            } else {
+                const mt = createMathElement("mtext", {}, parent)
+                mt.textContent = num
+            }
+            parseEqArrMr(parent, {
+                toParse: toParse.substr(num.length),
+                scr,
+                sty,
+                nor,
+                align
+            })
+        }
+    }
+}
+
+/**
+ * Parse math text
+ * @param {XMLElement} ctx - The context OMML element
+ * @param {XMLElement} parent - The parent MathML element
+ * @param {Object} options - Parsing options
+ */
+function parseMT(ctx, parent, {toParse = "", scr, sty, nor}) {
+    if (!toParse.length) {
+        return
+    }
+    const firstOper = rxIndexOf(toParse, oprx)
+    const firstNum = rxIndexOf(toParse, /\d/)
+    const startsWithOper = firstOper === 1
+    const startsWithNum = firstNum === 1
+    if (!startsWithOper && !startsWithNum) {
+        let charToPrint = 1
+        // Check if we're in a function name
+        const inFuncName = ctx.closest("m:fName") !== null
+        if (inFuncName) {
+            if (!firstOper && !firstNum) {
+                charToPrint = toParse.length
+            } else {
+                charToPrint =
+                    Math.min(
+                        firstOper || Number.MAX_VALUE,
+                        firstNum || Number.MAX_VALUE
+                    ) - 1
+            }
+        }
+        const mi = createMathElement(
+            "mi",
+            tokenAttributes({
+                scr,
+                sty,
+                nor,
+                charToPrint,
+                tokenType: "mi"
+            }),
+            parent
+        )
+        mi.textContent = nbsp(toParse.substr(0, charToPrint))
+        parseMT(ctx, parent, {
+            toParse: toParse.substr(charToPrint),
+            scr,
+            sty,
+            nor
+        })
+    } else if (startsWithOper) {
+        const mo = createMathElement(
+            "mo",
+            tokenAttributes({
+                nor,
+                tokenType: "mo"
+            }),
+            parent
+        )
+        mo.textContent = toParse.substr(0, 1)
+
+        parseMT(ctx, parent, {
+            toParse: toParse.substr(1),
+            scr,
+            sty,
+            nor
+        })
+    } else {
+        const num = numStart(toParse)
+        const mn = createMathElement(
+            "mn",
+            tokenAttributes({
+                scr,
+                sty: "p",
+                nor,
+                tokenType: "mn"
+            }),
+            parent
+        )
+        mn.textContent = num
+
+        parseMT(ctx, parent, {
+            toParse: toParse.substr(num.length),
+            scr,
+            sty,
+            nor
+        })
+    }
+}
+
+/**
+ * Find the index of a regex match in a string
+ * @param {string} str - The string to search
+ * @param {RegExp} rx - The regex to match
+ * @return {number} The match index + 1, or 0 if no match
+ */
+function rxIndexOf(str, rx) {
+    const re = rx.exec(str)
+    if (!re) {
+        return 0
+    }
+    return re.index + 1
+}
+
+/**
+ * Get the start of a number in a string
+ * @param {string} str - The string to check
+ * @return {string} The number at the start of the string
+ */
+function numStart(str) {
+    if (!str) {
+        return ""
+    }
+    const match = str.match(/^(\d+)/)
+    return match ? match[1] : ""
+}
+
+/**
+ * Count ampersands in a string
+ * @param {string} str - The string to check
+ * @return {number} The number of ampersands
+ */
+function countAmp(str) {
+    return ((str || "").match(/&/g) || []).length
+}
+
+/**
+ * Convert a combining character to its non-combining equivalent
+ * @param {string} ch - The character to convert
+ * @return {string} The non-combining equivalent
+ */
+function toNonCombining(ch) {
+    const combiMap = {
+        "\u0306": "\u02D8", // breve
+        "\u032e": "\u02D8", // breve below
+        "\u0312": "\u00B8", // cedilla
+        "\u0327": "\u00B8", // cedilla
+        "\u0300": "\u0060", // grave
+        "\u0316": "\u0060", // grave below
+        "\u0305": "\u002D", // macron/overbar
+        "\u0332": "\u002D", // macron/underbar
+        "\u0323": "\u002E", // dot below
+        "\u0307": "\u02D9", // dot above
+        "\u030B": "\u02DD", // double acute
+        "\u0317": "\u00B4", // acute below
+        "\u0301": "\u00B4", // acute
+        "\u0330": "\u007E", // tilde below
+        "\u0303": "\u007E", // tilde
+        "\u0324": "\u00A8", // diaeresis below
+        "\u0308": "\u00A8", // diaeresis
+        "\u032C": "\u02C7", // caron below
+        "\u030C": "\u02C7", // caron
+        "\u0302": "\u005E", // circumflex
+        "\u032D": "\u005E", // circumflex below
+        "\u20D7": "\u2192", // vector/right arrow
+        "\u20EF": "\u2192", // vector/right arrow below
+        "\u20D6": "\u2190", // left arrow
+        "\u20EE": "\u2190" // left arrow below
+    }
+    return combiMap[ch] || ch
+}
+
+/**
+ * Create MathML token attributes based on token settings
+ * @param {Object} options - Token options
+ * @return {Object} Attribute object
+ */
+function tokenAttributes({scr, sty, nor, charToPrint = 0, tokenType}) {
+    const attr = {}
+
+    if (nor) {
+        attr.mathvariant = "normal"
+    } else {
+        let mathvariant
+        const fontweight = sty === "b" || sty === "bi" ? "bold" : "normal"
+        const fontstyle = sty === "b" || sty === "p" ? "normal" : "italic"
+
+        if (tokenType !== "mn") {
+            if (scr === "monospace") {
+                mathvariant = "monospace"
+            } else if (scr === "sans-serif" && sty === "i") {
+                mathvariant = "sans-serif-italic"
+            } else if (scr === "sans-serif" && sty === "b") {
+                mathvariant = "bold-sans-serif"
+            } else if (scr === "sans-serif" && sty === "bi") {
+                mathvariant = "sans-serif-bold-italic"
+            } else if (scr === "sans-serif") {
+                mathvariant = "sans-serif"
+            } else if (scr === "fraktur" && (sty === "b" || sty === "i")) {
+                mathvariant = "bold-fraktur"
+            } else if (scr === "fraktur") {
+                mathvariant = "fraktur"
+            } else if (scr === "double-struck") {
+                mathvariant = "double-struck"
+            } else if (scr === "script" && (sty === "b" || sty === "i")) {
+                mathvariant = "bold-script"
+            } else if (scr === "script") {
+                mathvariant = "script"
+            } else if (scr === "roman" || !scr) {
+                if (sty === "b") {
+                    mathvariant = "bold"
+                } else if (sty === "i") {
+                    mathvariant = "italic"
+                } else if (sty === "p") {
+                    mathvariant = "normal"
+                } else if (sty === "bi") {
+                    mathvariant = "bold-italic"
+                }
+            }
+        }
+
+        if (tokenType === "mo" && mathvariant !== "normal") {
+            return attr
+        }
+
+        if (
+            tokenType === "mi" &&
+            charToPrint === 1 &&
+            (mathvariant === "italic" || !mathvariant)
+        ) {
+            return attr
+        }
+
+        if (
+            tokenType === "mi" &&
+            charToPrint > 1 &&
+            (mathvariant === "italic" || !mathvariant)
+        ) {
+            attr.mathvariant = "italic"
+        } else if (mathvariant && mathvariant !== "italic") {
+            attr.mathvariant = mathvariant
+        } else {
+            if (
+                fontstyle === "italic" &&
+                !(tokenType === "mi" && charToPrint === 1)
+            ) {
+                attr.fontstyle = "italic"
+            }
+            if (fontweight === "bold") {
+                attr.fontweight = "bold"
+            }
+        }
+    }
+
+    return attr
+}
+
+/**
+ * Create menclose notation attribute value
+ * @param {Object} options - Notation options
+ * @return {Object} The notation attributes
+ */
+function createMEnclodeNotation({
+    hideTop,
+    hideBot,
+    hideLeft,
+    hideRight,
+    strikeH,
+    strikeV,
+    strikeBLTR,
+    strikeTLBR
+}) {
+    const notation = []
+
+    if (!hideTop && !hideBot && !hideLeft && !hideRight) {
+        notation.push("box")
+    } else {
+        if (!hideTop) {
+            notation.push("top")
+        }
+        if (!hideBot) {
+            notation.push("bottom")
+        }
+        if (!hideLeft) {
+            notation.push("left")
+        }
+        if (!hideRight) {
+            notation.push("right")
+        }
+    }
+
+    if (strikeH) {
+        notation.push("horizontalstrike")
+    }
+    if (strikeV) {
+        notation.push("verticalstrike")
+    }
+    if (strikeBLTR) {
+        notation.push("updiagonalstrike")
+    }
+    if (strikeTLBR) {
+        notation.push("downdiagonalstrike")
+    }
+
+    return {notation: notation.join(" ")}
+}
+
+/**
+ * Create mpadded attributes
+ * @param {Object} options - Padding options
+ * @return {Object} The padding attributes
+ */
+function createMPaddedAttr({zeroWid, zeroAsc, zeroDesc}) {
+    const attr = {}
+
+    if (zeroWid) {
+        attr.width = "0in"
+    }
+    if (zeroAsc) {
+        attr.height = "0in"
+    }
+    if (zeroDesc) {
+        attr.depth = "0in"
+    }
+
+    return attr
+}
+
+/**
+ * Get fraction properties
+ * @param {string} type - Fraction type
+ * @return {Object} Fraction attributes
+ */
+function getFracProps(type) {
+    if (type === "skw" || type === "lin") {
+        return {bevelled: "true"}
+    }
+    if (type === "nobar") {
+        return {linethickness: "0pt"}
+    }
+    return {}
+}
+
+/**
+ * Replace spaces with non-breaking spaces
+ * @param {string} str - The string to process
+ * @return {string} String with non-breaking spaces
+ */
+function nbsp(str) {
+    if (!str) {
+        return ""
+    }
+    return str.replace(/\s/g, "\u00a0")
+}
+
+/**
+ * Parse a boolean value
+ * @param {string} str - The string to parse
+ * @return {boolean|undefined} The parsed boolean or undefined
+ */
+function tf(str) {
+    if (str == null) {
+        return
+    }
+    str = str.toLowerCase()
+    if (str === "on" || str === "1" || str === "true") {
+        return true
+    }
+    if (str === "off" || str === "0" || str === "false") {
+        return false
+    }
+}
+
+/**
+ * Force a value to be true unless explicitly false
+ * @param {string} str - The string to parse
+ * @return {boolean} True unless the string is explicitly false
+ */
+function forceFalse(str) {
+    const res = tf(str)
+    if (res === false) {
+        return false
+    }
+    return true
+}
+
+/**
+ * Force a value to be false unless explicitly true
+ * @param {string} str - The string to parse
+ * @return {boolean} False unless the string is explicitly true
+ */
+function forceTrue(str) {
+    return tf(str) || false
+}