ooxml-core 1.13.0 → 1.15.0

package/dist/math/index.cjs

@@ -79,13 +79,13 @@ function mergeSiblings(nodes) {
     for (const [key] of entries) {
       counts.set(key, (counts.get(key) ?? 0) + 1);
     }
-    const ordered = {};
+    const ordered = /* @__PURE__ */ Object.create(null);
     for (const [position, [key, value]] of entries.entries()) {
       ordered[(counts.get(key) ?? 0) > 1 ? orderedXmlKey(key, position) : key] = value;
     }
     return ordered;
   }
-  const result = {};
+  const result = /* @__PURE__ */ Object.create(null);
   for (const [key, value] of entries) {
     if (result[key]) {
       const existing = result[key];
@@ -338,7 +338,7 @@ var REVERSE_ESCAPE = {
 // math/latex-to-omml-constructs.ts
 function parseScriptArgs(ctx) {
   const args = { sub: [], sup: [], hasSub: false, hasSup: false };
-  for (let round = 0; round < 2; round++) {
+  for (let round2 = 0; round2 < 2; round2++) {
     while (ctx.peek()?.type === "whitespace") {
       ctx.next();
     }
@@ -540,7 +540,7 @@ function readEnvName(ctx) {
 }
 function parseEnvBody(ctx) {
   const rows = [];
-  let row = [];
+  let row2 = [];
   let cell = [];
   while (ctx.peek()) {
     const tok = ctx.peek();
@@ -551,15 +551,15 @@ function parseEnvBody(ctx) {
     }
     if (tok.type === "command" && tok.value === "\\\\") {
       ctx.next();
-      row.push(cell);
-      rows.push(row);
-      row = [];
+      row2.push(cell);
+      rows.push(row2);
+      row2 = [];
       cell = [];
       continue;
     }
     if (tok.type === "text" && tok.value === "&") {
       ctx.next();
-      row.push(cell);
+      row2.push(cell);
       cell = [];
       continue;
     }
@@ -568,9 +568,9 @@ function parseEnvBody(ctx) {
       cell.push(atom);
     }
   }
-  if (cell.length > 0 || row.length > 0) {
-    row.push(cell);
-    rows.push(row);
+  if (cell.length > 0 || row2.length > 0) {
+    row2.push(cell);
+    rows.push(row2);
   }
   return rows;
 }
@@ -604,9 +604,9 @@ function parseEnvironment(ctx) {
   const rows = parseEnvBody(ctx);
   const matrixDelims = MATRIX_ENVS[name];
   if (matrixDelims) {
-    const matrix = buildMatrix(ctx, rows);
+    const matrix2 = buildMatrix(ctx, rows);
     const [open, close] = matrixDelims;
-    return open || close ? wrapDelimited(ctx, matrix, open, close) : matrix;
+    return open || close ? wrapDelimited(ctx, matrix2, open, close) : matrix2;
   }
   if (name === "cases") {
     return wrapDelimited(ctx, buildEqArr(ctx, rows), "{", "");
@@ -998,11 +998,11 @@ function matrixEnvFor(open, close) {
   });
 }
 function rowsToLatex(emit, rows) {
-  return rows.map((row) => emit.children(row)).join(" \\\\ ");
+  return rows.map((row2) => emit.children(row2)).join(" \\\\ ");
 }
 function matrixToLatex(emit, node, env) {
   const rows = ensureArr(node["m:mr"]).map(
-    (row) => ensureArr(row["m:e"]).map((cell) => emit.children(cell)).join(" & ")
+    (row2) => ensureArr(row2["m:e"]).map((cell) => emit.children(cell)).join(" & ")
   );
   return `\\begin{${env}}${rows.join(" \\\\ ")}\\end{${env}}`;
 }
@@ -1092,7 +1092,7 @@ function radicalToLatex(node) {
 function funcNameToLatex(fName) {
   const sole = soleChild(fName);
   let nameNode = null;
-  let scripts = "";
+  let scripts2 = "";
   if (sole?.tag === "m:r") {
     nameNode = sole.node;
   } else if (sole && ["m:sSub", "m:sSup", "m:sSubSup", "m:limLow", "m:limUpp"].includes(sole.tag)) {
@@ -1101,7 +1101,7 @@ function funcNameToLatex(fName) {
       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}}` : ""}`;
+      scripts2 = `${sub ? `_{${sub}}` : ""}${sup ? `^{${sup}}` : ""}`;
     }
   }
   if (!nameNode) {
@@ -1109,7 +1109,7 @@ function funcNameToLatex(fName) {
   }
   const name = readRunText(nameNode).trim();
   const spelled = FUNC_NAMES.has(name) ? `\\${name}` : `\\operatorname{${escapeTextArgument(name)}}`;
-  return `${spelled}${scripts}`;
+  return `${spelled}${scripts2}`;
 }
 function accentToLatex(node) {
   const raw = attrVal(childNode(childNode(node, "m:accPr"), "m:chr")) || "\u0302";
@@ -1217,14 +1217,27 @@ function convertOmmlToLatex(omml) {
 }
 
 // math/latex-to-omml.ts
+var MAX_NESTING_DEPTH = 512;
 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;
+  /** Current group nesting; bounded so hostile input cannot exhaust the call stack. */
+  depth = 0;
   constructor(tokens) {
     this.tokens = tokens;
   }
+  nest(parse) {
+    if (++this.depth > MAX_NESTING_DEPTH) {
+      throw new Error(`LaTeX nesting exceeds ${MAX_NESTING_DEPTH} levels`);
+    }
+    try {
+      return parse();
+    } finally {
+      this.depth--;
+    }
+  }
   peek() {
     return this.tokens[this.pos];
   }
@@ -1239,6 +1252,9 @@ var LatexParser = class {
     return tok;
   }
   parseGroup() {
+    return this.nest(() => this.readGroup());
+  }
+  readGroup() {
     this.expect("group_start");
     const nodes = [];
     while (this.peek() && this.peek().type !== "group_end") {
@@ -1262,6 +1278,9 @@ var LatexParser = class {
   }
   /** Parse atoms up to and including the closing brace of the current group. */
   parseGroupRest() {
+    return this.nest(() => this.readGroupRest());
+  }
+  readGroupRest() {
     const nodes = [];
     while (this.peek() && this.peek().type !== "group_end") {
       const node = this.parseAtom();
@@ -1280,10 +1299,12 @@ var LatexParser = class {
     if (this.peek()?.type === "group_start") {
       return this.parseGroup();
     }
-    this.bare = true;
-    const atom = this.parseAtom();
-    this.bare = false;
-    return atom ? [atom] : [];
+    return this.nest(() => {
+      this.bare = true;
+      const atom = this.parseAtom();
+      this.bare = false;
+      return atom ? [atom] : [];
+    });
   }
   wrapE(nodes) {
     if (nodes.length === 1) {
@@ -1304,7 +1325,7 @@ var LatexParser = class {
       return null;
     }
     if (tok.type === "whitespace") {
-      this.next();
+      while (this.peek()?.type === "whitespace") this.next();
       return this.parseAtom();
     }
     const bare = this.bare;
@@ -1382,70 +1403,6 @@ function convertLatexToOmml(latex) {
   };
 }
 
-// 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;
-}
-
 // math/omml-mathml-helpers.ts
 function child(node, key) {
   if (!node) {
@@ -1631,13 +1588,722 @@ var DELIM_END_MAP = {
   "\u230B": "\u230B"
 };
 
+// math/omml-to-xml.ts
+var OMML_NAMESPACE = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+var escapeAttribute = (value) => escapeXml(value).replace(/"/g, "&quot;");
+function element(tag, value) {
+  if (value === void 0 || value === null) return "";
+  if (Array.isArray(value)) return value.map((item) => element(tag, item)).join("");
+  if (typeof value !== "object") {
+    const text = String(value);
+    const space = tag === "m:t" && /^\s|\s$/.test(text) ? ' xml:space="preserve"' : "";
+    return `<${tag}${space}>${escapeXml(text)}</${tag}>`;
+  }
+  const node = value;
+  let attributes = "";
+  let content = "";
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_")) {
+      attributes += ` ${tag === "m:t" ? "" : "m:"}${key.slice(2)}="${escapeAttribute(String(node[key]))}"`;
+    } else if (key === "#text") {
+      content += escapeXml(String(node[key]));
+    } else content += element(stripXmlOrderSuffix(key), node[key]);
+  }
+  if (tag === "m:t" && /^\s|\s$/.test(content) && !attributes) attributes = ' xml:space="preserve"';
+  return content ? `<${tag}${attributes}>${content}</${tag}>` : `<${tag}${attributes}/>`;
+}
+function ommlToXml(tree) {
+  const markup = Object.keys(tree).map((key) => element(stripXmlOrderSuffix(key), tree[key])).join("");
+  return markup.replace(/^<([\w:]+)/, `<$1 xmlns:m="${OMML_NAMESPACE}"`);
+}
+function latexToOmmlXml(latex, display) {
+  const tree = convertLatexToOmml(latex);
+  const para = tree["m:oMathPara"];
+  const math = para?.["m:oMath"];
+  if (!math) return void 0;
+  return ommlToXml(display ? tree : { "m:oMath": math });
+}
+
+// math/omml-box.ts
+var AXIS = 0.25;
+var emptyBox = () => ({ width: 0, ascent: 0, descent: 0, prims: [] });
+function scriptStyle(style) {
+  return {
+    ...style,
+    level: style.level + 1,
+    size: style.level >= 2 ? style.size : style.size * 0.7
+  };
+}
+function shifted(prims, dx, dy) {
+  return prims.map((prim) => {
+    switch (prim.kind) {
+      case "text":
+        return { ...prim, x: prim.x + dx, y: prim.y + dy };
+      case "line":
+        return { ...prim, x1: prim.x1 + dx, x2: prim.x2 + dx, y1: prim.y1 + dy, y2: prim.y2 + dy };
+      case "rect":
+        return { ...prim, x: prim.x + dx, y: prim.y + dy };
+      default:
+        return { ...prim, d: translatePath(prim.d, dx, dy) };
+    }
+  });
+}
+function translatePath(d, dx, dy) {
+  return d.replace(
+    /([ML])\s*(-?[\d.]+)[ ,]+(-?[\d.]+)/g,
+    (_m, cmd, x, y) => `${cmd}${round(Number(x) + dx)} ${round(Number(y) + dy)}`
+  );
+}
+var round = (value) => Math.round(value * 100) / 100;
+function row(boxes, gap = 0) {
+  const result = emptyBox();
+  let x = 0;
+  for (const box of boxes) {
+    if (result.prims.length || x > 0) x += gap;
+    result.prims.push(...shifted(box.prims, x, 0));
+    x += box.width;
+    result.ascent = Math.max(result.ascent, box.ascent);
+    result.descent = Math.max(result.descent, box.descent);
+  }
+  result.width = x;
+  return result;
+}
+function placed(box, dx, dy) {
+  return {
+    width: box.width,
+    ascent: box.ascent - dy,
+    descent: box.descent + dy,
+    prims: shifted(box.prims, dx, dy)
+  };
+}
+function overlay(parts) {
+  const result = emptyBox();
+  for (const { box, x, y } of parts) {
+    result.prims.push(...shifted(box.prims, x, y));
+    result.width = Math.max(result.width, x + box.width);
+    result.ascent = Math.max(result.ascent, box.ascent - y);
+    result.descent = Math.max(result.descent, box.descent + y);
+  }
+  return result;
+}
+var RELATIONS = new Set("=\u2260<>\u2264\u2265\u2248\u2261\u226A\u226B\u2208\u2209\u2282\u2283\u2286\u2287\u2192\u2190\u2194\u21D2\u21D0\u21D4\u221D\u2245\u223C\u2243".split(""));
+var BINARY = new Set("+\u2212-\xD7\xF7\xB7\xB1\u2213\u222A\u2229\u2227\u2228\u2295\u2297\u2218\u2217".split(""));
+var isRelation = (ch) => RELATIONS.has(ch);
+var isBinary = (ch) => BINARY.has(ch);
+function glyphEm(ch, bold) {
+  let em;
+  if (/[iIjl|!.,;:'`]/.test(ch)) em = ch === "I" ? 0.36 : 0.3;
+  else if (/[ftr]/.test(ch)) em = 0.38;
+  else if (/[mwMW@]/.test(ch)) em = ch === "m" ? 0.82 : 0.86;
+  else if (/[A-Z]/.test(ch)) em = 0.66;
+  else if (/[a-z]/.test(ch)) em = 0.52;
+  else if (/[0-9]/.test(ch)) em = 0.5;
+  else if (/[()[\]{}]/.test(ch)) em = 0.34;
+  else if (ch === " ") em = 0.25;
+  else if (isRelation(ch) || isBinary(ch)) em = 0.7;
+  else if (/[Ͱ-Ͽ]/.test(ch)) em = 0.58;
+  else if (/[⺀-鿿＀-￯]/.test(ch)) em = 1;
+  else em = 0.6;
+  return bold ? em * 1.08 : em;
+}
+var isOn2 = (value) => value === "1" || value === "on" || value === "true";
+function glyph(text, size, stretch = 1) {
+  const width = Array.from(text).reduce((sum, ch) => sum + glyphEm(ch, false), 0) * size;
+  const box = emptyBox();
+  box.width = width;
+  box.ascent = size * 0.78 * stretch;
+  box.descent = size * 0.22 * stretch;
+  box.prims.push({
+    kind: "text",
+    x: 0,
+    y: 0,
+    text,
+    size,
+    italic: false,
+    bold: false,
+    fit: width,
+    ...stretch > 1 ? { stretch } : {}
+  });
+  return box;
+}
+function scripts(base, sub, sup, style) {
+  const raise = Math.max(style.size * 0.4, base.ascent - style.size * 0.3);
+  const drop = Math.max(style.size * 0.2, base.descent + style.size * 0.12);
+  const parts = [{ box: base, x: 0, y: 0 }];
+  let width = base.width;
+  if (sup) {
+    const y = -Math.max(raise, sup.descent + style.size * 0.25);
+    parts.push({ box: sup, x: base.width + 1, y });
+    width = Math.max(width, base.width + 1 + sup.width);
+  }
+  if (sub) {
+    const y = Math.max(drop, sub.ascent - style.size * 0.1);
+    parts.push({ box: sub, x: base.width + 1, y });
+    width = Math.max(width, base.width + 1 + sub.width);
+  }
+  const box = overlay(parts);
+  box.width = width;
+  return box;
+}
+
+// math/omml-box-grouped.ts
+var NARY = /* @__PURE__ */ new Set(["\u2211", "\u220F", "\u2210", "\u22C0", "\u22C1", "\u22C2", "\u22C3"]);
+function nary(node, style, ctx) {
+  const pr = child(node, "m:naryPr");
+  const chr = val(child(pr, "m:chr")) || "\u222B";
+  const big = NARY.has(chr) ? 1.4 : 1.6;
+  const op = glyph(chr, style.size * big);
+  op.ascent = style.size * 0.78 * (big > 1.5 ? 1.5 : 1.25);
+  op.descent = style.size * (big > 1.5 ? 0.55 : 0.4);
+  const limits = (val(child(pr, "m:limLoc")) || (NARY.has(chr) ? "undOvr" : "subSup")) === "undOvr";
+  const sub = isOn2(val(child(pr, "m:subHide"))) ? void 0 : ctx.layout(child(node, "m:sub"), ctx.script(style));
+  const sup = isOn2(val(child(pr, "m:supHide"))) ? void 0 : ctx.layout(child(node, "m:sup"), ctx.script(style));
+  const hasSub = Boolean(sub?.width);
+  const hasSup = Boolean(sup?.width);
+  let head;
+  if (limits && (hasSub || hasSup)) {
+    const width = Math.max(op.width, sub?.width ?? 0, sup?.width ?? 0);
+    const parts = [{ box: op, x: (width - op.width) / 2, y: 0 }];
+    if (hasSup)
+      parts.push({
+        box: sup,
+        x: (width - sup.width) / 2,
+        y: -(op.ascent + sup.descent + style.size * 0.05)
+      });
+    if (hasSub)
+      parts.push({
+        box: sub,
+        x: (width - sub.width) / 2,
+        y: op.descent + sub.ascent + style.size * 0.05
+      });
+    head = overlay(parts);
+    head.width = width;
+  } else head = scripts(op, hasSub ? sub : void 0, hasSup ? sup : void 0, style);
+  const body = ctx.layout(child(node, "m:e"), style);
+  return row([head, body], style.size * 0.12);
+}
+var MATCHING_OPEN = {
+  "(": "(",
+  "[": "[",
+  "{": "{",
+  "|": "|",
+  "\u2016": "\u2016",
+  "\u27E8": "\u27E8",
+  "\u2308": "\u2308",
+  "\u230A": "\u230A"
+};
+function delimiter(node, style, ctx) {
+  const pr = child(node, "m:dPr");
+  const begin = child(pr, "m:begChr")["@_val"] === void 0 ? "(" : val(child(pr, "m:begChr"));
+  const end = child(pr, "m:endChr")["@_val"] === void 0 ? ")" : val(child(pr, "m:endChr"));
+  const separator = val(child(pr, "m:sepChr")) || "|";
+  const cells = ensureArray(node["m:e"]).map((cell) => ctx.layout(cell, style));
+  const parts = [];
+  cells.forEach((cell, index) => {
+    if (index > 0) parts.push(glyph(separator, style.size));
+    parts.push(cell);
+  });
+  const content = row(parts, style.size * 0.05);
+  const tall = (content.ascent + content.descent) / style.size;
+  const stretch = Math.max(1, tall / 1);
+  const open = begin ? glyph(MATCHING_OPEN[begin] ?? begin, style.size, stretch) : emptyBox();
+  const close = end ? glyph(end, style.size, stretch) : emptyBox();
+  return row([open, content, close], style.size * 0.04);
+}
+function matrix(node, style, ctx) {
+  const rows = ensureArray(node["m:mr"]).map(
+    (mr) => ensureArray(mr["m:e"]).map((cell) => ctx.layout(cell, style))
+  );
+  const columns = Math.max(0, ...rows.map((cells) => cells.length));
+  const widths = Array.from(
+    { length: columns },
+    (_, c) => Math.max(0, ...rows.map((cells) => cells[c]?.width ?? 0))
+  );
+  const gapX = style.size * 0.8;
+  const gapY = style.size * 0.3;
+  const result = emptyBox();
+  let y = 0;
+  const heights = rows.map((cells) => ({
+    a: Math.max(style.size * 0.78, ...cells.map((cell) => cell.ascent)),
+    d: Math.max(style.size * 0.22, ...cells.map((cell) => cell.descent))
+  }));
+  const total = heights.reduce((sum, h) => sum + h.a + h.d, 0) + gapY * Math.max(0, rows.length - 1);
+  y = -(total / 2) + style.size * AXIS;
+  rows.forEach((cells, r) => {
+    const h = heights[r];
+    y += h.a;
+    let x = 0;
+    cells.forEach((cell, c) => {
+      result.prims.push(...shifted(cell.prims, x + (widths[c] - cell.width) / 2, y));
+      x += widths[c] + gapX;
+    });
+    y += h.d + gapY;
+  });
+  result.width = widths.reduce((sum, w) => sum + w, 0) + gapX * Math.max(0, columns - 1);
+  result.ascent = total / 2 + style.size * AXIS;
+  result.descent = total / 2 - style.size * AXIS;
+  return result;
+}
+function above(base, mark, style) {
+  const width = Math.max(base.width, mark.width);
+  const box = overlay([
+    { box: base, x: (width - base.width) / 2, y: 0 },
+    {
+      box: mark,
+      x: (width - mark.width) / 2,
+      y: -(base.ascent + mark.descent + style.size * 0.04)
+    }
+  ]);
+  box.width = width;
+  return box;
+}
+function below(base, mark, style) {
+  const width = Math.max(base.width, mark.width);
+  const box = overlay([
+    { box: base, x: (width - base.width) / 2, y: 0 },
+    { box: mark, x: (width - mark.width) / 2, y: base.descent + mark.ascent + style.size * 0.04 }
+  ]);
+  box.width = width;
+  return box;
+}
+
+// math/omml-box-structures.ts
+function fraction(node, style, ctx) {
+  const type = val(child(child(node, "m:fPr"), "m:type"));
+  const inner = ctx.script({ ...style, level: Math.min(style.level, 0) });
+  const small = style.level === 0 ? { ...style, size: style.size * 0.9 } : inner;
+  const num = ctx.layout(child(node, "m:num"), small);
+  const den = ctx.layout(child(node, "m:den"), small);
+  if (type === "lin") {
+    const slash = glyph("/", style.size);
+    return row([num, slash, den]);
+  }
+  const gap = style.size * 0.12;
+  const axis = style.size * AXIS;
+  const width = Math.max(num.width, den.width) + style.size * 0.2;
+  const bar = type === "noBar" ? [] : [
+    {
+      kind: "line",
+      x1: 0,
+      x2: width,
+      y1: -axis,
+      y2: -axis,
+      width: Math.max(0.8, style.size * 0.05)
+    }
+  ];
+  const box = overlay([
+    { box: num, x: (width - num.width) / 2, y: -(axis + gap + num.descent) },
+    { box: den, x: (width - den.width) / 2, y: -axis + gap + den.ascent }
+  ]);
+  box.width = width;
+  box.prims.push(...bar);
+  return box;
+}
+function radical(node, style, ctx) {
+  const content = ctx.layout(child(node, "m:e"), style);
+  const hide = isOn2(val(child(child(node, "m:radPr"), "m:degHide")));
+  const degree = hide ? void 0 : ctx.layout(child(node, "m:deg"), { ...ctx.script(ctx.script(style)) });
+  const gap = style.size * 0.12;
+  const top = -(content.ascent + gap);
+  const bottom = content.descent + style.size * 0.05;
+  const height = bottom - top;
+  const sign = style.size * 0.55;
+  const lead = degree && degree.width ? Math.max(0, degree.width - sign * 0.4) : 0;
+  const x0 = lead;
+  const d = `M${round(x0)} ${round(top + height * 0.58)} L${round(x0 + sign * 0.22)} ${round(top + height * 0.52)} L${round(x0 + sign * 0.5)} ${round(bottom)} L${round(x0 + sign)} ${round(top)} L${round(x0 + sign + content.width + style.size * 0.1)} ${round(top)}`;
+  const parts = [{ box: content, x: x0 + sign + style.size * 0.05, y: 0 }];
+  const box = overlay(parts);
+  box.ascent = Math.max(box.ascent, -top);
+  box.descent = Math.max(box.descent, bottom);
+  box.width = x0 + sign + content.width + style.size * 0.15;
+  box.prims.push({ kind: "path", d, width: Math.max(0.8, style.size * 0.06) });
+  if (degree) box.prims.push(...shifted(degree.prims, 0, top + height * 0.35 - degree.descent));
+  return box;
+}
+function layoutStructure(tag, node, style, ctx) {
+  const arg2 = (name, next = style) => ctx.layout(child(node, name), next);
+  const small = () => ctx.script(style);
+  switch (tag) {
+    case "m:f":
+      return fraction(node, style, ctx);
+    case "m:rad":
+      return radical(node, style, ctx);
+    case "m:sSup":
+      return scripts(arg2("m:e"), void 0, arg2("m:sup", small()), style);
+    case "m:sSub":
+      return scripts(arg2("m:e"), arg2("m:sub", small()), void 0, style);
+    case "m:sSubSup":
+      return scripts(arg2("m:e"), arg2("m:sub", small()), arg2("m:sup", small()), style);
+    case "m:sPre": {
+      const pre = scripts(emptyBox(), arg2("m:sub", small()), arg2("m:sup", small()), style);
+      return row([pre, arg2("m:e")], 1);
+    }
+    case "m:nary":
+      return nary(node, style, ctx);
+    case "m:d":
+      return delimiter(node, style, ctx);
+    case "m:m":
+      return matrix(node, style, ctx);
+    case "m:acc": {
+      const chr = val(child(child(node, "m:accPr"), "m:chr")) || "\u0302";
+      const mark = glyph(
+        chr === "\u0302" ? "^" : chr === "\u0303" ? "~" : chr === "\u0304" ? "\xAF" : chr,
+        style.size * 0.8
+      );
+      mark.ascent = style.size * 0.2;
+      mark.descent = 0;
+      return above(arg2("m:e"), mark, style);
+    }
+    case "m:bar": {
+      const base = arg2("m:e");
+      const under = val(child(child(node, "m:barPr"), "m:pos")) === "bot";
+      const y = under ? base.descent + style.size * 0.08 : -(base.ascent + style.size * 0.08);
+      const box = overlay([{ box: base, x: 0, y: 0 }]);
+      box.prims.push({
+        kind: "line",
+        x1: 0,
+        x2: base.width,
+        y1: y,
+        y2: y,
+        width: Math.max(0.8, style.size * 0.05)
+      });
+      box.ascent = Math.max(box.ascent, under ? 0 : -y);
+      box.descent = Math.max(box.descent, under ? y : 0);
+      return box;
+    }
+    case "m:limLow":
+      return below(arg2("m:e"), arg2("m:lim", small()), style);
+    case "m:limUpp":
+      return above(arg2("m:e"), arg2("m:lim", small()), style);
+    case "m:groupChr": {
+      const pr = child(node, "m:groupChrPr");
+      const mark = glyph(val(child(pr, "m:chr")) || "\u23DF", style.size);
+      mark.ascent = style.size * 0.2;
+      mark.descent = style.size * 0.1;
+      return val(child(pr, "m:pos")) === "top" ? above(arg2("m:e"), mark, style) : below(arg2("m:e"), mark, style);
+    }
+    case "m:eqArr": {
+      const lines = ensureArray(node["m:e"]).map((line) => ctx.layout(line, style));
+      const result = emptyBox();
+      const gap = style.size * 0.25;
+      const total = lines.reduce((sum, line) => sum + line.ascent + line.descent, 0) + gap * Math.max(0, lines.length - 1);
+      let y = -(total / 2) + style.size * AXIS;
+      for (const line of lines) {
+        y += line.ascent;
+        result.prims.push(...shifted(line.prims, 0, y));
+        result.width = Math.max(result.width, line.width);
+        y += line.descent + gap;
+      }
+      result.ascent = total / 2 + style.size * AXIS;
+      result.descent = total / 2 - style.size * AXIS;
+      return result;
+    }
+    case "m:func": {
+      const name = arg2("m:fName", { ...style, plain: true });
+      return row([name, arg2("m:e")], style.size * 0.17);
+    }
+    case "m:borderBox": {
+      const inner = arg2("m:e");
+      const pad = style.size * 0.15;
+      const box = placed(inner, pad, 0);
+      box.width = inner.width + pad * 2;
+      box.ascent += pad;
+      box.descent += pad;
+      box.prims.push({
+        kind: "rect",
+        x: 0,
+        y: -box.ascent,
+        w: box.width,
+        h: box.ascent + box.descent,
+        width: 0.8
+      });
+      return box;
+    }
+    case "m:box":
+    case "m:phant":
+      return arg2("m:e");
+    default:
+      return ctx.layout(node, style);
+  }
+}
+
+// math/omml-box-layout.ts
+var isOn3 = (value) => value === "1" || value === "on" || value === "true";
+var isUnaryContext = (ch) => isRelation(ch) || isBinary(ch) || /[([{,;:]/.test(ch);
+function lastCharOf(node) {
+  const text = readText(node);
+  return text ? Array.from(text).at(-1) ?? "" : "";
+}
+function layoutRun(node, style, atStart) {
+  const text = readText(node);
+  if (!text) return emptyBox();
+  const rPr = child(node, "m:rPr");
+  const sty = val(child(rPr, "m:sty"));
+  const plain = style.plain || isOn3(val(child(rPr, "m:nor"))) || sty === "p" || sty === "b";
+  const bold = Boolean(style.bold) || sty === "b" || sty === "bi";
+  const boxes = [];
+  let index = 0;
+  let previous = atStart ? "(" : "x";
+  for (const raw of Array.from(text)) {
+    const ch = raw === "-" ? "\u2212" : raw;
+    const italic = !plain && /[A-Za-zα-ω]/.test(ch);
+    const unary = index === 0 ? atStart : isUnaryContext(previous);
+    const spaced = style.level > 0 ? 0 : isRelation(ch) ? 0.28 : isBinary(ch) && !unary ? 0.22 : 0;
+    previous = ch;
+    const width = glyphEm(ch, bold) * style.size;
+    const pad = spaced * style.size;
+    const box = emptyBox();
+    box.width = width + pad * 2;
+    box.ascent = style.size * 0.78;
+    box.descent = style.size * 0.22;
+    if (ch !== " " || width)
+      box.prims.push({
+        kind: "text",
+        x: pad,
+        y: 0,
+        text: ch,
+        size: style.size,
+        italic,
+        bold,
+        fit: width
+      });
+    boxes.push(box);
+    index++;
+  }
+  return mergeText(row(boxes));
+}
+function mergeText(box) {
+  const merged = [];
+  for (const prim of box.prims) {
+    const last = merged.at(-1);
+    if (prim.kind === "text" && last?.kind === "text" && last.italic === prim.italic && last.bold === prim.bold && last.size === prim.size && last.y === prim.y && Math.abs(last.x + last.fit - prim.x) < 0.01)
+      merged[merged.length - 1] = {
+        ...last,
+        text: last.text + prim.text,
+        fit: last.fit + prim.fit
+      };
+    else merged.push(prim);
+  }
+  return { ...box, prims: merged };
+}
+function layoutChildren(node, style) {
+  const boxes = [];
+  let last = "";
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_") || key === "#text") continue;
+    const tag = stripXmlOrderSuffix(key);
+    for (const item of ensureArray(node[key])) {
+      const atStart = boxes.length === 0 || last !== "" && isUnaryContext(last);
+      boxes.push(layoutElement(tag, item, style, atStart));
+      last = tag === "m:r" ? lastCharOf(item) : "";
+    }
+  }
+  return row(boxes);
+}
+function layoutElement(tag, node, style, atStart) {
+  if (tag === "m:r") return layoutRun(node, style, atStart);
+  if (tag === "m:oMath" || tag === "m:oMathPara") return layoutChildren(node, style);
+  if (/Pr$/.test(tag) || tag === "m:ctrlPr") return emptyBox();
+  return layoutStructure(tag, node, style, { layout: layoutChildren, script: scriptStyle });
+}
+function layoutEquation(root, sizePx) {
+  const box = layoutChildren(root, { level: 0, size: sizePx });
+  const pad = 1;
+  const ascent = Math.max(box.ascent, sizePx * 0.78) + pad;
+  const descent = Math.max(box.descent, sizePx * 0.22) + pad;
+  return {
+    box: { ...box, prims: shifted(box.prims, pad, 0), ascent, descent },
+    widthPx: round(Math.max(box.width, sizePx * 0.5) + pad * 2),
+    heightPx: round(ascent + descent),
+    descentPx: round(descent)
+  };
+}
+var DEFAULT_XML_LIMITS = {
+  maxDepth: 512,
+  maxNodes: 5e6
+};
+var MARKUP_RE = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<(\/?)([^\s\/>]+)(?:\s+[^\s=\/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*\s*(\/?)>/g;
+function checkXmlLimits(xml, label, limits = {}) {
+  const maxDepth = limits.maxDepth ?? DEFAULT_XML_LIMITS.maxDepth;
+  const maxNodes = limits.maxNodes ?? DEFAULT_XML_LIMITS.maxNodes;
+  let depth = 0;
+  let nodes = 0;
+  for (const match of xml.matchAll(MARKUP_RE)) {
+    const [, closing, name, selfClosing] = match;
+    if (name === void 0) continue;
+    if (closing) {
+      depth--;
+      continue;
+    }
+    nodes++;
+    if (nodes > maxNodes) throw new Error(`${label} XML exceeds the limit of ${maxNodes} elements`);
+    if (!selfClosing && ++depth > maxDepth)
+      throw new Error(`${label} XML exceeds the nesting depth limit of ${maxDepth}`);
+  }
+}
+function parseXml(xml, options = {}) {
+  const label = options.label ?? "OOXML";
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml))
+    throw new Error(`${label} XML with DTD or entity declarations is not supported`);
+  checkXmlLimits(xml, label, options.limits);
+  let parseError = "";
+  let parsed;
+  try {
+    parsed = new xmldom.DOMParser({
+      onError: (level, message) => {
+        if (level !== "warning") parseError = message;
+      }
+    }).parseFromString(xml, "application/xml");
+  } catch (error) {
+    throw new Error(
+      `Invalid ${label} XML: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  if (parseError || !parsed.documentElement)
+    throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
+  return parsed;
+}
+var isElement = (node) => node.nodeType === 1;
+var elements = (parent) => Array.from(parent.childNodes).filter(isElement);
+
+// 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"
+};
+var MAX_DEPTH = 512;
+function ommlFromElement(element2) {
+  const visit = (node, depth) => {
+    if (depth > MAX_DEPTH) throw new Error(`OMML nesting exceeds ${MAX_DEPTH} levels`);
+    const prefix = PREFIXES[node.namespaceURI ?? ""];
+    const name = prefix ? `${prefix}:${node.localName}` : node.tagName;
+    const body = mergeSiblings(elements(node).map((child2) => visit(child2, depth + 1)));
+    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(element2, 1);
+}
+function parseOmml(xml) {
+  return ommlFromElement(parseXml(xml, { label: "OMML" }).documentElement);
+}
+
+// math/omml-svg.ts
+var FONT_FAMILY = "'Cambria Math','STIX Two Math','Latin Modern Math','Times New Roman',serif";
+function primMarkup(prim) {
+  switch (prim.kind) {
+    case "text": {
+      const attrs = [
+        `font-size="${round(prim.size)}"`,
+        prim.italic ? 'font-style="italic"' : "",
+        prim.bold ? 'font-weight="bold"' : "",
+        Array.from(prim.text).length > 1 ? `textLength="${round(prim.fit)}" lengthAdjust="spacing"` : ""
+      ].filter(Boolean);
+      const at = prim.stretch ? `transform="translate(${round(prim.x)} ${round(prim.y)}) scale(1 ${round(prim.stretch)})"` : `x="${round(prim.x)}" y="${round(prim.y)}"`;
+      return `<text ${at} ${attrs.join(" ")}>${escapeXml(prim.text)}</text>`;
+    }
+    case "line":
+      return `<line x1="${round(prim.x1)}" y1="${round(prim.y1)}" x2="${round(prim.x2)}" y2="${round(prim.y2)}" stroke="currentColor" stroke-width="${round(prim.width)}"/>`;
+    case "rect":
+      return `<rect x="${round(prim.x)}" y="${round(prim.y)}" width="${round(prim.w)}" height="${round(prim.h)}" fill="none" stroke="currentColor" stroke-width="${round(prim.width)}"/>`;
+    default:
+      return `<path d="${prim.d}" fill="none" stroke="currentColor" stroke-width="${round(prim.width)}" stroke-linejoin="round"/>`;
+  }
+}
+function drawOmmlTree(root, sizePx, label = "") {
+  const { box, widthPx, heightPx, descentPx } = layoutEquation(root, sizePx);
+  if (!box.prims.length) return void 0;
+  const body = box.prims.map(primMarkup).join("");
+  const aria = label ? ` aria-label="${escapeXml(label).replace(/"/g, "&quot;")}"` : "";
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${widthPx}" height="${heightPx}" viewBox="0 0 ${widthPx} ${heightPx}" role="img"${aria}><g font-family="${FONT_FAMILY}" fill="currentColor" transform="translate(0 ${round(box.ascent)})">${body}</g></svg>`;
+  return { svg, widthPx, heightPx, descentPx };
+}
+function drawEquation(omml, sizePx, label = "") {
+  try {
+    return drawOmmlTree(parseOmml(omml), sizePx, label);
+  } catch {
+    return void 0;
+  }
+}
+
+// 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;
+}
+
 // math/omml-mathml-converters.ts
 function convertRun(node) {
   const text = readText(node);
   if (text.length === 0) {
     return "";
   }
-  const escaped = escapeXml(text);
+  const escaped = escapeXml(text === "-" ? "\u2212" : text);
   const rPr = child(node, "m:rPr");
   const norVal = val(child(rPr, "m:nor"));
   const isNormal = norVal === "1" || norVal === "on" || norVal === "true";
@@ -1758,8 +2424,8 @@ function convertDelimiter(node, cc) {
 function convertMatrix(node, cc) {
   const rows = ensureArray(node["m:mr"]);
   const tableRows = [];
-  for (const row of rows) {
-    const cells = ensureArray(row["m:e"]);
+  for (const row2 of rows) {
+    const cells = ensureArray(row2["m:e"]);
     const tdParts = [];
     for (const cell of cells) {
       tdParts.push(`<mtd><mrow>${cc(cell)}</mrow></mtd>`);
@@ -1934,67 +2600,35 @@ function ommlToMathml(omml) {
   }
   return convertOmmlToMathMl(omml);
 }
-function parseXml(xml, options = {}) {
-  const label = options.label ?? "OOXML";
-  if (/<!DOCTYPE|<!ENTITY/i.test(xml))
-    throw new Error(`${label} XML with DTD or entity declarations is not supported`);
-  let parseError = "";
-  let parsed;
-  try {
-    parsed = new xmldom.DOMParser({
-      onError: (level, message) => {
-        if (level !== "warning") parseError = message;
-      }
-    }).parseFromString(xml, "application/xml");
-  } catch (error) {
-    throw new Error(
-      `Invalid ${label} XML: ${error instanceof Error ? error.message : String(error)}`,
-      { cause: error }
-    );
-  }
-  if (parseError || !parsed.documentElement)
-    throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
-  return parsed;
-}
-var isElement = (node) => node.nodeType === 1;
-var elements = (parent) => Array.from(parent.childNodes).filter(isElement);
 
-// 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);
-}
+// math/equation-gallery.ts
+var EQUATION_GALLERY = [
+  { id: "area", name: "Area of Circle", latex: "A = \\pi r^{2}" },
+  {
+    id: "quadratic",
+    name: "Quadratic Formula",
+    latex: "x = \\frac{-b \\pm \\sqrt{b^{2} - 4ac}}{2a}"
+  },
+  { id: "pythagorean", name: "Pythagorean Theorem", latex: "a^{2} + b^{2} = c^{2}" },
+  {
+    id: "binomial",
+    name: "Binomial Theorem",
+    latex: "(x + a)^{n} = \\sum_{k=0}^{n} \\binom{n}{k} x^{k} a^{n-k}"
+  }
+];
 
 exports.ACCENT_ALIASES = ACCENT_ALIASES;
 exports.ACCENT_MAP = ACCENT_MAP;
 exports.DELIM_MAP = DELIM_MAP;
 exports.EQARR_ENVS = EQARR_ENVS;
+exports.EQUATION_GALLERY = EQUATION_GALLERY;
 exports.ESCAPE_MAP = ESCAPE_MAP;
 exports.FUNC_NAMES = FUNC_NAMES;
 exports.GREEK_MAP = GREEK_MAP;
 exports.LIMIT_FUNC_NAMES = LIMIT_FUNC_NAMES;
 exports.MATRIX_ENVS = MATRIX_ENVS;
 exports.NARY_MAP = NARY_MAP;
+exports.OMML_NAMESPACE = OMML_NAMESPACE;
 exports.OPERATOR_MAP = OPERATOR_MAP;
 exports.REVERSE_ACCENT = REVERSE_ACCENT;
 exports.REVERSE_DELIM = REVERSE_DELIM;
@@ -2012,6 +2646,8 @@ exports.convertLatexToOmml = convertLatexToOmml;
 exports.convertOmmlToLatex = convertOmmlToLatex;
 exports.convertOmmlToMathMl = convertOmmlToMathMl;
 exports.delimiterToLatex = delimiterToLatex;
+exports.drawEquation = drawEquation;
+exports.drawOmmlTree = drawOmmlTree;
 exports.ensureArr = ensureArr;
 exports.eqArrToLatex = eqArrToLatex;
 exports.escapeChar = escapeChar;
@@ -2022,11 +2658,13 @@ exports.getOmmlMathFontSize = getOmmlMathFontSize;
 exports.hasAttr = hasAttr;
 exports.isOn = isOn;
 exports.isSingleAtom = isSingleAtom;
+exports.latexToOmmlXml = latexToOmmlXml;
 exports.matrixToLatex = matrixToLatex;
 exports.mergeSiblings = mergeSiblings;
 exports.naryToLatex = naryToLatex;
 exports.ommlFromElement = ommlFromElement;
 exports.ommlToMathml = ommlToMathml;
+exports.ommlToXml = ommlToXml;
 exports.parseAccent = parseAccent;
 exports.parseBar = parseBar;
 exports.parseBoxed = parseBoxed;