ed-mathml2tex 0.2.2 → 0.2.4

package/lib/mathml2latex.browser.umd.js

@@ -5,8 +5,8 @@
 }(this, (function () { 'use strict';
 
   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];
@@ -28,17 +28,17 @@
         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', ''));
@@ -52,23 +52,36 @@
         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
    */
@@ -98,11 +111,17 @@
   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();
@@ -119,11 +138,9 @@
       }
     } 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
@@ -141,11 +158,54 @@
 
   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;
@@ -281,24 +341,24 @@
     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 ",
       ]
     },
 
@@ -616,9 +676,10 @@
     // 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;
   }
@@ -764,20 +825,24 @@
       "±": " \\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 ---
 
@@ -804,6 +869,20 @@
   // 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);
   }
 
@@ -837,8 +916,8 @@
     // 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}}`;
     }
 
@@ -893,6 +972,22 @@
     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) {
@@ -911,22 +1006,6 @@
     // 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 (
@@ -954,55 +1033,59 @@
         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);
@@ -1011,45 +1094,6 @@
             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);
@@ -1061,40 +1105,13 @@
     });
 
     // 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, "");
       });
     }
 
@@ -1102,6 +1119,44 @@
     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);
@@ -1250,9 +1305,11 @@
               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;
 
@@ -1260,22 +1317,9 @@
         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;
 
@@ -1299,7 +1343,7 @@
               .join("");
             return `\\left.${content}\\right|_{${sub}}^{${sup}}`;
           }
-          return `${base}_{${sub}}^{${sup}}`;
+          return `${wrapBaseForScript(base)}_{${sub}}^{${sup}}`;
         };
         break;
 
@@ -1309,9 +1353,15 @@
           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;
@@ -1327,6 +1377,27 @@
 
           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;
@@ -1337,10 +1408,21 @@
           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;
@@ -1354,19 +1436,19 @@
           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;
 
@@ -1374,30 +1456,56 @@
         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;
 
@@ -1498,7 +1606,28 @@
           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;
@@ -1508,7 +1637,10 @@
           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 === "|") {
@@ -1559,9 +1691,10 @@
               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)`;
@@ -1573,18 +1706,20 @@
             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;
 
@@ -1610,10 +1745,17 @@
       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);