ooxml-core 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -730,10 +730,10 @@ function booleanAttribute(element, name) {
 function descendants(root, local) {
   const result = [];
   const visit = (node) => {
-    for (const child of Array.from(node.childNodes)) {
-      if (!isElement(child)) continue;
-      if (child.localName === local) result.push(child);
-      visit(child);
+    for (const child2 of Array.from(node.childNodes)) {
+      if (!isElement(child2)) continue;
+      if (child2.localName === local) result.push(child2);
+      visit(child2);
     }
   };
   visit(root);
@@ -885,9 +885,9 @@ function parseDrawingColor(element) {
   const color = {
     kind,
     value: colorValue(kind, element),
-    transforms: elements(element).map((child) => ({
-      name: child.localName,
-      value: child.getAttribute("val") ?? ""
+    transforms: elements(element).map((child2) => ({
+      name: child2.localName,
+      value: child2.getAttribute("val") ?? ""
     }))
   };
   const fallback = kind === "system" ? element.getAttribute("lastClr") : null;
@@ -1202,7 +1202,7 @@ function parseRun(run) {
 }
 function parseParagraph(paragraph) {
   const runs = [];
-  for (const child of children(paragraph, "r", NS.a)) runs.push(parseRun(child));
+  for (const child2 of children(paragraph, "r", NS.a)) runs.push(parseRun(child2));
   for (const field of children(paragraph, "fld", NS.a)) runs.push(parseRun(field));
   const align = first(paragraph, "pPr", NS.a)?.getAttribute("algn");
   return { ...align ? { align } : {}, runs };
@@ -1413,9 +1413,9 @@ function parseDiagramDrawing(source, part) {
   const tree = root.localName === "spTree" ? root : first(root, "spTree", NS.dsp);
   let counter = 0;
   const visit = (container, group) => {
-    for (const child of Array.from(container.childNodes)) {
-      if (child.nodeType !== 1) continue;
-      const element = child;
+    for (const child2 of Array.from(container.childNodes)) {
+      if (child2.nodeType !== 1) continue;
+      const element = child2;
       if (element.localName === "sp") {
         const shape = parseShape(element, counter++, group, issues);
         if (shape) shapes.push(shape);
@@ -2632,9 +2632,9 @@ function evaluateFormula(parsed, vars) {
     // pin x y z — clamp y between x and z
     case "pin": {
       const lo = r(0);
-      const val = r(1);
+      const val2 = r(1);
       const hi = r(2);
-      return Math.max(lo, Math.min(val, hi));
+      return Math.max(lo, Math.min(val2, hi));
     }
     // sin x y — x * sin(y) where y is in OOXML angle units
     case "sin": {
@@ -16641,4 +16641,2032 @@ var TWIPS_PER_POINT = 20;
 var TWIPS_PER_INCH = 1440;
 var PIXELS_PER_INCH = 96;
 
-export { color_exports as color, diagram_exports as diagram, geometry_exports as geometry, opc_exports as opc, units_exports as units, xml_exports as xml };
+// src/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  ACCENT_ALIASES: () => ACCENT_ALIASES,
+  ACCENT_MAP: () => ACCENT_MAP,
+  DELIM_MAP: () => DELIM_MAP,
+  EQARR_ENVS: () => EQARR_ENVS,
+  ESCAPE_MAP: () => ESCAPE_MAP,
+  FUNC_NAMES: () => FUNC_NAMES,
+  GREEK_MAP: () => GREEK_MAP,
+  LIMIT_FUNC_NAMES: () => LIMIT_FUNC_NAMES,
+  MATRIX_ENVS: () => MATRIX_ENVS,
+  NARY_MAP: () => NARY_MAP,
+  OPERATOR_MAP: () => OPERATOR_MAP,
+  REVERSE_ACCENT: () => REVERSE_ACCENT,
+  REVERSE_DELIM: () => REVERSE_DELIM,
+  REVERSE_ESCAPE: () => REVERSE_ESCAPE,
+  REVERSE_GREEK: () => REVERSE_GREEK,
+  REVERSE_NARY: () => REVERSE_NARY,
+  REVERSE_OPERATOR: () => REVERSE_OPERATOR,
+  applyScripts: () => applyScripts,
+  attrVal: () => attrVal,
+  buildPrescript: () => buildPrescript,
+  childNode: () => childNode,
+  collectText: () => collectText,
+  contentKeys: () => contentKeys,
+  convertLatexToOmml: () => convertLatexToOmml,
+  convertOmmlToLatex: () => convertOmmlToLatex,
+  convertOmmlToMathMl: () => convertOmmlToMathMl,
+  delimiterToLatex: () => delimiterToLatex,
+  ensureArr: () => ensureArr,
+  eqArrToLatex: () => eqArrToLatex,
+  escapeChar: () => escapeChar,
+  escapeMathText: () => escapeMathText,
+  escapeTextArgument: () => escapeTextArgument,
+  getOmmlMathColor: () => getOmmlMathColor,
+  getOmmlMathFontSize: () => getOmmlMathFontSize,
+  hasAttr: () => hasAttr,
+  isOn: () => isOn,
+  isSingleAtom: () => isSingleAtom,
+  matrixToLatex: () => matrixToLatex,
+  mergeSiblings: () => mergeSiblings,
+  naryToLatex: () => naryToLatex,
+  ommlFromElement: () => ommlFromElement,
+  ommlToMathml: () => ommlToMathml,
+  parseAccent: () => parseAccent,
+  parseBar: () => parseBar,
+  parseBoxed: () => parseBoxed,
+  parseCommand: () => parseCommand,
+  parseDelimiter: () => parseDelimiter,
+  parseEnvironment: () => parseEnvironment,
+  parseFuncApplication: () => parseFuncApplication,
+  parseGroupChr: () => parseGroupChr,
+  parseNary: () => parseNary,
+  parseOmml: () => parseOmml,
+  parseOperatorName: () => parseOperatorName,
+  parsePhantom: () => parsePhantom,
+  parsePrescript: () => parsePrescript,
+  parseScriptArgs: () => parseScriptArgs,
+  parseTextArgument: () => parseTextArgument,
+  parseUnderOverset: () => parseUnderOverset,
+  readRunText: () => readRunText,
+  rowsToLatex: () => rowsToLatex,
+  soleChild: () => soleChild,
+  tokenize: () => tokenize,
+  tryParseScripts: () => tryParseScripts,
+  wrapDelimited: () => wrapDelimited
+});
+
+// src/math/omml-node.ts
+function orderedXmlKey(baseName, order) {
+  return `${baseName}#pptx-order-${order}`;
+}
+function stripXmlOrderSuffix(tagName) {
+  return tagName.split(/#(?:pptx|math)-order-/u, 1)[0] ?? tagName;
+}
+
+// src/math/latex-omml-siblings.ts
+var LETTER_RE = /[a-zA-Z]/u;
+var WHITESPACE_RE = /\s/u;
+function tokenize(latex) {
+  const tokens = [];
+  let i = 0;
+  while (i < latex.length) {
+    const ch = latex[i];
+    if (ch === "{") {
+      tokens.push({ type: "group_start", value: "{" });
+      i++;
+    } else if (ch === "}") {
+      tokens.push({ type: "group_end", value: "}" });
+      i++;
+    } else if (ch === "^") {
+      tokens.push({ type: "superscript", value: "^" });
+      i++;
+    } else if (ch === "_") {
+      tokens.push({ type: "subscript", value: "_" });
+      i++;
+    } else if (ch === "\\") {
+      let cmd = "\\";
+      i++;
+      if (i < latex.length && LETTER_RE.test(latex[i])) {
+        while (i < latex.length && LETTER_RE.test(latex[i])) {
+          cmd += latex[i];
+          i++;
+        }
+      } else if (i < latex.length) {
+        cmd += latex[i];
+        i++;
+      }
+      tokens.push({ type: "command", value: cmd });
+    } else if (WHITESPACE_RE.test(ch)) {
+      i++;
+      tokens.push({ type: "whitespace", value: " " });
+    } else {
+      tokens.push({ type: "text", value: ch });
+      i++;
+    }
+  }
+  return tokens;
+}
+function isGroupedByTag(tags) {
+  const seen = /* @__PURE__ */ new Set();
+  let previous = "";
+  for (const tag of tags) {
+    if (tag !== previous && seen.has(tag)) {
+      return false;
+    }
+    seen.add(tag);
+    previous = tag;
+  }
+  return true;
+}
+function mergeSiblings(nodes) {
+  const entries = [];
+  for (const node of nodes) {
+    for (const key of Object.keys(node)) {
+      if (node[key] !== void 0) {
+        entries.push([key, node[key]]);
+      }
+    }
+  }
+  if (!isGroupedByTag(entries.map(([key]) => key))) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const [key] of entries) {
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const ordered = {};
+    for (const [position, [key, value]] of entries.entries()) {
+      ordered[(counts.get(key) ?? 0) > 1 ? orderedXmlKey(key, position) : key] = value;
+    }
+    return ordered;
+  }
+  const result = {};
+  for (const [key, value] of entries) {
+    if (result[key]) {
+      const existing = result[key];
+      if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/math/latex-omml-symbols.ts
+var GREEK_MAP = {
+  "\\alpha": "\u03B1",
+  "\\beta": "\u03B2",
+  "\\gamma": "\u03B3",
+  "\\delta": "\u03B4",
+  "\\epsilon": "\u03B5",
+  "\\varepsilon": "\u03B5",
+  "\\zeta": "\u03B6",
+  "\\eta": "\u03B7",
+  "\\theta": "\u03B8",
+  "\\vartheta": "\u03D1",
+  "\\iota": "\u03B9",
+  "\\kappa": "\u03BA",
+  "\\lambda": "\u03BB",
+  "\\mu": "\u03BC",
+  "\\nu": "\u03BD",
+  "\\xi": "\u03BE",
+  "\\pi": "\u03C0",
+  "\\rho": "\u03C1",
+  "\\sigma": "\u03C3",
+  "\\tau": "\u03C4",
+  "\\upsilon": "\u03C5",
+  "\\phi": "\u03C6",
+  "\\varphi": "\u03D5",
+  "\\chi": "\u03C7",
+  "\\psi": "\u03C8",
+  "\\omega": "\u03C9",
+  "\\Gamma": "\u0393",
+  "\\Delta": "\u0394",
+  "\\Theta": "\u0398",
+  "\\Lambda": "\u039B",
+  "\\Xi": "\u039E",
+  "\\Pi": "\u03A0",
+  "\\Sigma": "\u03A3",
+  "\\Phi": "\u03A6",
+  "\\Psi": "\u03A8",
+  "\\Omega": "\u03A9"
+};
+var OPERATOR_MAP = {
+  "\\times": "\xD7",
+  "\\div": "\xF7",
+  "\\pm": "\xB1",
+  "\\mp": "\u2213",
+  "\\cdot": "\xB7",
+  "\\leq": "\u2264",
+  "\\geq": "\u2265",
+  "\\neq": "\u2260",
+  "\\approx": "\u2248",
+  "\\equiv": "\u2261",
+  "\\ll": "\u226A",
+  "\\gg": "\u226B",
+  "\\subset": "\u2282",
+  "\\supset": "\u2283",
+  "\\subseteq": "\u2286",
+  "\\supseteq": "\u2287",
+  "\\in": "\u2208",
+  "\\notin": "\u2209",
+  "\\cup": "\u222A",
+  "\\cap": "\u2229",
+  "\\to": "\u2192",
+  "\\rightarrow": "\u2192",
+  "\\leftarrow": "\u2190",
+  "\\leftrightarrow": "\u2194",
+  "\\Rightarrow": "\u21D2",
+  "\\Leftarrow": "\u21D0",
+  "\\Leftrightarrow": "\u21D4",
+  "\\infty": "\u221E",
+  "\\partial": "\u2202",
+  "\\nabla": "\u2207",
+  "\\forall": "\u2200",
+  "\\exists": "\u2203",
+  "\\therefore": "\u2234",
+  "\\because": "\u2235",
+  "\\propto": "\u221D",
+  "\\ldots": "\u2026",
+  "\\cdots": "\u22EF",
+  "\\vdots": "\u22EE",
+  "\\ddots": "\u22F1",
+  "\\le": "\u2264",
+  "\\ge": "\u2265",
+  "\\ne": "\u2260"
+};
+var ESCAPE_MAP = {
+  "\\{": "{",
+  "\\}": "}",
+  "\\lbrace": "{",
+  "\\rbrace": "}",
+  "\\_": "_",
+  "\\^": "^",
+  "\\&": "&",
+  "\\%": "%",
+  "\\#": "#",
+  "\\$": "$",
+  "\\ ": " ",
+  "\\backslash": "\\",
+  // Spacing commands render as an ordinary space run (`\ ` wins on reversal).
+  "\\quad": " ",
+  "\\qquad": " ",
+  "\\,": " ",
+  "\\:": " ",
+  "\\;": " ",
+  "\\!": ""
+};
+var NARY_MAP = {
+  "\\sum": "\u2211",
+  "\\prod": "\u220F",
+  "\\int": "\u222B",
+  "\\iint": "\u222C",
+  "\\iiint": "\u222D",
+  "\\oint": "\u222E",
+  "\\coprod": "\u2210",
+  "\\bigcup": "\u22C3",
+  "\\bigcap": "\u22C2",
+  "\\bigwedge": "\u22C0",
+  "\\bigvee": "\u22C1"
+};
+var FUNC_NAMES = /* @__PURE__ */ new Set([
+  "sin",
+  "cos",
+  "tan",
+  "cot",
+  "sec",
+  "csc",
+  "arcsin",
+  "arccos",
+  "arctan",
+  "sinh",
+  "cosh",
+  "tanh",
+  "coth",
+  "log",
+  "ln",
+  "exp",
+  "lim",
+  "min",
+  "max",
+  "sup",
+  "inf",
+  "det",
+  "dim",
+  "mod",
+  "gcd",
+  "deg",
+  "hom",
+  "ker"
+]);
+var LIMIT_FUNC_NAMES = /* @__PURE__ */ new Set(["lim", "min", "max", "sup", "inf", "det", "gcd"]);
+var ACCENT_MAP = {
+  "\\hat": "\u0302",
+  "\\check": "\u030C",
+  "\\tilde": "\u0303",
+  "\\acute": "\u0301",
+  "\\grave": "\u0300",
+  "\\dot": "\u0307",
+  "\\ddot": "\u0308",
+  "\\dddot": "\u20DB",
+  "\\breve": "\u0306",
+  "\\bar": "\u0305",
+  "\\vec": "\u20D7",
+  "\\overleftarrow": "\u20D6",
+  "\\overrightarrow": "\u20D7"
+};
+var ACCENT_ALIASES = {
+  "\u0304": "\u0305",
+  "^": "\u0302",
+  "~": "\u0303",
+  "\xAF": "\u0305"
+};
+var DELIM_MAP = {
+  "\\{": "{",
+  "\\}": "}",
+  "\\lbrace": "{",
+  "\\rbrace": "}",
+  "\\langle": "\u27E8",
+  "\\rangle": "\u27E9",
+  "\\lfloor": "\u230A",
+  "\\rfloor": "\u230B",
+  "\\lceil": "\u2308",
+  "\\rceil": "\u2309",
+  "\\vert": "|",
+  "\\lvert": "|",
+  "\\rvert": "|",
+  "\\|": "\u2016",
+  "\\Vert": "\u2016",
+  "\\lVert": "\u2016",
+  "\\rVert": "\u2016"
+};
+var MATRIX_ENVS = {
+  matrix: ["", ""],
+  pmatrix: ["(", ")"],
+  bmatrix: ["[", "]"],
+  Bmatrix: ["{", "}"],
+  vmatrix: ["|", "|"],
+  Vmatrix: ["\u2016", "\u2016"],
+  array: ["", ""]
+};
+var EQARR_ENVS = /* @__PURE__ */ new Set([
+  "aligned",
+  "align",
+  "align*",
+  "gather",
+  "gather*",
+  "gathered",
+  "eqnarray",
+  "eqnarray*",
+  "split"
+]);
+function invert(map) {
+  const reversed = {};
+  for (const [cmd, ch] of Object.entries(map)) {
+    if (!reversed[ch]) {
+      reversed[ch] = cmd;
+    }
+  }
+  return reversed;
+}
+var REVERSE_GREEK = invert(GREEK_MAP);
+var REVERSE_OPERATOR = invert(OPERATOR_MAP);
+var REVERSE_NARY = invert(NARY_MAP);
+var REVERSE_ACCENT = invert(ACCENT_MAP);
+var REVERSE_DELIM = invert(DELIM_MAP);
+var REVERSE_ESCAPE = {
+  "{": "\\{",
+  "}": "\\}",
+  _: "\\_",
+  "^": "\\^",
+  "%": "\\%",
+  "#": "\\#",
+  $: "\\$",
+  " ": "\\ ",
+  "\\": "\\backslash "
+};
+
+// src/math/latex-to-omml-constructs.ts
+function parseScriptArgs(ctx) {
+  const args = { sub: [], sup: [], hasSub: false, hasSup: false };
+  for (let round = 0; round < 2; round++) {
+    while (ctx.peek()?.type === "whitespace") {
+      ctx.next();
+    }
+    const tok = ctx.peek();
+    if (tok?.type === "superscript" && !args.hasSup) {
+      ctx.next();
+      args.sup = ctx.parseSingleOrGroup();
+      args.hasSup = true;
+    } else if (tok?.type === "subscript" && !args.hasSub) {
+      ctx.next();
+      args.sub = ctx.parseSingleOrGroup();
+      args.hasSub = true;
+    }
+  }
+  return args;
+}
+function applyScripts(ctx, base, args) {
+  if (args.hasSup && args.hasSub) {
+    return {
+      "m:sSubSup": {
+        "m:e": ctx.wrapE([base]),
+        "m:sub": ctx.wrapE(args.sub),
+        "m:sup": ctx.wrapE(args.sup)
+      }
+    };
+  }
+  if (args.hasSup) {
+    return {
+      "m:sSup": {
+        "m:e": ctx.wrapE([base]),
+        "m:sup": ctx.wrapE(args.sup)
+      }
+    };
+  }
+  if (args.hasSub) {
+    return {
+      "m:sSub": {
+        "m:e": ctx.wrapE([base]),
+        "m:sub": ctx.wrapE(args.sub)
+      }
+    };
+  }
+  return base;
+}
+function tryParseScripts(ctx, base) {
+  return applyScripts(ctx, base, parseScriptArgs(ctx));
+}
+function parseNary(ctx, operatorChar) {
+  let limLoc = "";
+  const limTok = ctx.peek();
+  if (limTok?.type === "command" && (limTok.value === "\\limits" || limTok.value === "\\nolimits")) {
+    ctx.next();
+    limLoc = limTok.value === "\\limits" ? "undOvr" : "subSup";
+  }
+  const { sub, sup, hasSub, hasSup } = parseScriptArgs(ctx);
+  const body = ctx.parseSingleOrGroup();
+  const naryPr = {
+    "m:chr": { "@_val": operatorChar }
+  };
+  if (limLoc) {
+    naryPr["m:limLoc"] = { "@_val": limLoc };
+  }
+  if (!hasSub) {
+    naryPr["m:subHide"] = { "@_val": "1" };
+  }
+  if (!hasSup) {
+    naryPr["m:supHide"] = { "@_val": "1" };
+  }
+  return {
+    "m:nary": {
+      "m:naryPr": naryPr,
+      "m:sub": hasSub ? ctx.wrapE(sub) : {},
+      "m:sup": hasSup ? ctx.wrapE(sup) : {},
+      "m:e": ctx.wrapE(body)
+    }
+  };
+}
+function readDelimiterChar(tok, fallback) {
+  if (!tok) {
+    return fallback;
+  }
+  if (tok.type === "command") {
+    return DELIM_MAP[tok.value] ?? tok.value.slice(1);
+  }
+  if (tok.value === ".") {
+    return "";
+  }
+  return tok.value;
+}
+function parseDelimiter(ctx) {
+  const openChar = readDelimiterChar(ctx.next(), "(");
+  const inner = [];
+  while (ctx.peek()) {
+    if (ctx.peek().type === "command" && ctx.peek().value === "\\right") {
+      ctx.next();
+      break;
+    }
+    const node = ctx.parseAtom();
+    if (node) {
+      inner.push(node);
+    }
+  }
+  const closeChar = readDelimiterChar(ctx.next(), ")");
+  const dPr = {};
+  if (openChar !== "(") {
+    dPr["m:begChr"] = { "@_val": openChar };
+  }
+  if (closeChar !== ")") {
+    dPr["m:endChr"] = { "@_val": closeChar };
+  }
+  return {
+    "m:d": {
+      "m:dPr": Object.keys(dPr).length > 0 ? dPr : void 0,
+      "m:e": ctx.wrapE(inner)
+    }
+  };
+}
+function parseFuncApplication(ctx, name) {
+  const fNameNode = ctx.makeRun(name, true);
+  const args = parseScriptArgs(ctx);
+  let withScripts;
+  if (LIMIT_FUNC_NAMES.has(name) && args.hasSub !== args.hasSup) {
+    const limit = {
+      "m:e": ctx.wrapE([fNameNode]),
+      "m:lim": ctx.wrapE(args.hasSub ? args.sub : args.sup)
+    };
+    withScripts = args.hasSub ? { "m:limLow": limit } : { "m:limUpp": limit };
+  } else {
+    withScripts = applyScripts(ctx, fNameNode, args);
+  }
+  let body = [];
+  if (ctx.peek()?.type === "group_start") {
+    body = ctx.parseGroup();
+  } else if (ctx.peek() && ctx.peek().type !== "group_end") {
+    const atom = ctx.parseAtom();
+    if (atom) {
+      body = [atom];
+    }
+  }
+  if (body.length === 0) {
+    return withScripts;
+  }
+  return {
+    "m:func": {
+      "m:fName": ctx.wrapE([withScripts]),
+      "m:e": ctx.wrapE(body)
+    }
+  };
+}
+function parseTextArgument(ctx) {
+  if (ctx.peek()?.type !== "group_start") {
+    const tok = ctx.next();
+    return tok ? tok.value : "";
+  }
+  ctx.next();
+  let depth = 1;
+  let text = "";
+  while (ctx.peek()) {
+    const tok = ctx.next();
+    if (tok.type === "group_start") {
+      depth++;
+    } else if (tok.type === "group_end") {
+      depth--;
+      if (depth === 0) {
+        break;
+      }
+    } else if (tok.type === "command") {
+      text += ESCAPE_MAP[tok.value] ?? OPERATOR_MAP[tok.value] ?? tok.value.slice(1);
+      continue;
+    }
+    if (depth > 0 && tok.type !== "group_start" && tok.type !== "group_end") {
+      text += tok.value;
+    }
+  }
+  return text;
+}
+
+// src/math/latex-to-omml-environments.ts
+function valNode(value) {
+  return { "@_val": value };
+}
+function wrapDelimited(ctx, inner, open, close) {
+  const dPr = {};
+  if (open !== "(") {
+    dPr["m:begChr"] = valNode(open);
+  }
+  if (close !== ")") {
+    dPr["m:endChr"] = valNode(close);
+  }
+  return {
+    "m:d": {
+      "m:dPr": Object.keys(dPr).length > 0 ? dPr : void 0,
+      "m:e": ctx.wrapE([inner])
+    }
+  };
+}
+function readEnvName(ctx) {
+  return parseTextArgument(ctx).trim();
+}
+function parseEnvBody(ctx) {
+  const rows = [];
+  let row = [];
+  let cell = [];
+  while (ctx.peek()) {
+    const tok = ctx.peek();
+    if (tok.type === "command" && tok.value === "\\end") {
+      ctx.next();
+      readEnvName(ctx);
+      break;
+    }
+    if (tok.type === "command" && tok.value === "\\\\") {
+      ctx.next();
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = [];
+      continue;
+    }
+    if (tok.type === "text" && tok.value === "&") {
+      ctx.next();
+      row.push(cell);
+      cell = [];
+      continue;
+    }
+    const atom = ctx.parseAtom();
+    if (atom) {
+      cell.push(atom);
+    }
+  }
+  if (cell.length > 0 || row.length > 0) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows;
+}
+function buildMatrix(ctx, rows) {
+  return {
+    "m:m": {
+      "m:mr": rows.map((cells) => ({
+        "m:e": cells.map((cell) => ctx.wrapE(cell))
+      }))
+    }
+  };
+}
+function buildEqArr(ctx, rows) {
+  const lines = rows.map((cells) => {
+    const nodes = [];
+    cells.forEach((cell, index) => {
+      if (index > 0) {
+        nodes.push(ctx.makeRun("&"));
+      }
+      nodes.push(...cell);
+    });
+    return ctx.wrapE(nodes);
+  });
+  return { "m:eqArr": { "m:e": lines } };
+}
+function parseEnvironment(ctx) {
+  const name = readEnvName(ctx);
+  if (name === "array" && ctx.peek()?.type === "group_start") {
+    parseTextArgument(ctx);
+  }
+  const rows = parseEnvBody(ctx);
+  const matrixDelims = MATRIX_ENVS[name];
+  if (matrixDelims) {
+    const matrix = buildMatrix(ctx, rows);
+    const [open, close] = matrixDelims;
+    return open || close ? wrapDelimited(ctx, matrix, open, close) : matrix;
+  }
+  if (name === "cases") {
+    return wrapDelimited(ctx, buildEqArr(ctx, rows), "{", "");
+  }
+  if (EQARR_ENVS.has(name) || rows.length > 1) {
+    return buildEqArr(ctx, rows);
+  }
+  const inline = rows.flat(2);
+  return inline.length > 0 ? ctx.wrapE(inline) : null;
+}
+function parseAccent(ctx, chr) {
+  return {
+    "m:acc": {
+      "m:accPr": { "m:chr": valNode(chr) },
+      "m:e": ctx.wrapE(ctx.parseSingleOrGroup())
+    }
+  };
+}
+function parseBar(ctx, pos) {
+  return {
+    "m:bar": {
+      "m:barPr": { "m:pos": valNode(pos) },
+      "m:e": ctx.wrapE(ctx.parseSingleOrGroup())
+    }
+  };
+}
+function parseGroupChr(ctx, chr, pos) {
+  const groupChrPr = { "m:chr": valNode(chr) };
+  if (pos === "top") {
+    groupChrPr["m:pos"] = valNode("top");
+  }
+  const group = {
+    "m:groupChr": {
+      "m:groupChrPr": groupChrPr,
+      "m:e": ctx.wrapE(ctx.parseSingleOrGroup())
+    }
+  };
+  const args = parseScriptArgs(ctx);
+  if (pos === "bot" && args.hasSub && !args.hasSup) {
+    return { "m:limLow": { "m:e": group, "m:lim": ctx.wrapE(args.sub) } };
+  }
+  if (pos === "top" && args.hasSup && !args.hasSub) {
+    return { "m:limUpp": { "m:e": group, "m:lim": ctx.wrapE(args.sup) } };
+  }
+  return applyScripts(ctx, group, args);
+}
+function parseUnderOverset(ctx, tag) {
+  const lim = ctx.parseSingleOrGroup();
+  const base = ctx.parseSingleOrGroup();
+  const limit = { "m:e": ctx.wrapE(base), "m:lim": ctx.wrapE(lim) };
+  return tag === "m:limLow" ? { "m:limLow": limit } : { "m:limUpp": limit };
+}
+function parseBoxed(ctx) {
+  return { "m:borderBox": { "m:e": ctx.wrapE(ctx.parseSingleOrGroup()) } };
+}
+function parsePhantom(ctx, kind) {
+  const phantPr = {};
+  if (kind === "h") {
+    phantPr["m:zeroAsc"] = valNode("1");
+    phantPr["m:zeroDesc"] = valNode("1");
+  } else if (kind === "v") {
+    phantPr["m:zeroWid"] = valNode("1");
+  }
+  return {
+    "m:phant": {
+      "m:phantPr": Object.keys(phantPr).length > 0 ? phantPr : void 0,
+      "m:e": ctx.wrapE(ctx.parseSingleOrGroup())
+    }
+  };
+}
+function buildPrescript(ctx, sub, sup) {
+  const base = ctx.parseAtom();
+  return {
+    "m:sPre": {
+      "m:sub": ctx.wrapE(sub),
+      "m:sup": ctx.wrapE(sup),
+      "m:e": base ?? {}
+    }
+  };
+}
+function parsePrescript(ctx) {
+  const sup = ctx.parseSingleOrGroup();
+  const sub = ctx.parseSingleOrGroup();
+  return buildPrescript(ctx, sub, sup);
+}
+function parseOperatorName(ctx) {
+  return parseFuncApplication(ctx, parseTextArgument(ctx));
+}
+
+// src/math/latex-to-omml-commands.ts
+function parseFraction(ctx, cmd) {
+  const num = ctx.parseGroup();
+  const den = ctx.parseGroup();
+  const frac = { "m:num": ctx.wrapE(num), "m:den": ctx.wrapE(den) };
+  if (cmd === "\\sfrac" || cmd === "\\binom") {
+    frac["m:fPr"] = {
+      "m:type": { "@_val": cmd === "\\sfrac" ? "lin" : "noBar" }
+    };
+  }
+  const node = { "m:f": frac };
+  if (cmd === "\\binom") {
+    return { "m:d": { "m:e": node } };
+  }
+  return node;
+}
+function parseRadical(ctx) {
+  if (ctx.peek()?.type === "text" && ctx.peek()?.value === "[") {
+    ctx.next();
+    const degree = [];
+    while (ctx.peek() && !(ctx.peek().type === "text" && ctx.peek().value === "]")) {
+      const atom = ctx.parseAtom();
+      if (atom) {
+        degree.push(atom);
+      }
+    }
+    if (ctx.peek()?.value === "]") {
+      ctx.next();
+    }
+    return {
+      "m:rad": {
+        "m:deg": ctx.wrapE(degree),
+        "m:e": ctx.wrapE(ctx.parseGroup())
+      }
+    };
+  }
+  return {
+    "m:rad": {
+      "m:radPr": { "m:degHide": { "@_val": "1" } },
+      "m:e": ctx.wrapE(ctx.parseGroup())
+    }
+  };
+}
+function parseCommand(ctx, cmd) {
+  const symbol = GREEK_MAP[cmd] ?? OPERATOR_MAP[cmd] ?? ESCAPE_MAP[cmd];
+  if (symbol !== void 0) {
+    return symbol === "" ? null : ctx.makeRun(symbol);
+  }
+  if (NARY_MAP[cmd]) {
+    return parseNary(ctx, NARY_MAP[cmd]);
+  }
+  if (ACCENT_MAP[cmd]) {
+    return parseAccent(ctx, ACCENT_MAP[cmd]);
+  }
+  switch (cmd) {
+    case "\\frac":
+    case "\\dfrac":
+    case "\\tfrac":
+    case "\\sfrac":
+    case "\\binom":
+      return parseFraction(ctx, cmd);
+    case "\\sqrt":
+      return parseRadical(ctx);
+    case "\\text":
+    case "\\mathrm":
+    case "\\textrm":
+    case "\\mbox":
+      return ctx.makeRun(parseTextArgument(ctx), true);
+    case "\\operatorname":
+      return parseOperatorName(ctx);
+    case "\\left":
+      return parseDelimiter(ctx);
+    case "\\right":
+    case "\\\\":
+    case "\\limits":
+    case "\\nolimits":
+    case "\\displaystyle":
+    case "\\textstyle":
+      return null;
+    case "\\begin":
+      return parseEnvironment(ctx);
+    case "\\end":
+      parseTextArgument(ctx);
+      return null;
+    case "\\overline":
+      return parseBar(ctx, "top");
+    case "\\underline":
+      return parseBar(ctx, "bot");
+    case "\\overbrace":
+      return parseGroupChr(ctx, "\u23DE", "top");
+    case "\\underbrace":
+      return parseGroupChr(ctx, "\u23DF", "bot");
+    case "\\overset":
+      return parseUnderOverset(ctx, "m:limUpp");
+    case "\\underset":
+      return parseUnderOverset(ctx, "m:limLow");
+    case "\\boxed":
+      return parseBoxed(ctx);
+    case "\\phantom":
+      return parsePhantom(ctx, "full");
+    case "\\hphantom":
+      return parsePhantom(ctx, "h");
+    case "\\vphantom":
+      return parsePhantom(ctx, "v");
+    case "\\prescript":
+      return parsePrescript(ctx);
+  }
+  const funcName = cmd.slice(1);
+  if (FUNC_NAMES.has(funcName)) {
+    return parseFuncApplication(ctx, funcName);
+  }
+  return ctx.makeRun(funcName, true);
+}
+
+// src/math/omml-to-latex-helpers.ts
+function ensureArr(val2) {
+  if (val2 === void 0 || val2 === null) {
+    return [];
+  }
+  if (Array.isArray(val2)) {
+    return val2.filter((entry) => Boolean(entry) && typeof entry === "object");
+  }
+  if (typeof val2 === "object") {
+    return [val2];
+  }
+  return [];
+}
+function childNode(node, key) {
+  if (!node) {
+    return {};
+  }
+  const v = node[key];
+  if (Array.isArray(v)) {
+    return ensureArr(v)[0] ?? {};
+  }
+  if (v && typeof v === "object") {
+    return v;
+  }
+  return {};
+}
+function attrVal(node) {
+  if (!node) {
+    return "";
+  }
+  const v = node["@_val"];
+  if (typeof v === "string") {
+    return v;
+  }
+  return v !== void 0 && v !== null ? String(v) : "";
+}
+function hasAttr(node) {
+  return Boolean(node) && node["@_val"] !== void 0;
+}
+function isOn(node) {
+  const v = attrVal(node);
+  return v === "1" || v === "on" || v === "true";
+}
+function readRunText(run) {
+  const t = run["m:t"];
+  if (typeof t === "string") {
+    return t;
+  }
+  if (typeof t === "number" || typeof t === "boolean") {
+    return String(t);
+  }
+  if (Array.isArray(t)) {
+    return t.map((entry) => readRunText({ "m:t": entry })).join("");
+  }
+  if (t && typeof t === "object") {
+    const inner = t["#text"];
+    return typeof inner === "string" || typeof inner === "number" ? String(inner) : "";
+  }
+  return "";
+}
+function contentKeys(node) {
+  return Object.keys(node).filter((key) => {
+    if (key.startsWith("@_") || key === "#text") {
+      return false;
+    }
+    const tag = stripXmlOrderSuffix(key);
+    return !tag.endsWith("Pr") && tag !== "m:t";
+  });
+}
+function soleChild(container) {
+  if (!container) {
+    return null;
+  }
+  const keys = contentKeys(container);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const items = ensureArr(container[keys[0]]);
+  if (items.length !== 1) {
+    return null;
+  }
+  return { tag: stripXmlOrderSuffix(keys[0]), node: items[0] };
+}
+function escapeChar(ch) {
+  if (REVERSE_GREEK[ch]) {
+    return `${REVERSE_GREEK[ch]} `;
+  }
+  if (REVERSE_OPERATOR[ch]) {
+    return `${REVERSE_OPERATOR[ch]} `;
+  }
+  return REVERSE_ESCAPE[ch] ?? ch;
+}
+function escapeMathText(text) {
+  return Array.from(text).map(escapeChar).join("");
+}
+var TEXT_ARGUMENT_ESCAPES = {
+  "\\": "\\backslash ",
+  "{": "\\{",
+  "}": "\\}"
+};
+function escapeTextArgument(text) {
+  return text.replace(/[\\{}]/gu, (ch) => TEXT_ARGUMENT_ESCAPES[ch] ?? ch);
+}
+function isSingleAtom(container) {
+  const sole = soleChild(container);
+  if (!sole) {
+    return false;
+  }
+  if (sole.tag !== "m:r") {
+    return true;
+  }
+  const text = readRunText(sole.node);
+  if (isOn(childNode(childNode(sole.node, "m:rPr"), "m:nor"))) {
+    return true;
+  }
+  return Array.from(text).length === 1;
+}
+function collectText(node) {
+  if (node === null || node === void 0) {
+    return "";
+  }
+  if (typeof node === "string" || typeof node === "number") {
+    return String(node);
+  }
+  if (Array.isArray(node)) {
+    return node.map((entry) => collectText(entry)).join("");
+  }
+  if (typeof node !== "object") {
+    return "";
+  }
+  const record = node;
+  let out = "";
+  for (const [key, value] of Object.entries(record)) {
+    if (key.startsWith("@_")) {
+      continue;
+    }
+    const tag = stripXmlOrderSuffix(key);
+    if (tag === "m:t") {
+      out += escapeMathText(readRunText(record));
+    } else if (tag === "#text") {
+      out += escapeMathText(String(value));
+    } else if (!tag.endsWith("Pr")) {
+      out += collectText(value);
+    }
+  }
+  return out;
+}
+
+// src/math/omml-to-latex-layout.ts
+var CMD_ENDS_WITH_LETTER = /[a-zA-Z]$/u;
+var PLAIN_DELIM = /^[()[\]|]$/u;
+function naryToLatex(emit, node) {
+  const naryPr = childNode(node, "m:naryPr");
+  const chr = attrVal(childNode(naryPr, "m:chr"));
+  let result = chr ? REVERSE_NARY[chr] ?? escapeMathText(chr) : "\\int";
+  if (attrVal(childNode(naryPr, "m:limLoc")) === "undOvr") {
+    result += "\\limits";
+  }
+  const sub = emit.arg(node, "m:sub");
+  const sup = emit.arg(node, "m:sup");
+  if (sub && !isOn(childNode(naryPr, "m:subHide"))) {
+    result += `_{${sub}}`;
+  }
+  if (sup && !isOn(childNode(naryPr, "m:supHide"))) {
+    result += `^{${sup}}`;
+  }
+  return `${result}{${emit.arg(node, "m:e")}}`;
+}
+function delimToLatex(chr) {
+  if (chr.length === 0) {
+    return ".";
+  }
+  if (PLAIN_DELIM.test(chr)) {
+    return chr;
+  }
+  const cmd = REVERSE_DELIM[chr];
+  if (cmd) {
+    return CMD_ENDS_WITH_LETTER.test(cmd) ? `${cmd} ` : cmd;
+  }
+  return chr;
+}
+function matrixEnvFor(open, close) {
+  return Object.keys(MATRIX_ENVS).find((env) => {
+    const [envOpen, envClose] = MATRIX_ENVS[env];
+    return env !== "array" && env !== "matrix" && envOpen === open && envClose === close;
+  });
+}
+function rowsToLatex(emit, rows) {
+  return rows.map((row) => emit.children(row)).join(" \\\\ ");
+}
+function matrixToLatex(emit, node, env) {
+  const rows = ensureArr(node["m:mr"]).map(
+    (row) => ensureArr(row["m:e"]).map((cell) => emit.children(cell)).join(" & ")
+  );
+  return `\\begin{${env}}${rows.join(" \\\\ ")}\\end{${env}}`;
+}
+function eqArrToLatex(emit, node) {
+  return `\\begin{aligned}${rowsToLatex(emit, ensureArr(node["m:e"]))}\\end{aligned}`;
+}
+function delimiterToLatex(emit, node) {
+  const dPr = childNode(node, "m:dPr");
+  const begNode = childNode(dPr, "m:begChr");
+  const endNode = childNode(dPr, "m:endChr");
+  const open = hasAttr(begNode) ? attrVal(begNode) : "(";
+  const close = hasAttr(endNode) ? attrVal(endNode) : ")";
+  const elements2 = ensureArr(node["m:e"]);
+  const sole = elements2.length === 1 ? soleChild(elements2[0]) : null;
+  if (sole?.tag === "m:m") {
+    const env = matrixEnvFor(open, close);
+    if (env) {
+      return matrixToLatex(emit, sole.node, env);
+    }
+  }
+  if (sole?.tag === "m:eqArr" && open === "{" && close === "") {
+    return `\\begin{cases}${rowsToLatex(emit, ensureArr(sole.node["m:e"]))}\\end{cases}`;
+  }
+  if (sole?.tag === "m:f" && open === "(" && close === ")") {
+    if (attrVal(childNode(childNode(sole.node, "m:fPr"), "m:type")) === "noBar") {
+      return `\\binom{${emit.arg(sole.node, "m:num")}}{${emit.arg(sole.node, "m:den")}}`;
+    }
+  }
+  const sepNode = childNode(dPr, "m:sepChr");
+  const separator = hasAttr(sepNode) ? attrVal(sepNode) : "|";
+  const inner = elements2.map((e) => emit.children(e)).join(escapeMathText(separator));
+  return `\\left${delimToLatex(open)}${inner}\\right${delimToLatex(close)}`;
+}
+
+// src/math/omml-to-latex.ts
+function childrenToLatex(node) {
+  if (!node || typeof node !== "object") {
+    return "";
+  }
+  const parts = [];
+  for (const key of contentKeys(node)) {
+    const tag = stripXmlOrderSuffix(key);
+    for (const item of ensureArr(node[key])) {
+      parts.push(elementToLatex(tag, item));
+    }
+  }
+  return parts.join("");
+}
+function arg(node, key) {
+  return childrenToLatex(childNode(node, key));
+}
+var emitter = { children: childrenToLatex, arg };
+function scriptBase(node) {
+  const base = arg(node, "m:e");
+  return isSingleAtom(childNode(node, "m:e")) || base.length <= 1 ? base : `{${base}}`;
+}
+function runToLatex(node) {
+  const text = readRunText(node);
+  if (text.length === 0) {
+    return "";
+  }
+  if (isOn(childNode(childNode(node, "m:rPr"), "m:nor"))) {
+    return `\\text{${escapeTextArgument(text)}}`;
+  }
+  return escapeMathText(text);
+}
+function fractionToLatex(node) {
+  const type = attrVal(childNode(childNode(node, "m:fPr"), "m:type"));
+  const num = arg(node, "m:num");
+  const den = arg(node, "m:den");
+  if (type === "lin") {
+    return `\\sfrac{${num}}{${den}}`;
+  }
+  if (type === "noBar") {
+    return `{${num} \\atop ${den}}`;
+  }
+  return `\\frac{${num}}{${den}}`;
+}
+function radicalToLatex(node) {
+  const base = arg(node, "m:e");
+  if (isOn(childNode(childNode(node, "m:radPr"), "m:degHide"))) {
+    return `\\sqrt{${base}}`;
+  }
+  const deg = arg(node, "m:deg");
+  return deg ? `\\sqrt[${deg}]{${base}}` : `\\sqrt{${base}}`;
+}
+function funcNameToLatex(fName) {
+  const sole = soleChild(fName);
+  let nameNode = null;
+  let scripts = "";
+  if (sole?.tag === "m:r") {
+    nameNode = sole.node;
+  } else if (sole && ["m:sSub", "m:sSup", "m:sSubSup", "m:limLow", "m:limUpp"].includes(sole.tag)) {
+    const inner = soleChild(childNode(sole.node, "m:e"));
+    if (inner?.tag === "m:r") {
+      nameNode = inner.node;
+      const sub = arg(sole.node, sole.tag === "m:limLow" ? "m:lim" : "m:sub");
+      const sup = arg(sole.node, sole.tag === "m:limUpp" ? "m:lim" : "m:sup");
+      scripts = `${sub ? `_{${sub}}` : ""}${sup ? `^{${sup}}` : ""}`;
+    }
+  }
+  if (!nameNode) {
+    return childrenToLatex(fName);
+  }
+  const name = readRunText(nameNode).trim();
+  const spelled = FUNC_NAMES.has(name) ? `\\${name}` : `\\operatorname{${escapeTextArgument(name)}}`;
+  return `${spelled}${scripts}`;
+}
+function accentToLatex(node) {
+  const raw = attrVal(childNode(childNode(node, "m:accPr"), "m:chr")) || "\u0302";
+  const chr = ACCENT_ALIASES[raw] ?? raw;
+  const cmd = REVERSE_ACCENT[chr];
+  const base = arg(node, "m:e");
+  return cmd ? `${cmd}{${base}}` : `\\overset{${escapeMathText(chr)}}{${base}}`;
+}
+function groupChrToLatex(node, label = "") {
+  const groupChrPr = childNode(node, "m:groupChrPr");
+  const chr = attrVal(childNode(groupChrPr, "m:chr")) || "\u23DF";
+  const top = attrVal(childNode(groupChrPr, "m:pos")) === "top";
+  const base = arg(node, "m:e");
+  if (chr === "\u23DF" && !top) {
+    return `\\underbrace{${base}}${label ? `_{${label}}` : ""}`;
+  }
+  if (chr === "\u23DE" && top) {
+    return `\\overbrace{${base}}${label ? `^{${label}}` : ""}`;
+  }
+  const wrapped = `\\${top ? "overset" : "underset"}{${escapeMathText(chr)}}{${base}}`;
+  return label ? `\\${top ? "overset" : "underset"}{${label}}{${wrapped}}` : wrapped;
+}
+function limitToLatex(node, tag) {
+  const lim = arg(node, "m:lim");
+  const sole = soleChild(childNode(node, "m:e"));
+  if (sole?.tag === "m:groupChr") {
+    const top = attrVal(childNode(childNode(sole.node, "m:groupChrPr"), "m:pos")) === "top";
+    if (top === (tag === "m:limUpp")) {
+      return groupChrToLatex(sole.node, lim);
+    }
+  }
+  return `\\${tag === "m:limLow" ? "underset" : "overset"}{${lim}}{${arg(node, "m:e")}}`;
+}
+function phantomToLatex(node) {
+  const phantPr = childNode(node, "m:phantPr");
+  const base = arg(node, "m:e");
+  if (isOn(childNode(phantPr, "m:zeroWid"))) {
+    return `\\vphantom{${base}}`;
+  }
+  if (isOn(childNode(phantPr, "m:zeroAsc")) || isOn(childNode(phantPr, "m:zeroDesc"))) {
+    return `\\hphantom{${base}}`;
+  }
+  return `\\phantom{${base}}`;
+}
+function elementToLatex(tag, node) {
+  switch (tag) {
+    case "m:r":
+      return runToLatex(node);
+    case "m:f":
+      return fractionToLatex(node);
+    case "m:rad":
+      return radicalToLatex(node);
+    case "m:sSup":
+      return `${scriptBase(node)}^{${arg(node, "m:sup")}}`;
+    case "m:sSub":
+      return `${scriptBase(node)}_{${arg(node, "m:sub")}}`;
+    case "m:sSubSup":
+      return `${scriptBase(node)}_{${arg(node, "m:sub")}}^{${arg(node, "m:sup")}}`;
+    case "m:sPre":
+      return `{}_{${arg(node, "m:sub")}}^{${arg(node, "m:sup")}}{${arg(node, "m:e")}}`;
+    case "m:nary":
+      return naryToLatex(emitter, node);
+    case "m:d":
+      return delimiterToLatex(emitter, node);
+    case "m:func":
+      return `${funcNameToLatex(childNode(node, "m:fName"))}{${arg(node, "m:e")}}`;
+    case "m:m":
+      return matrixToLatex(emitter, node, "matrix");
+    case "m:eqArr":
+      return eqArrToLatex(emitter, node);
+    case "m:acc":
+      return accentToLatex(node);
+    case "m:bar":
+      return `\\${attrVal(childNode(childNode(node, "m:barPr"), "m:pos")) === "bot" ? "underline" : "overline"}{${arg(node, "m:e")}}`;
+    case "m:limLow":
+    case "m:limUpp":
+      return limitToLatex(node, tag);
+    case "m:groupChr":
+      return groupChrToLatex(node);
+    case "m:borderBox":
+      return `\\boxed{${arg(node, "m:e")}}`;
+    case "m:phant":
+      return phantomToLatex(node);
+    case "m:box":
+      return ensureArr(node["m:e"]).map((e) => childrenToLatex(e)).join("");
+    case "m:oMath":
+      return childrenToLatex(node);
+    default:
+      return collectText(node);
+  }
+}
+function convertOmmlToLatex(omml) {
+  if (!omml || typeof omml !== "object") {
+    return "";
+  }
+  const para = omml["m:oMathPara"];
+  const roots = para ? ensureArr(para).flatMap((p) => ensureArr(p["m:oMath"])) : [];
+  if (roots.length > 0) {
+    return roots.map((root) => childrenToLatex(root)).join(" ");
+  }
+  if (omml["m:oMath"]) {
+    return ensureArr(omml["m:oMath"]).map((root) => childrenToLatex(root)).join(" ");
+  }
+  return childrenToLatex(omml);
+}
+
+// src/math/latex-to-omml.ts
+var LatexParser = class {
+  tokens;
+  pos = 0;
+  /** Set for one `parseAtom` call: the atom is a bare script argument and takes no scripts of its own. */
+  bare = false;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    return this.tokens[this.pos++];
+  }
+  expect(type) {
+    const tok = this.next();
+    if (!tok || tok.type !== type) {
+      throw new Error(`Expected ${type}, got ${tok?.type ?? "EOF"}`);
+    }
+    return tok;
+  }
+  parseGroup() {
+    this.expect("group_start");
+    const nodes = [];
+    while (this.peek() && this.peek().type !== "group_end") {
+      const tok = this.peek();
+      if (tok.type === "command" && (tok.value === "\\atop" || tok.value === "\\over")) {
+        this.next();
+        const den = this.parseGroupRest();
+        const frac = { "m:num": this.wrapE(nodes), "m:den": this.wrapE(den) };
+        if (tok.value === "\\atop") {
+          frac["m:fPr"] = { "m:type": { "@_val": "noBar" } };
+        }
+        return [{ "m:f": frac }];
+      }
+      const node = this.parseAtom();
+      if (node) {
+        nodes.push(node);
+      }
+    }
+    this.expect("group_end");
+    return nodes;
+  }
+  /** Parse atoms up to and including the closing brace of the current group. */
+  parseGroupRest() {
+    const nodes = [];
+    while (this.peek() && this.peek().type !== "group_end") {
+      const node = this.parseAtom();
+      if (node) {
+        nodes.push(node);
+      }
+    }
+    this.expect("group_end");
+    return nodes;
+  }
+  /**
+   * A braced group, or a single bare atom. A bare atom does not take its own
+   * scripts: in `x_i^2` the `^2` belongs to `x`, not to `i`.
+   */
+  parseSingleOrGroup() {
+    if (this.peek()?.type === "group_start") {
+      return this.parseGroup();
+    }
+    this.bare = true;
+    const atom = this.parseAtom();
+    this.bare = false;
+    return atom ? [atom] : [];
+  }
+  wrapE(nodes) {
+    if (nodes.length === 1) {
+      return nodes[0];
+    }
+    return mergeSiblings(nodes);
+  }
+  makeRun(text, normal = false) {
+    const run = { "m:t": text };
+    if (normal) {
+      run["m:rPr"] = { "m:nor": { "@_val": "1" } };
+    }
+    return { "m:r": run };
+  }
+  parseAtom() {
+    const tok = this.peek();
+    if (!tok) {
+      return null;
+    }
+    if (tok.type === "whitespace") {
+      this.next();
+      return this.parseAtom();
+    }
+    const bare = this.bare;
+    this.bare = false;
+    const scripted = (node) => bare ? node : tryParseScripts(this, node);
+    if (tok.type === "text") {
+      this.next();
+      return scripted(this.makeRun(tok.value));
+    }
+    if (tok.type === "group_start") {
+      const group = this.parseGroup();
+      if (group.length === 0) {
+        const args = parseScriptArgs(this);
+        if (args.hasSub || args.hasSup) {
+          return buildPrescript(this, args.sub, args.sup);
+        }
+        return null;
+      }
+      const base = group.length === 1 ? group[0] : this.wrapE(group);
+      return scripted(base);
+    }
+    if (tok.type === "command") {
+      this.next();
+      const node = parseCommand(this, tok.value);
+      return node ? scripted(node) : null;
+    }
+    if (tok.type === "superscript" || tok.type === "subscript") {
+      this.next();
+      const arg2 = this.parseSingleOrGroup();
+      const empty = this.makeRun("");
+      if (tok.type === "superscript") {
+        return {
+          "m:sSup": {
+            "m:e": this.wrapE([empty]),
+            "m:sup": this.wrapE(arg2)
+          }
+        };
+      }
+      return {
+        "m:sSub": {
+          "m:e": this.wrapE([empty]),
+          "m:sub": this.wrapE(arg2)
+        }
+      };
+    }
+    return null;
+  }
+  parseAll() {
+    const nodes = [];
+    while (this.peek()) {
+      const node = this.parseAtom();
+      if (node) {
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+};
+function convertLatexToOmml(latex) {
+  const trimmed = latex.replace(/^\s+/u, "").replace(/(?<!\\)\s+$/u, "");
+  if (trimmed.length === 0) {
+    return {};
+  }
+  const tokens = tokenize(trimmed);
+  const parser = new LatexParser(tokens);
+  const nodes = parser.parseAll();
+  if (nodes.length === 0) {
+    return {};
+  }
+  const oMath = mergeSiblings(nodes);
+  return {
+    "m:oMathPara": {
+      "m:oMath": oMath
+    }
+  };
+}
+
+// src/math/omml-color.ts
+function getOmmlMathColor(node) {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const drawingRunProperties = node["a:rPr"];
+  if (drawingRunProperties && typeof drawingRunProperties === "object") {
+    const solidFill = drawingRunProperties["a:solidFill"];
+    const srgbColor = solidFill && typeof solidFill === "object" ? solidFill["a:srgbClr"] : void 0;
+    const value = srgbColor?.["@_val"];
+    if (typeof value === "string" && /^[0-9a-f]{6}$/iu.test(value)) {
+      return `#${value.toUpperCase()}`;
+    }
+  }
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const child2 of value) {
+        if (child2 && typeof child2 === "object") {
+          const color = getOmmlMathColor(child2);
+          if (color) {
+            return color;
+          }
+        }
+      }
+    } else if (value && typeof value === "object") {
+      const color = getOmmlMathColor(value);
+      if (color) {
+        return color;
+      }
+    }
+  }
+  return void 0;
+}
+function getOmmlMathFontSize(node) {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const drawingRunProperties = node["a:rPr"];
+  if (drawingRunProperties && typeof drawingRunProperties === "object") {
+    const size = Number(drawingRunProperties["@_sz"]);
+    if (Number.isFinite(size) && size > 0) {
+      return size / 100;
+    }
+  }
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const child2 of value) {
+        if (child2 && typeof child2 === "object") {
+          const size = getOmmlMathFontSize(child2);
+          if (size) {
+            return size;
+          }
+        }
+      }
+    } else if (value && typeof value === "object") {
+      const size = getOmmlMathFontSize(value);
+      if (size) {
+        return size;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/math/omml-mathml-helpers.ts
+function child(node, key) {
+  if (!node) {
+    return {};
+  }
+  const v = node[key];
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    return v;
+  }
+  return {};
+}
+function ensureArray(value) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "object") {
+    return [value];
+  }
+  return [];
+}
+function attr3(node, name) {
+  if (!node) {
+    return "";
+  }
+  const v = node[`@_${name}`];
+  return typeof v === "string" ? v : v !== void 0 ? String(v) : "";
+}
+function val(node) {
+  return attr3(node, "val");
+}
+function escapeXml(text) {
+  return text.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;");
+}
+function readText(node) {
+  const textNode = node["m:t"];
+  if (typeof textNode === "string") {
+    return textNode;
+  }
+  if (typeof textNode === "number" || typeof textNode === "boolean") {
+    return String(textNode);
+  }
+  if (textNode && typeof textNode === "object" && !Array.isArray(textNode)) {
+    const inner = textNode["#text"];
+    return typeof inner === "string" ? inner : "";
+  }
+  return "";
+}
+var OPERATOR_CHARS = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "\u2212",
+  "\xB1",
+  "\u2213",
+  "\xD7",
+  "\xF7",
+  "\xB7",
+  "=",
+  "\u2260",
+  "\u2248",
+  "\u2261",
+  "\u2264",
+  "\u2265",
+  "<",
+  ">",
+  "\u226A",
+  "\u226B",
+  "\u2208",
+  "\u2209",
+  "\u2282",
+  "\u2283",
+  "\u2286",
+  "\u2287",
+  "\u222A",
+  "\u2229",
+  "\u2192",
+  "\u2190",
+  "\u2194",
+  "\u21D2",
+  "\u21D0",
+  "\u21D4",
+  "\u221E",
+  "\u2234",
+  "\u2235",
+  "\u221D",
+  "\u2200",
+  "\u2203",
+  ",",
+  ";",
+  ":",
+  "!",
+  "?",
+  ".",
+  "|",
+  "/",
+  "\\",
+  "'",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  "\u27E8",
+  "\u27E9"
+]);
+function isOperator(ch) {
+  return OPERATOR_CHARS.has(ch.trim());
+}
+function isNumeric(text) {
+  return /^[0-9]+(?:[.,][0-9]+)?$/u.test(text.trim());
+}
+var ACCENT_MAP2 = {
+  "\u0302": "^",
+  // combining circumflex → hat
+  "\u0303": "~",
+  // combining tilde
+  "\u0304": "\xAF",
+  // combining macron → bar
+  "\u0305": "\xAF",
+  // combining overline → bar
+  "\u0307": "\u02D9",
+  // combining dot above
+  "\u0308": "\xA8",
+  // combining diaeresis
+  "\u030C": "\u02C7",
+  // combining caron
+  "\u0332": "_",
+  // combining underbar
+  "\u20D7": "\u2192",
+  // combining right arrow above → →
+  "^": "^",
+  "~": "~",
+  "\xAF": "\xAF",
+  "\u02D9": "\u02D9",
+  "\xA8": "\xA8",
+  "\u02C7": "\u02C7"
+};
+var NARY_CHAR_MAP = {
+  "\u2211": "\u2211",
+  // ∑
+  "\u220F": "\u220F",
+  // ∏
+  "\u222B": "\u222B",
+  // ∫
+  "\u222C": "\u222C",
+  // ∬
+  "\u222D": "\u222D",
+  // ∭
+  "\u222E": "\u222E",
+  // ∮
+  "\u2210": "\u2210",
+  // ∐
+  "\u22C0": "\u22C0",
+  // ⋀
+  "\u22C1": "\u22C1",
+  // ⋁
+  "\u22C2": "\u22C2",
+  // ⋂
+  "\u22C3": "\u22C3"
+  // ⋃
+};
+var DELIM_BEGIN_MAP = {
+  "(": "(",
+  "[": "[",
+  "{": "{",
+  "|": "|",
+  "\u2016": "\u2016",
+  "\u27E8": "\u27E8",
+  "\u2308": "\u2308",
+  "\u230A": "\u230A"
+};
+var DELIM_END_MAP = {
+  ")": ")",
+  "]": "]",
+  "}": "}",
+  "|": "|",
+  "\u2016": "\u2016",
+  "\u27E9": "\u27E9",
+  "\u2309": "\u2309",
+  "\u230B": "\u230B"
+};
+
+// src/math/omml-mathml-converters.ts
+function convertRun(node) {
+  const text = readText(node);
+  if (text.length === 0) {
+    return "";
+  }
+  const escaped = escapeXml(text);
+  const rPr = child(node, "m:rPr");
+  const norVal = val(child(rPr, "m:nor"));
+  const isNormal = norVal === "1" || norVal === "on" || norVal === "true";
+  if (isNumeric(text)) {
+    return `<mn>${escaped}</mn>`;
+  }
+  if (isOperator(text)) {
+    return `<mo>${escaped}</mo>`;
+  }
+  if (isNormal) {
+    return `<mi mathvariant="normal">${escaped}</mi>`;
+  }
+  return `<mi>${escaped}</mi>`;
+}
+function convertFraction(node, cc) {
+  const fPr = child(node, "m:fPr");
+  const fracType = val(child(fPr, "m:type"));
+  const num = `<mrow>${cc(child(node, "m:num"))}</mrow>`;
+  const den = `<mrow>${cc(child(node, "m:den"))}</mrow>`;
+  if (fracType === "lin") {
+    return `<mrow>${num}<mo>/</mo>${den}</mrow>`;
+  }
+  if (fracType === "noBar") {
+    return `<mfrac linethickness="0">${num}${den}</mfrac>`;
+  }
+  return `<mfrac>${num}${den}</mfrac>`;
+}
+function convertRadical(node, cc) {
+  const radPr = child(node, "m:radPr");
+  const degHide = val(child(radPr, "m:degHide"));
+  const base = cc(child(node, "m:e"));
+  const degree = cc(child(node, "m:deg"));
+  if (degHide === "1" || degHide === "on" || degHide === "true" || degree.length === 0) {
+    return `<msqrt><mrow>${base}</mrow></msqrt>`;
+  }
+  return `<mroot><mrow>${base}</mrow><mrow>${degree}</mrow></mroot>`;
+}
+function convertSuperscript(node, cc) {
+  const base = cc(child(node, "m:e"));
+  const sup = cc(child(node, "m:sup"));
+  return `<msup><mrow>${base}</mrow><mrow>${sup}</mrow></msup>`;
+}
+function convertSubscript(node, cc) {
+  const base = cc(child(node, "m:e"));
+  const sub = cc(child(node, "m:sub"));
+  return `<msub><mrow>${base}</mrow><mrow>${sub}</mrow></msub>`;
+}
+function convertSubSup(node, cc) {
+  const base = cc(child(node, "m:e"));
+  const sub = cc(child(node, "m:sub"));
+  const sup = cc(child(node, "m:sup"));
+  return `<msubsup><mrow>${base}</mrow><mrow>${sub}</mrow><mrow>${sup}</mrow></msubsup>`;
+}
+function convertPreSubSup(node, cc) {
+  const base = cc(child(node, "m:e"));
+  const sub = cc(child(node, "m:sub"));
+  const sup = cc(child(node, "m:sup"));
+  return `<mmultiscripts><mrow>${base}</mrow><mprescripts/><mrow>${sub}</mrow><mrow>${sup}</mrow></mmultiscripts>`;
+}
+function convertNary(node, cc) {
+  const naryPr = child(node, "m:naryPr");
+  const chrVal = val(child(naryPr, "m:chr"));
+  const limLocVal = val(child(naryPr, "m:limLoc"));
+  const subHide = val(child(naryPr, "m:subHide"));
+  const supHide = val(child(naryPr, "m:supHide"));
+  const operatorChar = chrVal ? NARY_CHAR_MAP[chrVal] || chrVal : "\u222B";
+  const sub = cc(child(node, "m:sub"));
+  const sup = cc(child(node, "m:sup"));
+  const base = cc(child(node, "m:e"));
+  const showSub = subHide !== "1" && subHide !== "on" && subHide !== "true" && sub.length > 0;
+  const showSup = supHide !== "1" && supHide !== "on" && supHide !== "true" && sup.length > 0;
+  let result;
+  if (showSub && showSup) {
+    if (limLocVal === "undOvr") {
+      result = `<munderover><mo>${escapeXml(operatorChar)}</mo><mrow>${sub}</mrow><mrow>${sup}</mrow></munderover>`;
+    } else {
+      result = `<msubsup><mo>${escapeXml(operatorChar)}</mo><mrow>${sub}</mrow><mrow>${sup}</mrow></msubsup>`;
+    }
+  } else if (showSub) {
+    if (limLocVal === "undOvr") {
+      result = `<munder><mo>${escapeXml(operatorChar)}</mo><mrow>${sub}</mrow></munder>`;
+    } else {
+      result = `<msub><mo>${escapeXml(operatorChar)}</mo><mrow>${sub}</mrow></msub>`;
+    }
+  } else if (showSup) {
+    if (limLocVal === "undOvr") {
+      result = `<mover><mo>${escapeXml(operatorChar)}</mo><mrow>${sup}</mrow></mover>`;
+    } else {
+      result = `<msup><mo>${escapeXml(operatorChar)}</mo><mrow>${sup}</mrow></msup>`;
+    }
+  } else {
+    result = `<mo>${escapeXml(operatorChar)}</mo>`;
+  }
+  return `<mrow>${result}<mrow>${base}</mrow></mrow>`;
+}
+function convertDelimiter(node, cc) {
+  const dPr = child(node, "m:dPr");
+  const begChrVal = val(child(dPr, "m:begChr"));
+  const endChrVal = val(child(dPr, "m:endChr"));
+  const sepChrVal = val(child(dPr, "m:sepChr"));
+  const open = begChrVal.length > 0 ? begChrVal : "(";
+  const close = endChrVal.length > 0 ? endChrVal : ")";
+  const separator = sepChrVal.length > 0 ? sepChrVal : "";
+  const openChar = DELIM_BEGIN_MAP[open] || open;
+  const closeChar = DELIM_END_MAP[close] || close;
+  const elements2 = ensureArray(node["m:e"]);
+  const parts = [];
+  for (let i = 0; i < elements2.length; i++) {
+    if (i > 0 && separator.length > 0) {
+      parts.push(`<mo>${escapeXml(separator)}</mo>`);
+    }
+    parts.push(`<mrow>${cc(elements2[i])}</mrow>`);
+  }
+  const openMo = open ? `<mo>${escapeXml(openChar)}</mo>` : "<mo></mo>";
+  const closeMo = close ? `<mo>${escapeXml(closeChar)}</mo>` : "<mo></mo>";
+  return `<mrow>${openMo}${parts.join("")}${closeMo}</mrow>`;
+}
+function convertMatrix(node, cc) {
+  const rows = ensureArray(node["m:mr"]);
+  const tableRows = [];
+  for (const row of rows) {
+    const cells = ensureArray(row["m:e"]);
+    const tdParts = [];
+    for (const cell of cells) {
+      tdParts.push(`<mtd><mrow>${cc(cell)}</mrow></mtd>`);
+    }
+    tableRows.push(`<mtr>${tdParts.join("")}</mtr>`);
+  }
+  return `<mrow><mo>[</mo><mtable>${tableRows.join("")}</mtable><mo>]</mo></mrow>`;
+}
+function convertAccent(node, cc) {
+  const accPr = child(node, "m:accPr");
+  const chrVal = val(child(accPr, "m:chr"));
+  const base = cc(child(node, "m:e"));
+  const accentChar = chrVal.length > 0 ? ACCENT_MAP2[chrVal] || chrVal : "\u0302";
+  return `<mover accent="true"><mrow>${base}</mrow><mo>${escapeXml(accentChar)}</mo></mover>`;
+}
+function convertBar(node, cc) {
+  const barPr = child(node, "m:barPr");
+  const posVal = val(child(barPr, "m:pos"));
+  const base = cc(child(node, "m:e"));
+  if (posVal === "bot") {
+    return `<munder><mrow>${base}</mrow><mo>\xAF</mo></munder>`;
+  }
+  return `<mover><mrow>${base}</mrow><mo>\xAF</mo></mover>`;
+}
+function convertLimLow(node, cc) {
+  const base = cc(child(node, "m:e"));
+  const lim = cc(child(node, "m:lim"));
+  return `<munder><mrow>${base}</mrow><mrow>${lim}</mrow></munder>`;
+}
+function convertLimUpp(node, cc) {
+  const base = cc(child(node, "m:e"));
+  const lim = cc(child(node, "m:lim"));
+  return `<mover><mrow>${base}</mrow><mrow>${lim}</mrow></mover>`;
+}
+function convertGroupChr(node, cc) {
+  const grpPr = child(node, "m:groupChrPr");
+  const chrVal = val(child(grpPr, "m:chr"));
+  const posVal = val(child(grpPr, "m:pos"));
+  const base = cc(child(node, "m:e"));
+  const chr = chrVal.length > 0 ? chrVal : "\u23DF";
+  if (posVal === "top") {
+    return `<mover><mrow>${base}</mrow><mo>${escapeXml(chr)}</mo></mover>`;
+  }
+  return `<munder><mrow>${base}</mrow><mo>${escapeXml(chr)}</mo></munder>`;
+}
+function convertEqArr(node, cc) {
+  const elements2 = ensureArray(node["m:e"]);
+  const rows = [];
+  for (const el of elements2) {
+    rows.push(`<mtr><mtd><mrow>${cc(el)}</mrow></mtd></mtr>`);
+  }
+  return `<mtable columnalign="left">${rows.join("")}</mtable>`;
+}
+function convertBox(node, cc) {
+  return `<mrow>${cc(child(node, "m:e"))}</mrow>`;
+}
+function convertFunc(node, cc) {
+  const fName = cc(child(node, "m:fName"));
+  const base = cc(child(node, "m:e"));
+  return `<mrow>${fName}<mo>&#x2061;</mo><mrow>${base}</mrow></mrow>`;
+}
+
+// src/math/omml-to-mathml.ts
+function convertChildren(node) {
+  if (!node || typeof node !== "object") {
+    return "";
+  }
+  const parts = [];
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) {
+      continue;
+    }
+    const tag = stripXmlOrderSuffix(key);
+    if (tag === "m:oMathPara") {
+      continue;
+    }
+    const items = ensureArray(node[key]);
+    for (const item of items) {
+      const result = convertElement(tag, item);
+      if (result) {
+        parts.push(result);
+      }
+    }
+  }
+  return parts.join("");
+}
+function convertElement(tag, node) {
+  switch (tag) {
+    case "m:r":
+      return convertRun(node);
+    case "m:f":
+      return convertFraction(node, convertChildren);
+    case "m:rad":
+      return convertRadical(node, convertChildren);
+    case "m:sSup":
+      return convertSuperscript(node, convertChildren);
+    case "m:sSub":
+      return convertSubscript(node, convertChildren);
+    case "m:sSubSup":
+      return convertSubSup(node, convertChildren);
+    case "m:sPre":
+      return convertPreSubSup(node, convertChildren);
+    case "m:nary":
+      return convertNary(node, convertChildren);
+    case "m:d":
+      return convertDelimiter(node, convertChildren);
+    case "m:m":
+      return convertMatrix(node, convertChildren);
+    case "m:acc":
+      return convertAccent(node, convertChildren);
+    case "m:bar":
+      return convertBar(node, convertChildren);
+    case "m:limLow":
+      return convertLimLow(node, convertChildren);
+    case "m:limUpp":
+      return convertLimUpp(node, convertChildren);
+    case "m:groupChr":
+      return convertGroupChr(node, convertChildren);
+    case "m:eqArr":
+      return convertEqArr(node, convertChildren);
+    case "m:box":
+      return convertBox(node, convertChildren);
+    case "m:borderBox":
+      return convertBox(node, convertChildren);
+    case "m:func":
+      return convertFunc(node, convertChildren);
+    case "m:oMath":
+      return `<mrow>${convertChildren(node)}</mrow>`;
+    default:
+      return "";
+  }
+}
+function findOmathRoots(node) {
+  if (node["m:oMath"]) {
+    return ensureArray(node["m:oMath"]);
+  }
+  const para = node["m:oMathPara"];
+  if (para) {
+    const paraNode = Array.isArray(para) ? para[0] : para;
+    if (paraNode["m:oMath"]) {
+      return ensureArray(paraNode["m:oMath"]);
+    }
+  }
+  const contentTags = /* @__PURE__ */ new Set(["m:r", "m:f", "m:rad", "m:sSup", "m:sSub", "m:box"]);
+  if (Object.keys(node).some((key) => contentTags.has(stripXmlOrderSuffix(key)))) {
+    return [node];
+  }
+  return [];
+}
+function convertOmmlToMathMl(ommlNode) {
+  if (!ommlNode || typeof ommlNode !== "object") {
+    return "";
+  }
+  const oMaths = findOmathRoots(ommlNode);
+  if (oMaths.length === 0) {
+    return "";
+  }
+  const innerParts = oMaths.map((om) => convertChildren(om));
+  const inner = innerParts.join("");
+  if (inner.length === 0) {
+    return "";
+  }
+  const color = getOmmlMathColor(ommlNode);
+  const colorAttribute = color ? ` mathcolor="${color}"` : "";
+  const fontSize = getOmmlMathFontSize(ommlNode);
+  const sizeAttribute = fontSize ? ` mathsize="${fontSize}pt"` : "";
+  return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"${colorAttribute}${sizeAttribute}>${inner}</math>`;
+}
+function ommlToMathml(omml) {
+  if (typeof omml === "string") {
+    return "";
+  }
+  return convertOmmlToMathMl(omml);
+}
+
+// src/math/omml-dom.ts
+var PREFIXES = {
+  "http://schemas.openxmlformats.org/officeDocument/2006/math": "m",
+  "http://purl.oclc.org/ooxml/officeDocument/math": "m",
+  "http://schemas.openxmlformats.org/drawingml/2006/main": "a",
+  "http://schemas.openxmlformats.org/wordprocessingml/2006/main": "w"
+};
+function ommlFromElement(element) {
+  const visit = (node) => {
+    const prefix = PREFIXES[node.namespaceURI ?? ""];
+    const name = prefix ? `${prefix}:${node.localName}` : node.tagName;
+    const body = mergeSiblings(elements(node).map(visit));
+    for (const attribute of Array.from(node.attributes)) {
+      if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
+      body[`@_${attribute.localName}`] = attribute.value;
+    }
+    const text = Array.from(node.childNodes).filter((child2) => child2.nodeType === 3 || child2.nodeType === 4).map((child2) => child2.nodeValue ?? "").join("");
+    if (text && (!elements(node).length || text.trim())) body["#text"] = text;
+    return { [name]: body };
+  };
+  return visit(element);
+}
+function parseOmml(xml) {
+  return ommlFromElement(parseXml(xml, { label: "OMML" }).documentElement);
+}
+
+export { color_exports as color, diagram_exports as diagram, geometry_exports as geometry, math_exports as math, opc_exports as opc, units_exports as units, xml_exports as xml };