ed-mathml2tex 0.1.0 → 0.1.1

package/lib/mathml2latex.browser.umd.js

@@ -588,74 +588,75 @@
     }
   };
 
-  function getRender_default(template) {
-    return function(node, children) {
-      const parts = renderChildren(children);
-      return renderTemplate(template, parts);
-    };
-  }
-
   function getRender_joinSeparator(template, separator = '') {
-    return function(node, children) {
+    return function (node, children) {
       const parts = renderChildren(children);
       return template.replace('@content', parts.join(separator));
     };
   }
 
-  function convert(mathmlHtml){
+  function convert(mathmlHtml) {
     const math = NodeTool.parseMath(mathmlHtml);
     let result = toLatex(parse(math));
-    
-    // Last-chance post-processing for specific patterns
-    if (mathmlHtml.includes("<munder>") && 
-        mathmlHtml.includes("<mo>→</mo>") && 
-        mathmlHtml.includes("<mrow/>")) {
+
+    // Xử lý sau cuối cho các mẫu đặc biệt
+    result = result.replace(/\\right\.\./g, "\\right."); // Loại bỏ dấu chấm trùng lặp
+    result = result.replace(/\.\s*\./g, "."); // Loại bỏ dấu chấm trùng lặp
+
+    if (mathmlHtml.includes("<munder>") &&
+      mathmlHtml.includes("<mo>→</mo>") &&
+      mathmlHtml.includes("<mrow/>")) {
       if (result.includes("\\limits")) {
         result = "\\underset{}{\\rightarrow}";
       }
     }
-    
+
+    // 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
+
     return result;
   }
 
   function toLatex(result) {
-    // binomial coefficients
+    // Xử lý binomial coefficients
     result = result.replace(/\\left\(\\DELETE_BRACKET_L/g, '');
     result = result.replace(/\\DELETE_BRACKET_R\\right\)/g, '');
     result = result.replace(/\\DELETE_BRACKET_L/g, '');
     result = result.replace(/\\DELETE_BRACKET_R/g, '');
-    
-    // Fix all cases of arrows with limits
-    // Case 1: munder - arrow with empty subscript
+
+    // Xử lý các trường hợp mũi tên với giới hạn
     result = result.replace(/→\\limits_{}/g, "\\underset{}{\\rightarrow}");
     result = result.replace(/→\\limits_{(\s*)}/g, "\\underset{}{\\rightarrow}");
     result = result.replace(/\\rightarrow\\limits_{}/g, "\\underset{}{\\rightarrow}");
     result = result.replace(/\\rightarrow\\limits_{(\s*)}/g, "\\underset{}{\\rightarrow}");
-    
-    // Case 2: munder - arrow with non-empty subscript
+
     result = result.replace(/→\\limits_\{([^}]*)\}/g, "\\underset{$1}{\\rightarrow}");
     result = result.replace(/\\rightarrow\\limits_\{([^}]*)\}/g, "\\underset{$1}{\\rightarrow}");
-    
-    // Case 3: munderover - arrow with both subscript and superscript
+
     result = result.replace(/→\\limits_\{([^}]*)\}\^\{([^}]*)\}/g, "\\overset{$2}{\\underset{$1}{\\rightarrow}}");
     result = result.replace(/\\rightarrow\\limits_\{([^}]*)\}\^\{([^}]*)\}/g, "\\overset{$2}{\\underset{$1}{\\rightarrow}}");
-    
-    // Case 4: mover - fix expressions with arrow superscript
-    // Simple expression with arrow superscript: expr^{\rightarrow} → \overrightarrow{expr}
+
+    // Xử lý vector và các ký hiệu đặc biệt
     result = result.replace(/([^{}\s]+)\^\{\\rightarrow\}/g, "\\overrightarrow{$1}");
     result = result.replace(/\{([^{}]+)\}\^\{\\rightarrow\}/g, "\\overrightarrow{$1}");
-    
-    // Complex expressions with subscripts and arrow: expr_{sub}^{\rightarrow} → \overrightarrow{expr_{sub}}
     result = result.replace(/([A-Za-z0-9]+)_\{([^{}]+)\}\^\{\\rightarrow\}/g, "\\overrightarrow{$1_{$2}}");
     result = result.replace(/([A-Za-z0-9]+)_([0-9])\^\{\\rightarrow\}/g, "\\overrightarrow{$1_$2}");
-    
-    // Very complex expressions: (expr)^{\rightarrow} → \overrightarrow{(expr)}
     result = result.replace(/(\([^()]+\))\^\{\\rightarrow\}/g, "\\overrightarrow{$1}");
-    
-    // Also match if there are spaces
-    result = result.replace(/→\s*\\limits\s*_\s*{\s*}/g, "\\underset{}{\\rightarrow}");
-    result = result.replace(/\\rightarrow\s*\\limits\s*_\s*{\s*}/g, "\\underset{}{\\rightarrow}");
-    
+
+    // Thêm xử lý các ký hiệu toán học phổ biến
+    result = result.replace(/≤/g, "\\leq");
+    result = result.replace(/≥/g, "\\geq");
+    result = result.replace(/≠/g, "\\neq");
+    result = result.replace(/≈/g, "\\approx");
+    result = result.replace(/π/g, "\\pi");
+    result = result.replace(/α/g, "\\alpha");
+    result = result.replace(/β/g, "\\beta");
+    result = result.replace(/γ/g, "\\gamma");
+
     return result;
   }
 
@@ -669,15 +670,15 @@
   }
 
   // @see https://www.w3.org/TR/MathML3/chapter7.html
+  // Cải tiến parseLeaf để hỗ trợ thêm các ký hiệu
   function parseLeaf(node) {
     let r = '';
     const nodeName = NodeTool.getNodeName(node);
-    
-    // Special case for empty mrow
+
     if (nodeName === "mrow" && NodeTool.getNodeText(node).trim() === "") {
       return "";
     }
-    
+
     switch (nodeName) {
       case 'mi':
         r = parseElementMi(node);
@@ -688,53 +689,76 @@
       case 'mo':
         r = parseOperator(node);
         break;
-      case 'ms': r = parseElementMs(node);
+      case 'ms':
+        r = parseElementMs(node);
         break;
-      case 'mtext': r = parseElementMtext(node);
+      case 'mtext':
+        r = parseElementMtext(node);
         break;
-      case 'mglyph': r = parseElementMglyph(node);
+      case 'mglyph':
+        r = parseElementMglyph(node);
         break;
-      case 'mprescripts': r = '';
+      case 'mprescripts':
+        r = '';
         break;
-      case 'mspace': r = parseElementMspace();
-      case 'none': r = '\\:';
-      //TODO other usecase of 'none' ?
+      case 'mspace':
+        r = parseElementMspace();
         break;
-      default: r = escapeSpecialChars(NodeTool.getNodeText(node).trim());
+      case 'none':
+        r = '\\:';
+        break;
+      default:
+        r = escapeSpecialChars(NodeTool.getNodeText(node).trim());
         break;
     }
     return r;
   }
 
-  // operator token, mathematical operators
+  // Cải tiến parseOperator để hỗ trợ thêm toán tử
   function parseOperator(node) {
     let it = NodeTool.getNodeText(node).trim();
-    
-    // Special case for arrow (→) with proper spacing
-    if (it === "→") {
-      return " \\rightarrow ";  // Add spaces around arrow
-    }
-    
-    it = MathSymbol.parseOperator(it);
-    return escapeSpecialChars(it);
+
+    const operatorMap = {
+      "→": " \\rightarrow ",
+      "←": " \\leftarrow ",
+      "↔": " \\leftrightarrow ",
+      "⇒": " \\Rightarrow ",
+      "⇐": " \\Leftarrow ",
+      "⇔": " \\Leftrightarrow ",
+      "±": " \\pm ",
+      "×": " \\times ",
+      "÷": " \\div ",
+      "∑": " \\sum ",
+      "∏": " \\prod ",
+      "∫": " \\int ",
+      "−": "-",
+      "≠": " \\neq ",
+      ">": " > ",
+      "=": " = ",
+      ",": ", ", // Dấu phẩy trong tập hợp
+      ";": ";",  // Dấu chấm phẩy không cần khoảng trắng
+      "Ω": "\\Omega" // Thêm ký hiệu Omega
+    };
+
+    return operatorMap[it] || escapeSpecialChars(MathSymbol.parseOperator(it));
   }
 
   // Math identifier
   function parseElementMi(node) {
     let it = NodeTool.getNodeText(node).trim();
-    
+
     // Handle vectors (e.g. AB', AI)
     if (it.includes("'")) {
       return it;  // Return as is to handle in mrow
     }
-    
+
     // Handle subscripts (e.g. n₂)
-    if (it.match(/[a-zA-Z]\d/)) {
+    if (it.match(/[a-zA-z]\d/)) {
       const base = it[0];
       const sub = it[1];
       return `${base}_{${sub}}`;
     }
-    
+
     it = MathSymbol.parseIdentifier(it);
     return escapeSpecialChars(it);
   }
@@ -746,33 +770,33 @@
   }
 
   // Math String
-  function parseElementMs(node){
+  function parseElementMs(node) {
     const content = NodeTool.getNodeText(node).trimRight();
     const it = escapeSpecialChars(content);
     return ['"', it, '"'].join('');
   }
 
   // Math Text
-  function parseElementMtext(node){
+  function parseElementMtext(node) {
     const content = NodeTool.getNodeText(node);
     const it = escapeSpecialChars(content);
     return `\\text{${it}}`;
   }
 
   // Math glyph (image)
-  function parseElementMglyph(node){
+  function parseElementMglyph(node) {
     const it = ['"', NodeTool.getAttr(node, 'alt', ''), '"'].join('');
     return escapeSpecialChars(it);
   }
 
   // TODO need or not
-  function parseElementMspace(node){
+  function parseElementMspace(node) {
     return '';
   }
 
   function escapeSpecialChars(text) {
     const specialChars = /\$|%|_|&|#|\{|\}/g;
-    text = text.replace(specialChars, char => `\\${ char }`);
+    text = text.replace(specialChars, char => `\\${char}`);
     return text;
   }
 
@@ -790,26 +814,33 @@
     const parts = [];
     let lefts = [];
     Array.prototype.forEach.call(children, (node) => {
-      if(NodeTool.getNodeName(node) === 'mo'){
+      if (NodeTool.getNodeName(node) === 'mo') {
         const op = NodeTool.getNodeText(node).trim();
-        if(Brackets.contains(op)){
+        if (Brackets.contains(op)) {
           let stretchy = NodeTool.getAttr(node, 'stretchy', 'true');
           stretchy = ['', 'true'].indexOf(stretchy) > -1;
-          
-          if(Brackets.isRight(op)){
+
+          if (Brackets.isRight(op)) {
             const nearLeft = lefts[lefts.length - 1];
-            if(nearLeft){
-              if(Brackets.isPair(nearLeft, op)){
+            if (nearLeft) {
+              if (Brackets.isPair(nearLeft, op)) {
                 parts.push(Brackets.parseRight(op, stretchy));
                 lefts.pop();
               } else {
                 parts.push(`\\right${op}`);
               }
             } else {
-              parts.push(`\\right${op}`);
+              parts.push(op); // Chỉ thêm dấu ngoặc đóng khi đứng một mình
             }
           } else {
-            parts.push(Brackets.parseLeft(op, stretchy));
+            // Xử lý dấu ngoặc mở
+            if (op === '{' && node.parentNode && 
+                Array.from(NodeTool.getChildren(node.parentNode)).some(child => 
+                  NodeTool.getNodeName(child) === 'mtable')) {
+              parts.push('\\left\\{');
+            } else {
+              parts.push(Brackets.parseLeft(op, stretchy));
+            }
             lefts.push(op);
           }
         } else {
@@ -819,351 +850,444 @@
         parts.push(parse(node));
       }
     });
-    // Only add \right. if there are unmatched left brackets
-    if(lefts.length > 0 && !parts.some(p => p.includes('\\right'))) {
+
+    // Chỉ thêm \right. nếu có dấu ngoặc mở chưa được đóng
+    if (lefts.length > 0 && !parts.some(p => p.includes('\\right'))) {
       parts.push("\\right.");
     }
     lefts = undefined;
     return parts;
   }
 
-
   function getRender(node) {
     let render = undefined;
     const nodeName = NodeTool.getNodeName(node);
-    switch(nodeName){
+
+    switch (nodeName) {
+      case 'mrow':
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (childrenArray.length >= 2 &&
+            NodeTool.getNodeName(childrenArray[0]) === 'mo' &&
+            NodeTool.getNodeName(childrenArray[childrenArray.length - 1]) === 'mo') {
+            const firstOp = NodeTool.getNodeText(childrenArray[0]).trim();
+            const lastOp = NodeTool.getNodeText(childrenArray[childrenArray.length - 1]).trim();
+
+            // Xử lý đặc biệt cho dấu ngoặc nhọn chứa mtable
+            if (firstOp === '{' && childrenArray.some(child => 
+              NodeTool.getNodeName(child) === 'mtable')) {
+              const innerContent = childrenArray
+                .slice(1, -1)
+                .map(child => parse(child))
+                .join('');
+              return `\\left\\{${innerContent}\\right.`;
+            }
+
+            // Xử lý cho trường hợp [a;b) và [a,b)
+            if (firstOp === '[' && lastOp === ')') {
+              const innerContent = childrenArray
+                .slice(1, -1)
+                .map(child => parse(child))
+                .join('');
+              return `\\left[${innerContent}\\right)`;
+            }
+
+            // Xử lý ngoặc nhọn bình thường
+            if (firstOp === '{' && lastOp === '}') {
+              const innerContent = childrenArray
+                .slice(1, -1)
+                .map(child => parse(child))
+                .join('');
+              return `\\{${innerContent}\\}`;
+            }
+
+            // Bỏ qua nếu firstOp là rỗng (trường hợp <mo></mo>)
+            if (!firstOp && !lastOp) {
+              return getRender_joinSeparator("@content")(node, childrenArray);
+            }
+
+            // Xử lý đặc biệt cho dấu ngoặc vuông chứa mtable
+            if (firstOp === '[') {
+              const innerContent = childrenArray
+                .slice(1, -1) // Bỏ dấu ngoặc mở và đóng
+                .map(child => {
+                  const parsed = parse(child);
+                  // Nếu child là mtable, trả về nội dung đã được định dạng với \begin{array}{l} ... \end{array}
+                  if (NodeTool.getNodeName(child) === 'mtable') {
+                    const rows = Array.from(NodeTool.getChildren(child)).map(row => {
+                      const rowChildren = Array.from(NodeTool.getChildren(row));
+                      return rowChildren.map(cell => parse(cell)).join('');
+                    });
+                    return `\\begin{array}{l} ${rows.join(' \\\\ ')} \\end{array}`;
+                  }
+                  // Nếu child là mrow chứa mtable, xử lý tương tự
+                  if (NodeTool.getNodeName(child) === 'mrow' &&
+                    Array.from(NodeTool.getChildren(child)).some(c => NodeTool.getNodeName(c) === 'mtable')) {
+                    const mtableChild = Array.from(NodeTool.getChildren(child)).find(c => NodeTool.getNodeName(c) === 'mtable');
+                    const rows = Array.from(NodeTool.getChildren(mtableChild)).map(row => {
+                      const rowChildren = Array.from(NodeTool.getChildren(row));
+                      return rowChildren.map(cell => parse(cell)).join('');
+                    });
+                    return `\\begin{array}{l} ${rows.join(' \\\\ ')} \\end{array}`;
+                  }
+                  return parsed;
+                })
+                .join('');
+
+              // Giữ nguyên dấu ngoặc vuông lớn
+              return `\\left[${innerContent}\\right.`;
+            }
+
+            if (Brackets.isPair(firstOp, lastOp)) {
+              const innerContent = childrenArray
+                .slice(1, -1)
+                .map(child => parse(child))
+                .join('');
+              return `\\left${firstOp}${innerContent}\\right${lastOp}`;
+            }
+
+            // Giữ nguyên dấu ngoặc nhọn trong MathML
+            if (firstOp === '{' || lastOp === '}') {
+              const innerContent = childrenArray
+                .slice(1, lastOp === '}' ? -1 : undefined)
+                .map(child => parse(child))
+                .join('');
+              return `${firstOp === '{' ? '\\{' : ''}${innerContent}${lastOp === '}' ? '\\}' : ''}`;
+            }
+          }
+          return getRender_joinSeparator("@content")(node, childrenArray);
+        };
+        break;
+
       case 'msub':
-        render = function(node, children) {
-          if (!children || children.length < 2) return '';
-          
-          const base = parse(children[0]);
-          if (!base) return '';
-          
-          const sub = children[1];
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          const base = parse(childrenArray[0]) || '';
+          const sub = childrenArray[1];
           if (!sub) return base;
 
-          // Handle nested subscript with empty mrow
-          if (NodeTool.getNodeName(sub) === 'msub' && 
-              sub.firstChild && 
-              NodeTool.getNodeName(sub.firstChild) === 'mrow' &&
-              (!NodeTool.getNodeText(sub.firstChild) || NodeTool.getNodeText(sub.firstChild).trim() === '')) {
+          if (NodeTool.getNodeName(sub) === 'msub' &&
+            sub.firstChild &&
+            NodeTool.getNodeName(sub.firstChild) === 'mrow' &&
+            (!NodeTool.getNodeText(sub.firstChild) || NodeTool.getNodeText(sub.firstChild).trim() === '')) {
             const lastChild = sub.lastChild;
-            if (!lastChild) return base;
-            return `${base}_${parse(lastChild)}`;
+            return lastChild ? `${base}_${parse(lastChild)}` : base;
           }
-          
-          // Regular subscript
           return `${base}_{${parse(sub)}}`;
         };
         break;
+
       case 'msup':
-        render = getRender_default("@1^{@2}");
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          const base = parse(childrenArray[0]) || '';
+          const sup = parse(childrenArray[1]) || '';
+          return `${base}^{${sup}}`;
+        };
         break;
+
       case 'msubsup':
-        render = getRender_default("@1_{@2}^{@3}");
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 3) return '';
+          const base = parse(childrenArray[0]);
+          const sub = parse(childrenArray[1]);
+          const sup = parse(childrenArray[2]);
+
+          const lastChild = childrenArray[0].lastElementChild;
+          if (lastChild && NodeTool.getNodeName(lastChild) === 'mo' &&
+            NodeTool.getNodeText(lastChild).trim() === '|') {
+            const content = Array.from(childrenArray[0].children)
+              .slice(0, -1)
+              .map(child => parse(child))
+              .join('');
+            return `\\left.${content}\\right|_{${sub}}^{${sup}}`;
+          }
+          return `${base}_{${sub}}^{${sup}}`;
+        };
         break;
+
       case 'mover':
-        render = renderMover;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          const base = parse(childrenArray[0]) || '';
+          const over = parse(childrenArray[1]) || '';
+          const overText = NodeTool.getNodeText(childrenArray[1])?.trim() || '';
+          const isAccent = NodeTool.getAttr(node, "accent", "false") === "true";
+
+          if (overText === "→" && isAccent) return `\\vec{${base}}`;
+          if (overText === "¯" && isAccent) return `\\overline{${base}}`;
+          if (overText === "^" && isAccent) return `\\hat{${base}}`;
+          return `\\overset{${over}}{${base}}`;
+        };
         break;
+
       case 'munder':
-        render = renderMunder;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          const base = parse(childrenArray[0]) || '';
+          const under = parse(childrenArray[1]) || '';
+          const isUnderAccent = NodeTool.getAttr(node, "accentunder", "false") === "true";
+
+          if (base === "∫") return `\\int_{${under}}`;
+          return `\\underset{${under}}{${base}}`;
+        };
         break;
+
       case 'munderover':
-        render = renderMunderover;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 3) return '';
+          const base = parse(childrenArray[0]);
+          const under = parse(childrenArray[1]);
+          const over = parse(childrenArray[2]);
+          const baseText = NodeTool.getNodeText(childrenArray[0]).trim();
+
+          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}}`;
+        };
         break;
+
       case 'mmultiscripts':
-        render = renderMmultiscripts;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 1) return '';
+          const base = parse(childrenArray[0]);
+          let prescripts = '';
+          let postscripts = '';
+          let i = 1;
+
+          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;
+              }
+            } else {
+              if (i + 1 < childrenArray.length) {
+                postscripts += `_{${parse(childrenArray[i])}}^{${parse(childrenArray[i + 1])}}`;
+                i += 2;
+              } else break;
+            }
+          }
+          return `${base}${prescripts}${postscripts}`;
+        };
         break;
+
+      case 'mlongdiv':
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          return `\\longdiv{${parse(childrenArray[0])}}{${parse(childrenArray[1])}}`;
+        };
+        break;
+
       case 'mroot':
-        render = getRender_default("\\sqrt[@2]{@1}");
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          const base = parse(childrenArray[0]);
+          const index = parse(childrenArray[1]);
+          return `\\sqrt[${index}]{${base}}`;
+        };
         break;
+
       case 'msqrt':
-        render = getRender_joinSeparator("\\sqrt{@content}");
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          const content = renderChildren(childrenArray).join('');
+          return `\\sqrt{${content}}`;
+        };
         break;
+
       case 'mtable':
-        render = renderTable;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+
+          // Kiểm tra xem mtable có phải là mtable con không
+          let isNestedTable = false;
+          let parent = node.parentNode;
+          while (parent) {
+            if (NodeTool.getNodeName(parent) === 'mtable') {
+              isNestedTable = true;
+              break;
+            }
+            parent = parent.parentNode;
+          }
+
+          // Xử lý mỗi mtr như một hàng
+          const rows = childrenArray.map(row => {
+            const rowChildren = Array.from(NodeTool.getChildren(row));
+            return rowChildren.map(cell => parse(cell)).join('');
+          });
+
+          // Nếu là mtable con, chỉ trả về các hàng mà không bao bọc trong \begin{array}...\end{array}
+          if (isNestedTable) {
+            return rows.join(' \\\\ ');
+          }
+
+          // Nếu mtable nằm trong mrow với dấu ngoặc vuông, sẽ được xử lý ở mrow
+          let isInsideSquareBrackets = false;
+          parent = node.parentNode;
+          while (parent) {
+            if (NodeTool.getNodeName(parent) === 'mrow') {
+              const childrenOfParent = Array.from(NodeTool.getChildren(parent));
+              if (childrenOfParent.length >= 2 &&
+                NodeTool.getNodeName(childrenOfParent[0]) === 'mo' &&
+                NodeTool.getNodeText(childrenOfParent[0]).trim() === '[') {
+                isInsideSquareBrackets = true;
+                break;
+              }
+            }
+            parent = parent.parentNode;
+          }
+
+          if (isInsideSquareBrackets) {
+            return rows.join(' \\\\ ');
+          }
+
+          // Nếu là mtable chính, bao bọc trong \begin{array}...\end{array}
+          const arrayContent = rows.join(' \\\\ ');
+          return `\\begin{array}{l} ${arrayContent} \\end{array}`;
+        };
         break;
+
       case 'mtr':
-        render = getRender_joinSeparator("@content \\\\ ", ' & ');
+        render = getRender_joinSeparator("@content", " & ");
         break;
+
       case 'mtd':
         render = getRender_joinSeparator("@content");
         break;
+
       case 'mfrac':
-        render = renderMfrac;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          if (!childrenArray || childrenArray.length < 2) return '';
+          const num = parse(childrenArray[0]);
+          const den = parse(childrenArray[1]);
+          const linethickness = NodeTool.getAttr(node, 'linethickness', 'medium');
+          if (linethickness === '0') return `\\binom{${num}}{${den}}`;
+          return `\\frac{${num}}{${den}}`;
+        };
         break;
+
       case 'mfenced':
-        render = renderMfenced;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          const open = NodeTool.getAttr(node, 'open', '(');
+          const close = NodeTool.getAttr(node, 'close', ')');
+          const separators = NodeTool.getAttr(node, 'separators', ',').split('');
+
+          // Xử lý đặc biệt cho mfenced chứa mtable
+          if (open === '{' && !close) {
+            // Kiểm tra xem có mtable trong cấu trúc không
+            const hasMtable = childrenArray.some(child => {
+              // Kiểm tra trực tiếp mtable
+              if (NodeTool.getNodeName(child) === 'mtable') return true;
+              // Kiểm tra mtable trong mrow
+              if (NodeTool.getNodeName(child) === 'mrow') {
+                return Array.from(NodeTool.getChildren(child)).some(
+                  grandChild => NodeTool.getNodeName(grandChild) === 'mtable'
+                );
+              }
+              return false;
+            });
+
+            if (hasMtable) {
+              const content = childrenArray.map(child => parse(child)).join('');
+              return `\\left\\{${content}\\right.`;
+            }
+          }
+
+          // Xử lý cho trường hợp [a;b)
+          if (open === '[' && close === ')') {
+            const parts = [];
+            childrenArray.forEach((child, index) => {
+              parts.push(parse(child));
+              if (index < childrenArray.length - 1 && separators[index % separators.length]) {
+                parts.push(separators[index % separators.length]);
+              }
+            });
+            return `\\left[${parts.join('')}\\right)`;
+          }
+
+          // Giữ nguyên xử lý cho các trường hợp khác
+          const parts = [];
+          childrenArray.forEach((child, index) => {
+            parts.push(parse(child));
+            if (index < childrenArray.length - 1 && separators[index % separators.length]) {
+              parts.push(separators[index % separators.length]);
+            }
+          });
+          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 `${content}\\right${close}`;
+          return `\\left${open}${content}\\right${close}`;
+        };
+        break;
+
+      case 'menclose':
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          const notation = NodeTool.getAttr(node, 'notation', 'longdiv');
+          const content = renderChildren(childrenArray).join('');
+          switch (notation) {
+            case 'box': return `\\boxed{${content}}`;
+            case 'circle': return `\\enclose{circle}{${content}}`;
+            case 'roundedbox': return `\\fbox{${content}}`;
+            default: return content;
+          }
+        };
         break;
+
       case 'mi':
       case 'mn':
       case 'mo':
       case 'ms':
       case 'mtext':
-        // they may contains <mglyph>
         render = getRender_joinSeparator("@content");
         break;
+
       case 'mphantom':
-        render = renderMphantom;
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          const content = renderChildren(childrenArray).join('');
+          return `\\phantom{${content}}`;
+        };
+        break;
+
+      case 'mstyle':
+        render = function (node, children) {
+          const childrenArray = Array.from(children);
+          const mathsize = NodeTool.getAttr(node, 'mathsize', 'normal');
+          const content = renderChildren(childrenArray).join('');
+          switch (mathsize) {
+            case 'big': return `\\large{${content}}`;
+            case 'small': return `\\small{${content}}`;
+            default: return content;
+          }
+        };
         break;
+
       default:
-        // math, mstyle, mrow
         render = getRender_joinSeparator("@content");
         break;
     }
     return render;
   }
 
-  function renderTable(node, children) {
-    const template = "\\begin{array}{l}@content\\end{array}";
-    // Remove extra backslash and add proper spacing
-    const render = getRender_joinSeparator(template, " \\\\ ");
-    return render(node, children);
-  }
-
-  function renderMover(node, children) {
-      // Check if children exists and has enough elements
-      if (!children || children.length < 2) return '';
-
-      const baseNode = children[0];
-      const overNode = children[1];
-      
-      // Check if nodes exist before accessing
-      if (!baseNode || !overNode) return '';
-      
-      const overText = NodeTool.getNodeText(overNode)?.trim() || '';
-      const isAccent = NodeTool.getAttr(node, "accent", "false") === "true";
-
-      // Handle vector notation
-      if (overText === "→" && isAccent) {
-          return `\\vec{${parse(baseNode)}}`;
-      }
-
-      return parse(baseNode);
-  }
-
-  function renderMfenced(node, children) {
-      const [open, close, separatorsStr] = [
-          NodeTool.getAttr(node, 'open', '('),
-          NodeTool.getAttr(node, 'close', ')'),
-          NodeTool.getAttr(node, 'separators', ',')
-      ];
-
-      const parts = renderChildren(children);
-      const content = parts.join(separatorsStr === '|' ? ',' : separatorsStr).trim();
-      
-      // Handle nested absolute value cases
-      if (open === '|' && close === '') {
-          return `\\left|${content}`;
-      }
-      if (open === '' && close === '|') {
-          return `${content}\\right|`;
-      }
-      
-      // Handle system of equations with curly brace
-      if (open === '{') {
-          return `\\left\\{${content}${close ? '\\right\\}' : '\\right.'}`;
-      }
-      
-      // Handle regular absolute value notation
-      if (open === '|' && close === '|') {
-          return `\\left|${content}\\right|`;
-      }
-
-      // Regular cases with proper closing
-      return `\\left${open}${content}\\right${close || '.'}`;
-  }
-
-  function renderMfrac(node, children){
-    const [linethickness, bevelled] = [
-      NodeTool.getAttr(node, 'linethickness', 'medium'),
-      NodeTool.getAttr(node, 'bevelled', 'false')
-    ];
-
-    let render = null;
-    if(bevelled === 'true') {
-      render = getRender_default("{}^{@1}/_{@2}");
-    } else if(['0', '0px'].indexOf(linethickness) > -1) {
-      const [prevNode, nextNode] = [
-        NodeTool.getPrevNode(node),
-        NodeTool.getNextNode(node)
-      ];
-      if((prevNode && NodeTool.getNodeText(prevNode).trim() === '(') &&
-         (nextNode && NodeTool.getNodeText(nextNode).trim() === ')')
-      ) {
-        render = getRender_default("\\binom{@1}{@2}");
-      } else {
-        render = getRender_default("\\frac{@1}{@2}");
-      }
-    } else {
-      render = getRender_default("\\frac{@1}{@2}");
-    }
-    return render(node, children);
-  }
-
-  function renderMmultiscripts(node, children) {
-    if(children.length === 0) { return '' }
-    let sepIndex = -1;
-    let mprescriptsNode = null;
-    Array.prototype.forEach.call(children, (node) => {
-      if(NodeTool.getNodeName(node) === 'mprescripts'){
-        mprescriptsNode = node;
-      }
-    });
-    if(mprescriptsNode) {
-      sepIndex = Array.prototype.indexOf.call(children, mprescriptsNode);
-    }
-    const parts = renderChildren(children);
-
-    const splitArray = (arr, index) => {
-      return [arr.slice(0, index), arr.slice(index + 1, arr.length)]
-    };
-    const renderScripts = (items) => {
-      if(items.length > 0) {
-        const subs = [];
-        const sups = [];
-        items.forEach((item, index) => {
-          // one render as sub script, one as super script
-          if((index + 1) % 2 === 0){
-            sups.push(item);
-          } else {
-            subs.push(item);
-          }
-        });
-        return [
-          (subs.length > 0 ? `_{${subs.join(' ')}}` : ''),
-          (sups.length > 0 ? `^{${sups.join(' ')}}` : '')
-        ].join('');
-      } else {
-        return '';
-      }
-    };
-    const base = parts.shift();
-    let prevScripts = [];
-    let backScripts = [];
-    if(sepIndex === -1){
-      backScripts = parts;
-    } else {
-      [backScripts, prevScripts] = splitArray(parts, sepIndex - 1);
-    }
-    return [renderScripts(prevScripts), base, renderScripts(backScripts)].join('');
-  }
-
-  function renderMunder(node, children){
-    const nodes = flattenNodeTreeByNodeName(node, 'munder');
-    let result = undefined;
-    for(let i = 0; i < nodes.length - 1; i++) {
-      if(!result){ result = parse(nodes[i]); }
-      
-      const underNode = nodes[i + 1];
-      const underText = NodeTool.getNodeText(underNode).trim();
-      const isAccent = NodeTool.getAttr(node, "accent", "false") === "true";
-      
-      // Special handling for arrow accent
-      if (underText === "→" && isAccent) {
-        return `\\underset{${result}}{\\rightarrow}`;
-      }
-      
-      const under = parse(underNode);
-      const template = getMatchValueByChar({
-        decimals: MathSymbol.underScript.decimals,
-        values: MathSymbol.underScript.templates,
-        judgeChar: underText,
-        defaultValue: "@1_{@2}"
-      });
-      result = renderTemplate(template.replace("@v", "@1"), [result, under]);
-    }
-    return result;
-  }
-
-  function renderMunderover(node, children){
-    const nodes = flattenNodeTreeByNodeName(node, 'munderover');
-    let result = undefined;
-    for(let i = 0; i < nodes.length - 1; i++) {
-      if(!result){ result = parse(nodes[i]); }
-      
-      const overNode = nodes[i + 1];
-      const overText = NodeTool.getNodeText(overNode).trim();
-      const underNode = nodes[i + 2];
-      const underText = NodeTool.getNodeText(underNode).trim();
-      const isAccent = NodeTool.getAttr(node, "accent", "false") === "true";
-      
-      // Special handling for arrow accent
-      if (overText === "→" && isAccent) {
-        return `\\overset{${result}}{\\underset{${underText}}{\\rightarrow}}`;
-      }
-      
-      const over = parse(overNode);
-      const under = parse(underNode);
-      const template = getMatchValueByChar({
-        decimals: MathSymbol.underoverScript.decimals,
-        values: MathSymbol.underoverScript.templates,
-        judgeChar: overText,
-        defaultValue: "@1_{@2}^{@3}"
-      });
-      result = renderTemplate(template.replace("@v", "@1"), [over, under]);
-    }
-    return result;
-  }
-
-  function renderMphantom(node, children){
-    const nodes = flattenNodeTreeByNodeName(node, 'mphantom');
-    let result = undefined;
-    for(let i = 0; i < nodes.length - 1; i++) {
-      if(!result){ result = parse(nodes[i]); }
-      
-      const phantomNode = nodes[i + 1];
-      const phantomText = NodeTool.getNodeText(phantomNode).trim();
-      const isAccent = NodeTool.getAttr(node, "accent", "false") === "true";
-      
-      // Special handling for arrow accent
-      if (phantomText === "→" && isAccent) {
-        return `\\overrightarrow{${result}}`;
-      }
-      
-      const phantom = parse(phantomNode);
-      const template = getMatchValueByChar({
-        decimals: MathSymbol.phantomScript.decimals,
-        values: MathSymbol.phantomScript.templates,
-        judgeChar: phantomText,
-        defaultValue: "@1^{@2}"
-      });
-      result = renderTemplate(template.replace("@v", "@1"), [result, phantom]);
-    }
-    return result;
-  }
-
-  function renderTemplate(template, args) {
-    return template.replace(/@(\d+)/g, (match, index) => {
-      const arg = args[index - 1];
-      return arg || match;
-    });
-  }
-
-  function getMatchValueByChar(options) {
-    const { decimals, values, judgeChar, defaultValue } = options;
-    const match = values.find(value => value.judgeChar === judgeChar);
-    return match || defaultValue;
-  }
-
-  function flattenNodeTreeByNodeName(node, nodeName) {
-    const nodes = [];
-    const children = NodeTool.getChildren(node);
-    if (children && children.length > 0) {
-      // Convert HTMLCollection to Array before using forEach
-      Array.from(children).forEach(child => {
-        if (NodeTool.getNodeName(child) === nodeName) {
-          nodes.push(child);
-        } else {
-          // Recursively search in child nodes
-          const childNodes = flattenNodeTreeByNodeName(child, nodeName);
-          nodes.push(...childNodes);
-        }
-      });
-    }
-    return nodes;
-  }
-
   // Export the convert function
   var mathml2latex = {
     convert: convert