ed-mathml2tex 0.0.9 → 0.1.1

package/lib/mathml2latex.browser.cjs.js

@@ -584,74 +584,75 @@ T.createMarker = function() {
   }
 };
 
-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;
 }
 
@@ -665,15 +666,15 @@ function parse(node) {
 }
 
 // @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);
@@ -684,53 +685,76 @@ function parseLeaf(node) {
     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);
 }
@@ -742,33 +766,33 @@ function parseElementMn(node) {
 }
 
 // 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;
 }
 
@@ -786,31 +810,33 @@ function renderChildren(children) {
   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 {
-              if(Brackets.isLeft(op)) {
-                parts.push(Brackets.parseLeft(op, stretchy));
-                lefts.push(op);
-              }
-            }
-          }else {
-            if(Brackets.isLeft(op)) {
-              parts.push(Brackets.parseLeft(op, stretchy));
-              lefts.push(op);
+              parts.push(`\\right${op}`);
             }
+          } else {
+            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 {
@@ -820,345 +846,444 @@ function renderChildren(children) {
       parts.push(parse(node));
     }
   });
-  if(lefts.length > 0){
-    for(let i=0; i < lefts.length; i++){
-      parts.push("\\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 system of equations with curly brace
-    if (open === '{') {
-        // If no closing brace specified, use \right.
-        return `\\left\\{${content}${close ? '\\right\\}' : '\\right.'}`;
-    }
-    
-    // Handle absolute value notation
-    if (open === '|' && (close === '|' || 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