ed-mathml2tex 0.2.2 → 0.2.4

package/lib/mathml2latex.browser.es.js

@@ -1,6 +1,6 @@
 const Brackets = {
-  left: ['(', '[', '{', '|', '‖', '⟨', '⌊', '⌈', '⌜'],
-  right: [')', ']', '}', '|', '‖', '⟩', '⌋', '⌉', '⌝'],
+  left: ['(', '[', '{', '|', '\u2016', '\u27E8', '\u230A', '\u2308', '\u231C'],
+  right: [')', ']', '}', '|', '\u2016', '\u27E9', '\u230B', '\u2309', '\u231D'],
   isPair: function(l, r){
     const idx = this.left.indexOf(l);
     return r === this.right[idx];
@@ -22,17 +22,17 @@ const Brackets = {
       case '[':
       case '|': r = `\\left${it}`;
         break;
-      case '‖': r = '\\left\\|';
+      case '\u2016': r = '\\left\\|';
         break;
       case '{': r = '\\left\\{';
         break;
-      case '⟨': r = '\\left\\langle ';
+      case '\u27E8': r = '\\left\\langle ';
         break;
-      case '⌊': r = '\\left\\lfloor ';
+      case '\u230A': r = '\\left\\lfloor ';
         break;
-      case '⌈': r = '\\left\\lceil ';
+      case '\u2308': r = '\\left\\lceil ';
         break;
-      case '⌜': r = '\\left\\ulcorner ';
+      case '\u231C': r = '\\left\\ulcorner ';
         break;
     }
     return (stretchy ? r : r.replace('\\left', ''));
@@ -46,23 +46,36 @@ const Brackets = {
       case ']':
       case '|': r = `\\right${it}`;
         break;
-      case '‖': r = '\\right\\|';
+      case '\u2016': r = '\\right\\|';
         break;
       case '}': r = '\\right\\}';
         break;
-      case '⟩': r = ' \\right\\rangle';
+      case '\u27E9': r = ' \\right\\rangle';
         break;
-      case '⌋': r = ' \\right\\rfloor';
+      case '\u230B': r = ' \\right\\rfloor';
         break;
-      case '⌉': r = ' \\right\\rceil';
+      case '\u2309': r = ' \\right\\rceil';
         break;
-      case '⌝': r = ' \\right\\urcorner';
+      case '\u231D': r = ' \\right\\urcorner';
         break;
     }
     return (stretchy ? r : r.replace('\\right', ''));
   }
 };
 
+var _nodeResolve_empty = {};
+
+var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': _nodeResolve_empty
+});
+
+function getCjsExportFromNamespace (n) {
+	return n && n['default'] || n;
+}
+
+var require$$0 = getCjsExportFromNamespace(_nodeResolve_empty$1);
+
 /*
  * Set up window for Node.js
  */
@@ -92,11 +105,17 @@ function canParseHTMLNatively () {
 function createHTMLParser () {
   const Parser = function () {};
 
-  if (typeof process !== 'undefined' && true) {
-    if (shouldUseActiveX()) {
+  const hasDocument =
+    typeof document !== 'undefined' &&
+    document &&
+    document.implementation &&
+    typeof document.implementation.createHTMLDocument === 'function';
+
+  if (hasDocument) {
+    if (typeof process !== 'undefined' && true && shouldUseActiveX()) {
       Parser.prototype.parseFromString = function (string) {
         const doc = new window.ActiveXObject('htmlfile');
-        doc.designMode = 'on'; // disable on-page scripts
+        doc.designMode = 'on';
         doc.open();
         doc.write(string);
         doc.close();
@@ -113,11 +132,9 @@ function createHTMLParser () {
     }
   } else {
     Parser.prototype.parseFromString = function (string) {
-      const doc = document.implementation.createHTMLDocument('');
-      doc.open();
-      doc.write(string);
-      doc.close();
-      return doc
+      const domino = require$$0;
+      const window = domino.createWindow(string || '');
+      return window.document
     };
   }
   return Parser
@@ -135,11 +152,54 @@ function shouldUseActiveX () {
 
 const HTMLParser = canParseHTMLNatively() ? root.DOMParser : createHTMLParser();
 
+function normalizeMathMLInput(input) {
+  let s = input == null ? '' : String(input);
+
+  if (s.includes('<math') && /\\[ntr"]/.test(s)) {
+    s = s
+      .replace(/\\r\\n/g, '\n')
+      .replace(/\\n/g, '\n')
+      .replace(/\\t/g, '\t')
+      .replace(/\\"/g, '"')
+      .replace(/\\'/g, "'");
+  }
+
+  s = s.replace(/^\s*<\?xml[\s\S]*?\?>\s*/i, '');
+
+  s = s.replace(
+    /xmlns\s*=\s*(["'])\s*`?\s*(https?:\/\/www\.w3\.org\/1998\/Math\/MathML)\s*`?\s*\1/gi,
+    'xmlns="$2"'
+  );
+
+  s = s.replace(/xmlns\s*=\s*(["'])\s*`?\s*http:\/\/www\.w3\.org\/1998\/Math\/MathML\\`?\s*\1/gi, 'xmlns="http://www.w3.org/1998/Math/MathML"');
+
+  if (!/<math\b/i.test(s) && /<(msub|mrow|mi|mn|mo|mfrac|msup|msubsup|munder|mover|munderover|mtable)\b/i.test(s)) {
+    s = `<math xmlns="http://www.w3.org/1998/Math/MathML">${s}</math>`;
+  }
+
+  return s;
+}
+
 const NodeTool = {
   parseMath: function(html) {
+    const normalized = normalizeMathMLInput(html);
     const parser = new HTMLParser();
-    const doc = parser.parseFromString(html, 'text/html');
-    return doc.querySelector('math');
+    const doc = parser.parseFromString(normalized, 'text/html');
+    let math = doc && doc.querySelector ? doc.querySelector('math') : null;
+
+    if (!math) {
+      const match = normalized.match(/<math\b[\s\S]*?<\/math>/i);
+      if (match) {
+        const retryDoc = parser.parseFromString(match[0], 'text/html');
+        math = retryDoc && retryDoc.querySelector ? retryDoc.querySelector('math') : null;
+      }
+    }
+
+    if (!math) {
+      throw new Error('Invalid MathML: missing <math> root element');
+    }
+
+    return math;
   },
   getChildren: function(node) {
     return node.children;
@@ -275,24 +335,24 @@ const MathSymbol = {
   bigCommand: {
     decimals: [8721, 8719, 8720, 10753, 10754, 10752, 8899, 8898, 10756, 10758, 8897, 8896, 8747, 8750, 8748, 8749, 10764, 8747],
     scripts: [
-      "\\sum",
-      "\\prod",
-      "\\coprod",
-      "\\bigoplus",
-      "\\bigotimes",
-      "\\bigodot",
-      "\\bigcup",
-      "\\bigcap",
-      "\\biguplus",
-      "\\bigsqcup",
-      "\\bigvee",
-      "\\bigwedge",
-      "\\int",
-      "\\oint",
-      "\\iint",
-      "\\iiint",
-      "\\iiiint",
-      "\\idotsint",
+      "\\sum ",
+      "\\prod ",
+      "\\coprod ",
+      "\\bigoplus ",
+      "\\bigotimes ",
+      "\\bigodot ",
+      "\\bigcup ",
+      "\\bigcap ",
+      "\\biguplus ",
+      "\\bigsqcup ",
+      "\\bigvee ",
+      "\\bigwedge ",
+      "\\int ",
+      "\\oint ",
+      "\\iint ",
+      "\\iiint ",
+      "\\iiiint ",
+      "\\idotsint ",
     ]
   },
 
@@ -610,9 +670,10 @@ function convert(mathmlHtml) {
   // Thêm xử lý cho các thẻ MathML khác
   result = result
     .replace(/∞/g, "\\infty") // Vô cực
-    .replace(/∑/g, "\\sum") // Tổng
-    .replace(/∏/g, "\\prod") // Tích
-    .replace(/∫/g, "\\int"); // Tích phân
+    .replace(/∫/g, " \\int "); // Tích phân
+
+  // Đảm bảo dấu cách sau các lệnh LaTeX quan trọng để tránh dính biến (vd: \intf -> \int f)
+  result = result.replace(/\\(int|sum|prod|cos|sin|tan|cot|lim(?!its)|log|ln)([a-zA-Z0-9])/g, "\\$1 $2");
 
   return result;
 }
@@ -758,20 +819,24 @@ function parseOperator(node) {
     "±": " \\pm ",
     "×": " \\times ",
     "÷": " \\div ",
-    "∑": " \\sum ",
-    "∏": " \\prod ",
-    "∫": "\\int",
+    "∑": "\\sum ",
+    "∏": "\\prod ",
+    "∫": "\\int ",
     "−": "-",
     "≠": " \\neq ",
     ">": " > ",
     "=": " = ",
+    "(": "(",
+    ")": ")",
     ",": ", ", // Dấu phẩy trong tập hợp
     ";": ";",
     Ω: "\\Omega",
     "|": " \\mid ", // PATCH: set-builder mid
     π: " \\pi ", // PATCH: Greek letter
+    "...": "\\dots",
   };
-  return operatorMap[it] || escapeSpecialChars(MathSymbol.parseOperator(it));
+  const res = operatorMap[it] || escapeSpecialChars(MathSymbol.parseOperator(it));
+  return res;
 }
 // --- END PATCH ---
 
@@ -798,6 +863,20 @@ function parseElementMi(node) {
 // Math Number
 function parseElementMn(node) {
   let it = NodeTool.getNodeText(node).trim();
+  // Loại bỏ các ký tự điều khiển hoặc khoảng trắng lạ
+  it = it.replace(/[\u0000-\u001F\u007F-\u009F\u00A0]/g, "");
+  
+  // Danh sách các hàm toán học mở rộng
+  const mathFunctions = ["cos", "sin", "tan", "cot", "arccos", "arcsin", "arctan", "arccot", "log", "ln", "lim", "sinh", "cosh", "tanh", "sec", "csc"];
+  
+  if (mathFunctions.some(fn => it.toLowerCase().includes(fn))) {
+    // Tìm hàm khớp chính xác nhất
+    for (const fn of mathFunctions) {
+      if (it.toLowerCase() === fn) {
+        return "\\" + fn + " ";
+      }
+    }
+  }
   return escapeSpecialChars(it);
 }
 
@@ -831,8 +910,8 @@ function parseElementMtext(node) {
   // Nếu đã là lệnh LaTeX thì giữ nguyên
   if (content.startsWith("\\")) return content;
 
-  // Bọc token chữ/số liền nhau bằng \text{...} (hóa học: Cu, OH, NaOH, ...)
-  if (/^[A-Za-z][A-Za-z0-9]*$/.test(content)) {
+  // Bọc token chữ/số liền nhau bằng \text{...} (hóa học: Cu, OH, NaOH, ..., k times)
+  if (/^[A-Za-z][A-Za-z0-9\s]*$/.test(content)) {
     return `\\text{${content}}`;
   }
 
@@ -887,6 +966,22 @@ function escapeSpecialChars(text) {
   return text;
 }
 
+function wrapBaseForScript(base) {
+  const t = (base ?? "").trim();
+  if (!t) return "";
+  if (t.startsWith("{") && t.endsWith("}")) return t;
+  if (/^\\[a-zA-Z]+$/.test(t)) return t;
+  const needsWrap =
+    t.includes("_") ||
+    t.includes("^") ||
+    /\s/.test(t) ||
+    t.startsWith("\\left") ||
+    t.startsWith("\\right") ||
+    /\\[a-zA-Z]+/.test(t) ||
+    /[{}]/.test(t);
+  return needsWrap ? `{${t}}` : t;
+}
+
 function parseContainer(node, children) {
   const render = getRender(node);
   if (render) {
@@ -905,22 +1000,6 @@ function renderChildren(children) {
   // lefts là mảng object: { op: "(", index: 5 }
   let lefts = [];
 
-  if (
-    children.length >= 3 &&
-    NodeTool.getNodeName(children[0]) === "mo" &&
-    NodeTool.getNodeText(children[0]).trim() === "{" &&
-    NodeTool.getNodeName(children[children.length - 1]) === "mo" &&
-    NodeTool.getNodeText(children[children.length - 1]).trim() === "}"
-  ) {
-    // Render inner content
-    const innerContent = Array.prototype.slice
-      .call(children, 1, -1)
-      .map((child) => parse(child))
-      .join(""); // Chỉ trả về nếu nội dung không rỗng
-    const result = `\\left\\{${innerContent}\\right\\}`;
-    return result;
-  }
-
   Array.prototype.forEach.call(children, (node, idx) => {
     // PATCH: Thin space between variables/numbers in mfrac numerator (k 2 π)
     if (
@@ -948,55 +1027,59 @@ function renderChildren(children) {
       if (Brackets.contains(op)) {
         let stretchy = NodeTool.getAttr(node, "stretchy", "true");
         stretchy = ["", "true"].indexOf(stretchy) > -1;
-
-        let escapedOp = op;
-        if (op === "{" || op === "}") {
-          escapedOp = `\\${op}`;
+        const parentNode = node.parentNode;
+        const isInPower = parentNode && NodeTool.getNodeName(parentNode) === "msup";
+        if (isInPower) {
+          stretchy = false;
         }
 
         if (Brackets.isRight(op)) {
           const nearLeftObj = lefts[lefts.length - 1];
-          if (nearLeftObj) {
-            const parentNode = node.parentNode;
-            const isInPower =
-              parentNode && NodeTool.getNodeName(parentNode) === "msup";
-
-            let partToPush = "";
-            if (stretchy && !isInPower) {
-              partToPush = `\\right${escapedOp}`;
-            } else {
-              partToPush = escapedOp;
-            }
-            if (partToPush) {
-              // CHỈ PUSH NẾU KHÔNG RỖNG
-              parts.push(partToPush);
+          if (nearLeftObj && Brackets.isPair(nearLeftObj.op, op)) {
+            const leftIdx = nearLeftObj.index;
+            const leftRendered =
+              typeof leftIdx === "number" ? String(parts[leftIdx] ?? "") : "";
+            let rightRendered = Brackets.parseRight(op, stretchy);
+
+            const leftRenderedTrimmed = leftRendered.trim();
+            const rightRenderedTrimmed = String(rightRendered).trim();
+
+            if (
+              leftRenderedTrimmed.startsWith("\\left") &&
+              !rightRenderedTrimmed.startsWith("\\right")
+            ) {
+              parts[leftIdx] = leftRendered.replace("\\left", "");
+            } else if (
+              !leftRenderedTrimmed.startsWith("\\left") &&
+              rightRenderedTrimmed.startsWith("\\right")
+            ) {
+              rightRendered = String(rightRendered).replace("\\right", "");
             }
-            // matched a left: remove corresponding left object
+
+            if (rightRendered) parts.push(rightRendered);
             lefts.pop();
+          } else if (Brackets.isLeft(op)) {
+            // If it's a Right bracket but doesn't match the current Left,
+            // AND it is also a Left bracket (e.g. '|'), treat it as a new Left.
+            const partToPush = Brackets.parseLeft(op, stretchy);
+            if (partToPush) parts.push(partToPush);
+            lefts.push({ op: op, index: parts.length - 1 });
           } else {
-            if (escapedOp) {
-              // CHỈ PUSH NẾu KHÔNG RỖNG
-              parts.push(escapedOp);
-            }
+            // Unmatched right bracket
+            let rightRendered = Brackets.parseRight(op, stretchy);
+            rightRendered = String(rightRendered).replace("\\right", "");
+            if (rightRendered) parts.push(rightRendered);
           }
         } else {
-          // Là ngoặc trái
-          const parentNode = node.parentNode;
-          const isInPower =
-            parentNode && NodeTool.getNodeName(parentNode) === "msup";
-
-          let partToPush = "";
-          if (stretchy && !isInPower) {
-            partToPush = `\\left${escapedOp}`;
+          // Must be Left bracket (or only Left)
+          if (Brackets.isLeft(op)) {
+            const partToPush = Brackets.parseLeft(op, stretchy);
+            if (partToPush) parts.push(partToPush);
+            lefts.push({ op: op, index: parts.length - 1 });
           } else {
-            partToPush = escapedOp;
+            // Should not happen if Brackets.contains is correct
+            if (op) parts.push(op);
           }
-          if (partToPush) {
-            // CHỈ PUSH NẾU KHÔNG RỖNG
-            parts.push(partToPush);
-          }
-          // Lưu vị trí token left vừa push để có thể xử lý nếu không có right
-          lefts.push({ op: op, index: parts.length - 1 });
         }
       } else {
         const parsedOperator = parseOperator(node);
@@ -1005,45 +1088,6 @@ function renderChildren(children) {
           parts.push(parsedOperator);
         }
       }
-
-      // --- START PATCH V6 (Giữ nguyên logic V5) ---
-    } else if (NodeTool.getNodeName(node) === "msub") {
-      const subChildren = Array.from(NodeTool.getChildren(node));
-      if (
-        subChildren.length === 2 &&
-        NodeTool.getNodeName(subChildren[0]) === "mo" &&
-        NodeTool.getNodeText(subChildren[0]).trim() === ")"
-      ) {
-        // ĐÚNG LÀ NGOẠI LỆ
-
-        const sub = parse(subChildren[1]);
-        // Mảng 'parts' lúc này "sạch" và là: ["\text{Cu}", "\left(", "\text{OH}"]
-        const lastPart = parts.pop(); // lastPart = "\text{OH}"
-        // Mảng 'parts' lúc này là: ["\text{Cu}", "\left("]
-        for (let i = parts.length - 1; i >= 0; i--) {
-          if (parts[i] && parts[i].trim() === "\\left(") {
-            parts.splice(i, 1); // Xóa "\left("
-            break;
-          }
-          _;
-        } // Mảng 'parts' lúc này là: ["\text{Cu}"]
-
-        parts.push(`${lastPart}_{${sub}}`); // Push "\text{OH}_{2}"
-        // Mảng 'parts' lúc này là: ["\text{Cu}", "\text{OH}_{2}"]
-
-        const nearLeftObj = lefts[lefts.length - 1];
-        if (nearLeftObj) {
-          lefts.pop();
-        }
-      } else {
-        // <msub> bình thường
-        const parsed = parse(node);
-        if (parsed) {
-          // CHỈ PUSH NẾU KHÔNG RỖNG
-          parts.push(parsed);
-        }
-      }
-      // --- END PATCH V6 ---
     } else {
       // Các node khác như <mtext>, #text, v.v.
       const parsed = parse(node);
@@ -1055,40 +1099,13 @@ function renderChildren(children) {
   });
 
   // Nếu còn lefts (ngoặc trái) chưa được đóng, chỉ chuyển '\leftX' thành 'X'
-  // khi không có đóng tương ứng phía sau — nếu có \right (hoặc dấu đóng) thì giữ \left
+  // để tránh sinh LaTeX không hợp lệ (\left mà không có \right)
   if (lefts && lefts.length > 0) {
-    const rightForLeft = (left) => {
-      switch (left) {
-        case "(":
-          return ")";
-        case "[":
-          return "]";
-        case "{":
-          return "}";
-        case "|":
-          return "|";
-        default:
-          return ".";
-      }
-    };
-
     lefts.forEach((leftObj) => {
       const idx = leftObj && leftObj.index;
       if (typeof idx !== "number" || !parts[idx]) return;
-
-      const left = leftObj.op;
-      const right = rightForLeft(left);
-
-      // Kiểm tra phần tử sau vị trí left có chứa \right hoặc ký tự đóng tương ứng hay không
-      const tail = parts.slice(idx + 1).map(String).join(" ");
-      const hasMatchingRight =
-        (/\\right/.test(tail)) || (right !== "." && tail.indexOf(right) !== -1);
-
-      if (!hasMatchingRight) {
-        // Không có đóng tương ứng: bỏ prefix '\left' để chỉ còn ký tự mở bình thường
-        parts[idx] = String(parts[idx]).replace(/^\\left/, "");
-      }
-      // Nếu có đóng tương ứng thì giữ nguyên '\left...' để không sinh \right thừa
+      // Use regex with whitespace support and global flag just in case
+      parts[idx] = String(parts[idx]).replace(/\\left/g, "");
     });
   }
 
@@ -1096,6 +1113,44 @@ function renderChildren(children) {
   return parts;
 }
 
+function isLimitOperator(base) {
+  const t = (base || "").trim();
+  const ops = [
+    "\\sum",
+    "\\prod",
+    "\\coprod",
+    "\\int",
+    "\\oint",
+    "\\bigcap",
+    "\\bigcup",
+    "\\bigsqcup",
+    "\\bigvee",
+    "\\bigwedge",
+    "\\bigodot",
+    "\\bigotimes",
+    "\\bigoplus",
+    "\\biguplus",
+    "\\lim",
+    "\\max",
+    "\\min",
+    "\\sup",
+    "\\inf",
+    "\\det",
+    "\\gcd",
+    "\\Pr",
+    "\\limsup",
+    "\\liminf",
+  ];
+  return ops.some(
+    (op) =>
+      t === op ||
+      t.startsWith(op + " ") ||
+      t.startsWith(op + "\\") ||
+      t.startsWith(op + "^") ||
+      t.startsWith(op + "_")
+  );
+}
+
 function getRender(node) {
   let render = undefined;
   const nodeName = NodeTool.getNodeName(node);
@@ -1244,9 +1299,11 @@ function getRender(node) {
             NodeTool.getNodeText(sub.firstChild).trim() === "")
         ) {
           const lastChild = sub.lastChild;
-          return lastChild ? `${base}_${parse(lastChild)}` : base;
+          return lastChild
+            ? `${wrapBaseForScript(base)}_{${parse(lastChild)}}`
+            : base;
         }
-        return `${base}_{${parse(sub)}}`;
+        return `${wrapBaseForScript(base)}_{${parse(sub)}}`;
       };
       break;
 
@@ -1254,22 +1311,9 @@ function getRender(node) {
       render = function (node, children) {
         const childrenArray = Array.from(children);
         if (!childrenArray || childrenArray.length < 2) return "";
-        // Nếu base là một <mo> và là ngoặc phải, chuyển thành \right<op>
-        const baseNode = childrenArray[0];
-        let base = parse(baseNode) || "";
-        if (NodeTool.getNodeName(baseNode) === "mo") {
-          const op = NodeTool.getNodeText(baseNode).trim();
-          if (Brackets.isRight(op)) {
-            // Escape brace characters
-            if (op === "}" || op === "{") {
-              base = `\\right\\${op}`;
-            } else {
-              base = `\\right${op}`;
-            }
-          }
-        }
+        const base = parse(childrenArray[0]) || "";
         const sup = parse(childrenArray[1]) || "";
-        return `${base}^{${sup}}`;
+        return `${wrapBaseForScript(base)}^{${sup}}`;
       };
       break;
 
@@ -1293,7 +1337,7 @@ function getRender(node) {
             .join("");
           return `\\left.${content}\\right|_{${sub}}^{${sup}}`;
         }
-        return `${base}_{${sub}}^{${sup}}`;
+        return `${wrapBaseForScript(base)}_{${sub}}^{${sup}}`;
       };
       break;
 
@@ -1303,9 +1347,15 @@ function getRender(node) {
         if (!childrenArray || childrenArray.length < 2) return "";
         const base = parse(childrenArray[0]) || "";
         const over = parse(childrenArray[1]) || "";
-        const overText = NodeTool.getNodeText(childrenArray[1])?.trim() || "";
+        const overNode = childrenArray[1];
+        const baseText = NodeTool.getNodeText(childrenArray[0])?.trim() || "";
+        const overText = NodeTool.getNodeText(overNode)?.trim() || "";
         const isAccent = NodeTool.getAttr(node, "accent", "false") === "true";
 
+        // Handle arrows with extensible commands
+        if (baseText === "→" || baseText === "⟶") return `\\xrightarrow{${over}}`;
+        if (baseText === "←" || baseText === "⟵") return `\\xleftarrow{${over}}`;
+
         // Handle biology notation (double overline)
         if (overText === "¯") {
           const parentNode = node.parentNode;
@@ -1321,6 +1371,27 @@ function getRender(node) {
 
         if (overText === "→" && isAccent) return `\\vec{${base}}`;
         if (overText === "^" && isAccent) return `\\hat{${base}}`;
+        if (overText === "\u23DE") return `\\overbrace{${base}}`;
+        
+        // Check for nested overbrace (layer-2)
+        if (NodeTool.getNodeName(overNode) === "mover") {
+           const innerChildren = Array.from(NodeTool.getChildren(overNode));
+           if (innerChildren.length >= 2) {
+              const innerBaseText = NodeTool.getNodeText(innerChildren[0]).trim();
+              if (innerBaseText === "\u23DE") {
+                 const label = parse(innerChildren[1]);
+                 return `\\overbrace{${base}}\\limits^{${label}}`;
+              }
+           }
+        }
+
+        if (base.startsWith("\\overbrace") || base.startsWith("\\underbrace")) {
+          return `${base}\\limits^{${over}}`;
+        }
+
+        if (isLimitOperator(base)) {
+          return `${base}\\limits^{${over}}`;
+        }
         return `\\overset{${over}}{${base}}`;
       };
       break;
@@ -1331,10 +1402,21 @@ function getRender(node) {
         if (!childrenArray || childrenArray.length < 2) return "";
         const base = parse(childrenArray[0]) || "";
         const under = parse(childrenArray[1]) || "";
+        const baseText = NodeTool.getNodeText(childrenArray[0])?.trim() || "";
+        const underText = NodeTool.getNodeText(childrenArray[1])?.trim() || "";
         const isUnderAccent =
           NodeTool.getAttr(node, "accentunder", "false") === "true";
 
+        // Handle arrows with extensible commands
+        if (baseText === "→" || baseText === "⟶") return `\\xrightarrow[${under}]{}`;
+        if (baseText === "←" || baseText === "⟵") return `\\xleftarrow[${under}]{}`;
+
         if (base === "∫") return `\\int_{${under}}`;
+        if (underText === "\u23DF") return `\\underbrace{${base}}`;
+
+        if (isLimitOperator(base)) {
+          return `${base}\\limits_{${under}}`;
+        }
         return `\\underset{${under}}{${base}}`;
       };
       break;
@@ -1348,19 +1430,19 @@ function getRender(node) {
         const over = parse(childrenArray[2]);
         const baseText = NodeTool.getNodeText(childrenArray[0]).trim();
 
-        // Special handling for chemical reaction arrow
-        if (
-          baseText === "→" &&
-          NodeTool.getNodeName(childrenArray[1]) === "msup"
-        ) {
-          return `\\xrightarrow[${under}]{${over}}`;
-        }
+        // Special handling for chemical reaction arrow and other arrows
+        if (baseText === "→" || baseText === "⟶") return `\\xrightarrow[${under}]{${over}}`;
+        if (baseText === "←" || baseText === "⟵") return `\\xleftarrow[${under}]{${over}}`;
 
         if (baseText === "∫") return `\\int_{${under}}^{${over}}`;
         if (baseText === "∑") return `\\sum_{${under}}^{${over}}`;
         if (baseText === "∏") return `\\prod_{${under}}^{${over}}`;
         if (baseText === "|") return `\\big|_{${under}}^{${over}}`;
-        return `${base}_{${under}}^{${over}}`;
+
+        if (isLimitOperator(base)) {
+          return `${base}\\limits_{${under}}^{${over}}`;
+        }
+        return `\\underset{${under}}{\\overset{${over}}{${base}}}`;
       };
       break;
 
@@ -1368,30 +1450,56 @@ function getRender(node) {
       render = function (node, children) {
         const childrenArray = Array.from(children);
         if (!childrenArray || childrenArray.length < 1) return "";
-        const base = parse(childrenArray[0]);
-        let prescripts = "";
-        let postscripts = "";
+        const base = parse(childrenArray[0]) || "";
+
+        const postSub = [];
+        const postSup = [];
+        const preSub = [];
+        const preSup = [];
+
         let i = 1;
+        let inPrescripts = false;
 
         while (i < childrenArray.length) {
-          if (NodeTool.getNodeName(childrenArray[i]) === "mprescripts") {
-            i++;
-            if (i + 1 < childrenArray.length) {
-              prescripts = `_{${parse(childrenArray[i])}}^{${parse(
-                childrenArray[i + 1]
-              )}}`;
-              i += 2;
-            }
+          const name = NodeTool.getNodeName(childrenArray[i]);
+          if (name === "mprescripts") {
+            inPrescripts = true;
+            i += 1;
+            continue;
+          }
+
+          const subNode = childrenArray[i];
+          const supNode = childrenArray[i + 1];
+          if (!subNode || !supNode) break;
+
+          const sub = parse(subNode) || "";
+          const sup = parse(supNode) || "";
+
+          if (inPrescripts) {
+            if (sub) preSub.push(sub);
+            if (sup) preSup.push(sup);
           } else {
-            if (i + 1 < childrenArray.length) {
-              postscripts += `_{${parse(childrenArray[i])}}^{${parse(
-                childrenArray[i + 1]
-              )}}`;
-              i += 2;
-            } else break;
+            if (sub) postSub.push(sub);
+            if (sup) postSup.push(sup);
           }
+
+          i += 2;
         }
-        return `${base}${prescripts}${postscripts}`;
+
+        const preSubStr = preSub.join(" ");
+        const preSupStr = preSup.join(" ");
+        const postSubStr = postSub.join(" ");
+        const postSupStr = postSup.join(" ");
+
+        let pre = "";
+        if (preSubStr) pre += `_{${preSubStr}}`;
+        if (preSupStr) pre += `^{${preSupStr}}`;
+
+        let post = "";
+        if (postSubStr) post += `_{${postSubStr}}`;
+        if (postSupStr) post += `^{${postSupStr}}`;
+
+        return `${pre}${wrapBaseForScript(base)}${post}`;
       };
       break;
 
@@ -1492,7 +1600,28 @@ function getRender(node) {
         const num = parse(childrenArray[0]);
         const den = parse(childrenArray[1]);
         const linethickness = NodeTool.getAttr(node, "linethickness", "medium");
-        if (linethickness === "0") return `\\binom{${num}}{${den}}`;
+        const bevelled = NodeTool.getAttr(node, "bevelled", "false");
+
+        if (bevelled === "true") {
+          return `{}^{${num}}/_{${den}}`;
+        }
+
+        if (["0", "0px"].indexOf(linethickness) > -1) {
+          const prevNode = NodeTool.getPrevNode(node);
+          const nextNode = NodeTool.getNextNode(node);
+          if (
+            prevNode &&
+            NodeTool.getNodeName(prevNode) === "mo" &&
+            NodeTool.getNodeText(prevNode).trim() === "(" &&
+            nextNode &&
+            NodeTool.getNodeName(nextNode) === "mo" &&
+            NodeTool.getNodeText(nextNode).trim() === ")"
+          ) {
+            return `\\DELETE_BRACKET_L\\binom{${num}}{${den}}\\DELETE_BRACKET_R`;
+          }
+          return `{}_{${den}}^{${num}}`;
+        }
+
         return `\\frac{${num}}{${den}}`;
       };
       break;
@@ -1502,7 +1631,10 @@ function getRender(node) {
         const childrenArray = Array.from(children);
         const open = NodeTool.getAttr(node, "open", "(");
         const close = NodeTool.getAttr(node, "close", ")");
-        const separators = NodeTool.getAttr(node, "separators", ",").split("");
+        const separatorsStr = NodeTool.getAttr(node, "separators", ",");
+        const separators = separatorsStr
+          .split("")
+          .filter((c) => c.trim().length === 1);
 
         // Xử lý đặc biệt cho trường hợp dấu ngoặc đơn |
         if (open === "|") {
@@ -1553,9 +1685,10 @@ function getRender(node) {
             parts.push(parse(child));
             if (
               index < childrenArray.length - 1 &&
-              separators[index % separators.length]
+              separators.length > 0
             ) {
-              parts.push(separators[index % separators.length]);
+              const sep = separators[index] ?? separators[separators.length - 1];
+              if (sep) parts.push(sep);
             }
           });
           return `\\left[${parts.join("")}\\right)`;
@@ -1567,18 +1700,20 @@ function getRender(node) {
           parts.push(parse(child));
           if (
             index < childrenArray.length - 1 &&
-            separators[index % separators.length]
+            separators.length > 0
           ) {
-            parts.push(separators[index % separators.length]);
+            const sep = separators[index] ?? separators[separators.length - 1];
+            if (sep) parts.push(sep);
           }
         });
         const content = parts.join("");
 
         if (open === "{" && close === "}") return `\\{${content}\\}`;
         if (open === "|" && close === "|") return `\\left|${content}\\right|`;
-        if (!close) return `\\left${open}${content}\\right.`;
-        if (!open) return `\\left.${content}\\right${close}`;
-        return `\\left${open}${content}\\right${close}`;
+        const left = open ? Brackets.parseLeft(open) : "";
+        const right = close ? Brackets.parseRight(close) : "";
+        if (!close && open) return `${left}${content}\\right.`;
+        return `${left}${content}${right}`;
       };
       break;
 
@@ -1604,10 +1739,17 @@ function getRender(node) {
     case "mn":
     case "mo":
     case "ms":
-    case "mtext":
       render = getRender_joinSeparator("@content");
       break;
 
+    case "mtext":
+      render = function (node, children) {
+        const childrenArray = Array.from(children);
+        const content = renderChildren(childrenArray).join("");
+        return `\\text{${content}}`;
+      };
+      break;
+
     case "mphantom":
       render = function (node, children) {
         const childrenArray = Array.from(children);