ed-mathml2tex 0.1.6 → 0.1.8

package/lib/mathml2latex.es.js

@@ -582,10 +582,10 @@ T.createMarker = function() {
   }
 };
 
-function getRender_joinSeparator(template, separator = '') {
+function getRender_joinSeparator(template, separator = "") {
   return function (node, children) {
     const parts = renderChildren(children);
-    return template.replace('@content', parts.join(separator));
+    return template.replace("@content", parts.join(separator));
   };
 }
 
@@ -597,9 +597,11 @@ function convert(mathmlHtml) {
   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>") &&
+  if (
+    mathmlHtml.includes("<munder>") &&
     mathmlHtml.includes("<mo>→</mo>") &&
-    mathmlHtml.includes("<mrow/>")) {
+    mathmlHtml.includes("<mrow/>")
+  ) {
     if (result.includes("\\limits")) {
       result = "\\underset{}{\\rightarrow}";
     }
@@ -608,38 +610,71 @@ function convert(mathmlHtml) {
   // Thêm xử lý cho các thẻ MathML khác
   result = result
     .replace(/∞/g, "\\infty") // Vô cực
-    .replace(/∑/g, "\\sum")   // Tổng
-    .replace(/∏/g, "\\prod")  // Tích
-    .replace(/∫/g, "\\int");  // Tích phân
+    .replace(/∑/g, "\\sum") // Tổng
+    .replace(/∏/g, "\\prod") // Tích
+    .replace(/∫/g, "\\int"); // Tích phân
 
   return result;
 }
 
 function toLatex(result) {
   // 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, '');
+  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, "");
 
   // 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}");
-
-  result = result.replace(/→\\limits_\{([^}]*)\}/g, "\\underset{$1}{\\rightarrow}");
-  result = result.replace(/\\rightarrow\\limits_\{([^}]*)\}/g, "\\underset{$1}{\\rightarrow}");
-
-  result = result.replace(/→\\limits_\{([^}]*)\}\^\{([^}]*)\}/g, "\\overset{$2}{\\underset{$1}{\\rightarrow}}");
-  result = result.replace(/\\rightarrow\\limits_\{([^}]*)\}\^\{([^}]*)\}/g, "\\overset{$2}{\\underset{$1}{\\rightarrow}}");
+  result = result.replace(
+    /\\rightarrow\\limits_{}/g,
+    "\\underset{}{\\rightarrow}"
+  );
+  result = result.replace(
+    /\\rightarrow\\limits_{(\s*)}/g,
+    "\\underset{}{\\rightarrow}"
+  );
+
+  result = result.replace(
+    /→\\limits_\{([^}]*)\}/g,
+    "\\underset{$1}{\\rightarrow}"
+  );
+  result = result.replace(
+    /\\rightarrow\\limits_\{([^}]*)\}/g,
+    "\\underset{$1}{\\rightarrow}"
+  );
+
+  result = result.replace(
+    /→\\limits_\{([^}]*)\}\^\{([^}]*)\}/g,
+    "\\overset{$2}{\\underset{$1}{\\rightarrow}}"
+  );
+  result = result.replace(
+    /\\rightarrow\\limits_\{([^}]*)\}\^\{([^}]*)\}/g,
+    "\\overset{$2}{\\underset{$1}{\\rightarrow}}"
+  );
 
   // 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}");
-  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}");
-  result = result.replace(/(\([^()]+\))\^\{\\rightarrow\}/g, "\\overrightarrow{$1}");
+  result = result.replace(
+    /([^{}\s]+)\^\{\\rightarrow\}/g,
+    "\\overrightarrow{$1}"
+  );
+  result = result.replace(
+    /\{([^{}]+)\}\^\{\\rightarrow\}/g,
+    "\\overrightarrow{$1}"
+  );
+  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}"
+  );
+  result = result.replace(
+    /(\([^()]+\))\^\{\\rightarrow\}/g,
+    "\\overrightarrow{$1}"
+  );
 
   // Remove or comment out these lines in toLatex function
   // Thêm xử lý các ký hiệu toán học phổ biến
@@ -667,7 +702,7 @@ 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 = '';
+  let r = "";
   const nodeName = NodeTool.getNodeName(node);
 
   if (nodeName === "mrow" && NodeTool.getNodeText(node).trim() === "") {
@@ -675,32 +710,32 @@ function parseLeaf(node) {
   }
 
   switch (nodeName) {
-    case 'mi':
+    case "mi":
       r = parseElementMi(node);
       break;
-    case 'mn':
+    case "mn":
       r = parseElementMn(node);
       break;
-    case 'mo':
+    case "mo":
       r = parseOperator(node);
       break;
-    case 'ms':
+    case "ms":
       r = parseElementMs(node);
       break;
-    case 'mtext':
+    case "mtext":
       r = parseElementMtext(node);
       break;
-    case 'mglyph':
+    case "mglyph":
       r = parseElementMglyph(node);
       break;
-    case 'mprescripts':
-      r = '';
+    case "mprescripts":
+      r = "";
       break;
-    case 'mspace':
+    case "mspace":
       r = parseElementMspace();
       break;
-    case 'none':
-      r = '\\:';
+    case "none":
+      r = "\\:";
       break;
     default:
       r = escapeSpecialChars(NodeTool.getNodeText(node).trim());
@@ -709,10 +744,10 @@ function parseLeaf(node) {
   return r;
 }
 
-// Cải tiến parseOperator để hỗ trợ thêm toán tử
+// --- PATCH by AI: Fix for set-builder notation and fraction output ---
+// 1. Extend operatorMap and add π->\pi, |->\mid
 function parseOperator(node) {
   let it = NodeTool.getNodeText(node).trim();
-
   const operatorMap = {
     "→": " \\rightarrow ",
     "←": " \\leftarrow ",
@@ -731,12 +766,14 @@ function parseOperator(node) {
     ">": " > ",
     "=": " = ",
     ",": ", ", // 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
+    ";": ";",
+    Ω: "\\Omega",
+    "|": " \\mid ", // PATCH: set-builder mid
+    π: " \\pi ", // PATCH: Greek letter
   };
-
   return operatorMap[it] || escapeSpecialChars(MathSymbol.parseOperator(it));
 }
+// --- END PATCH ---
 
 // Math identifier
 function parseElementMi(node) {
@@ -744,7 +781,7 @@ function parseElementMi(node) {
 
   // Handle vectors (e.g. AB', AI)
   if (it.includes("'")) {
-    return it;  // Return as is to handle in mrow
+    return it; // Return as is to handle in mrow
   }
 
   // Handle subscripts (e.g. n₂)
@@ -768,27 +805,41 @@ function parseElementMn(node) {
 function parseElementMs(node) {
   const content = NodeTool.getNodeText(node).trimRight();
   const it = escapeSpecialChars(content);
-  return ['"', it, '"'].join('');
+  return ['"', it, '"'].join("");
 }
 
 // Math Text
 function parseElementMtext(node) {
   let content = NodeTool.getNodeText(node)
     // Handle operators and spacing only
-    .replace(/\s*=\s*/g, ' = ')
-    .replace(/\s*\.\s*/g, ' \\cdot ')
+    .replace(/\s*=\s*/g, " = ")
+    .replace(/\s*\.\s*/g, " \\cdot ")
     .trim();
 
+  const specialMTextMap = {
+    ℝ: "\\mathbb{R}",
+    ℤ: "\\mathbb{Z}",
+    ℕ: "\\mathbb{N}",
+    ℚ: "\\mathbb{Q}",
+    ℂ: "\\mathbb{C}",
+    "\\": "\\setminus ",
+    "|": "\\mid ",
+    " ": "",
+  };
+  if (specialMTextMap[content]) return specialMTextMap[content];
+
   // Handle units with proper \mathrm formatting
-  if (content.includes('(') && content.includes(')')) {
+  if (content.includes("(") && content.includes(")")) {
     const parts = content.split(/(\([^)]+\))/);
-    content = parts.map(part => {
-      if (part.startsWith('(') && part.endsWith(')')) {
-        // Keep original characters in units
-        return `\\mathrm{${part}}`;
-      }
-      return part;
-    }).join('');
+    content = parts
+      .map((part) => {
+        if (part.startsWith("(") && part.endsWith(")")) {
+          // Keep original characters in units
+          return `\\mathrm{${part}}`;
+        }
+        return part;
+      })
+      .join("");
   }
 
   return content;
@@ -796,84 +847,124 @@ function parseElementMtext(node) {
 
 // Math glyph (image)
 function parseElementMglyph(node) {
-  const it = ['"', NodeTool.getAttr(node, 'alt', ''), '"'].join('');
+  const it = ['"', NodeTool.getAttr(node, "alt", ""), '"'].join("");
   return escapeSpecialChars(it);
 }
 
 // TODO need or not
 function parseElementMspace(node) {
-  return '';
+  return "";
 }
 
 function escapeSpecialChars(text) {
+  // Don't escape pi, Greek, or just a-z0-9 or Unicode Greek, or empty
+  if (
+    /^\\?[a-zA-Z0-9]+$/.test(text) ||
+    /^\\(?:pi|alpha|beta|gamma|Omega)$/.test(text) ||
+    /^π$/.test(text) ||
+    !text
+  ) {
+    return text;
+  }
+  // Otherwise escape only true reserved LaTeX
   const specialChars = /\$|%|_|&|#|\{|\}/g;
-  text = text.replace(specialChars, char => `\\${char}`);
+  text = text.replace(specialChars, (char) => `\\${char}`);
   return text;
 }
 
-
 function parseContainer(node, children) {
   const render = getRender(node);
   if (render) {
     return render(node, children);
   } else {
-    throw new Error(`Couldn't get render function for container node: ${NodeTool.getNodeName(node)}`);
+    throw new Error(
+      `Couldn't get render function for container node: ${NodeTool.getNodeName(
+        node
+      )}`
+    );
   }
 }
 
 function renderChildren(children) {
   const parts = [];
   let lefts = [];
-  Array.prototype.forEach.call(children, (node) => {
-    if (NodeTool.getNodeName(node) === 'mo') {
+
+  // PATCH: Special case for set-builder style: leading { ... trailing }
+  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("");
+    return `\\left\\{${innerContent}\\right\\}`;
+  }
+
+  Array.prototype.forEach.call(children, (node, idx) => {
+    // PATCH: Thin space between variables/numbers in mfrac numerator (k 2 π)
+    if (
+      NodeTool.getNodeName(node) === "mrow" &&
+      node.parentNode &&
+      NodeTool.getNodeName(node.parentNode) === "mfrac"
+    ) {
+      const mrowKids = Array.from(NodeTool.getChildren(node));
+      if (
+        mrowKids.every((n) =>
+          ["mi", "mn", "mo"].includes(NodeTool.getNodeName(n))
+        )
+      ) {
+        // Only vars, nums, ops (possibly Greek); join with thin space
+        const str = mrowKids.map((k) => parse(k)).join("\\,");
+        parts.push(str);
+        return;
+      }
+    }
+    // END PATCH
+    if (NodeTool.getNodeName(node) === "mo") {
       const op = NodeTool.getNodeText(node).trim();
       if (Brackets.contains(op)) {
-        let stretchy = NodeTool.getAttr(node, 'stretchy', 'true');
-        stretchy = ['', 'true'].indexOf(stretchy) > -1;
+        let stretchy = NodeTool.getAttr(node, "stretchy", "true");
+        stretchy = ["", "true"].indexOf(stretchy) > -1;
+
+        let escapedOp = op;
+        if (op === "{" || op === "}") {
+          escapedOp = `\\${op}`;
+        }
 
         if (Brackets.isRight(op)) {
           const nearLeft = lefts[lefts.length - 1];
+          // CHỈ CẦN CÓ NGOẶC TRÁI LÀ ĐỦ, KHÔNG CẦN KIỂM TRA CÓ "KHỚP" HAY KHÔNG
           if (nearLeft) {
-            if (Brackets.isPair(nearLeft, op)) {
-              // Kiểm tra xem có phải là một phần của biểu thức mũ không
-              const parentNode = node.parentNode;
-              const nextSibling = node.nextSibling;
-              const prevSibling = node.previousSibling;
-              
-              const isInPower = parentNode && (
-                NodeTool.getNodeName(parentNode) === 'msup' ||
-                (nextSibling && NodeTool.getNodeName(nextSibling) === 'msup') ||
-                (prevSibling && NodeTool.getNodeName(prevSibling) === 'msup')
-              );
-              
-              if (isInPower) {
-                parts.push(op); // Không thêm \right cho ngoặc trong mũ
-              } else {
-                parts.push(op); // Chỉ thêm dấu ngoặc đơn giản
-              }
-              lefts.pop();
+            const parentNode = node.parentNode;
+            const isInPower =
+              parentNode && NodeTool.getNodeName(parentNode) === "msup";
+
+            if (stretchy && !isInPower) {
+              parts.push(`\\right${escapedOp}`);
             } else {
-              parts.push(op);
+              parts.push(escapedOp);
             }
+            lefts.pop(); // Luôn đóng ngoặc trái gần nhất
           } else {
-            parts.push(op);
+            parts.push(escapedOp); // Ngoặc phải không có ngoặc trái tương ứng
           }
         } else {
-          // Kiểm tra cho dấu ngoặc mở
+          // Là ngoặc trái
           const parentNode = node.parentNode;
-          const nextSibling = node.nextSibling;
-          
-          const isInPower = parentNode && (
-            NodeTool.getNodeName(parentNode) === 'msup' ||
-            (nextSibling && NodeTool.getNodeName(nextSibling) === 'msup')
-          );
-          
-          if (isInPower) {
-            parts.push(op); // Không thêm \left cho ngoặc trong mũ
+          const isInPower =
+            parentNode && NodeTool.getNodeName(parentNode) === "msup";
+
+          if (stretchy && !isInPower) {
+            parts.push(`\\left${escapedOp}`);
           } else {
-            parts.push(op); // Chỉ thêm dấu ngoặc đơn giản
+            parts.push(escapedOp);
           }
-          lefts.push(op);
+          lefts.push(op); // Dùng op gốc để so sánh
         }
       } else {
         parts.push(parseOperator(node));
@@ -882,7 +973,6 @@ function renderChildren(children) {
       parts.push(parse(node));
     }
   });
-
   lefts = undefined;
   return parts;
 }
@@ -892,41 +982,49 @@ function getRender(node) {
   const nodeName = NodeTool.getNodeName(node);
 
   switch (nodeName) {
-    case 'mrow':
+    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') {
+        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();
+          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')) {
+          if (
+            firstOp === "{" &&
+            childrenArray.some(
+              (child) => NodeTool.getNodeName(child) === "mtable"
+            )
+          ) {
             const innerContent = childrenArray
               .slice(1, -1)
-              .map(child => parse(child))
-              .join('');
+              .map((child) => parse(child))
+              .join("");
             return `\\left\\{${innerContent}\\right.`;
           }
 
           // Xử lý cho trường hợp [a;b) và [a,b)
-          if (firstOp === '[' && lastOp === ')') {
+          if (firstOp === "[" && lastOp === ")") {
             const innerContent = childrenArray
               .slice(1, -1)
-              .map(child => parse(child))
-              .join('');
+              .map((child) => parse(child))
+              .join("");
             return `\\left[${innerContent}\\right)`;
           }
 
           // Xử lý ngoặc nhọn bình thường
-          if (firstOp === '{' && lastOp === '}') {
+          if (firstOp === "{" && lastOp === "}") {
             const innerContent = childrenArray
               .slice(1, -1)
-              .map(child => parse(child))
-              .join('');
-            return `\\{${innerContent}\\}`;
+              .map((child) => parse(child))
+              .join("");
+            return `\\left\\{${innerContent}\\right\\}`;
           }
 
           // Bỏ qua nếu firstOp là rỗng (trường hợp <mo></mo>)
@@ -934,41 +1032,55 @@ function getRender(node) {
             return getRender_joinSeparator("@content")(node, childrenArray);
           }
 
-          if (firstOp === '[' && lastOp === ']') {
+          if (firstOp === "[" && lastOp === "]") {
             const innerContent = childrenArray
               .slice(1, -1)
-              .map(child => parse(child))
-              .join('');
+              .map((child) => parse(child))
+              .join("");
             return `[${innerContent}]`;
           }
 
           // Xử lý đặc biệt cho dấu ngoặc vuông chứa mtable
-          if (firstOp === '[') {
+          if (firstOp === "[") {
             const innerContent = childrenArray
               .slice(1, -1) // Bỏ dấu ngoặc mở và đóng
-              .map(child => {
+              .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}`;
+                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 => {
+                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 rowChildren.map((cell) => parse(cell)).join("");
                   });
-                  return `\\begin{array}{l} ${rows.join(' \\\\ ')} \\end{array}`;
+                  return `\\begin{array}{l} ${rows.join(
+                    " \\\\ "
+                  )} \\end{array}`;
                 }
                 return parsed;
               })
-              .join('');
+              .join("");
 
             // Giữ nguyên dấu ngoặc vuông lớn
             return `\\left[${innerContent}\\right.`;
@@ -977,36 +1089,41 @@ function getRender(node) {
           if (Brackets.isPair(firstOp, lastOp)) {
             const innerContent = childrenArray
               .slice(1, -1)
-              .map(child => parse(child))
-              .join('');
+              .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 === '}') {
+          if (firstOp === "{" || lastOp === "}") {
             const innerContent = childrenArray
-              .slice(1, lastOp === '}' ? -1 : undefined)
-              .map(child => parse(child))
-              .join('');
-            return `${firstOp === '{' ? '\\{' : ''}${innerContent}${lastOp === '}' ? '\\}' : ''}`;
+              .slice(1, lastOp === "}" ? -1 : undefined)
+              .map((child) => parse(child))
+              .join("");
+            return `${firstOp === "{" ? "\\{" : ""}${innerContent}${
+              lastOp === "}" ? "\\}" : ""
+            }`;
           }
         }
         return getRender_joinSeparator("@content")(node, childrenArray);
       };
       break;
 
-    case 'msub':
+    case "msub":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        if (!childrenArray || childrenArray.length < 2) return '';
-        const base = parse(childrenArray[0]) || '';
+        if (!childrenArray || childrenArray.length < 2) return "";
+        const base = parse(childrenArray[0]) || "";
         const sub = childrenArray[1];
         if (!sub) return base;
 
-        if (NodeTool.getNodeName(sub) === 'msub' &&
+        if (
+          NodeTool.getNodeName(sub) === "msub" &&
           sub.firstChild &&
-          NodeTool.getNodeName(sub.firstChild) === 'mrow' &&
-          (!NodeTool.getNodeText(sub.firstChild) || NodeTool.getNodeText(sub.firstChild).trim() === '')) {
+          NodeTool.getNodeName(sub.firstChild) === "mrow" &&
+          (!NodeTool.getNodeText(sub.firstChild) ||
+            NodeTool.getNodeText(sub.firstChild).trim() === "")
+        ) {
           const lastChild = sub.lastChild;
           return lastChild ? `${base}_${parse(lastChild)}` : base;
         }
@@ -1014,52 +1131,57 @@ function getRender(node) {
       };
       break;
 
-    case 'msup':
+    case "msup":
       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]) || '';
+        if (!childrenArray || childrenArray.length < 2) return "";
+        const base = parse(childrenArray[0]) || "";
+        const sup = parse(childrenArray[1]) || "";
         return `${base}^{${sup}}`;
       };
       break;
 
-    case 'msubsup':
+    case "msubsup":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        if (!childrenArray || childrenArray.length < 3) return '';
+        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() === '|') {
+        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('');
+            .map((child) => parse(child))
+            .join("");
           return `\\left.${content}\\right|_{${sub}}^{${sup}}`;
         }
         return `${base}_{${sub}}^{${sup}}`;
       };
       break;
 
-    case 'mover':
+    case "mover":
       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() || '';
+        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";
 
         // Handle biology notation (double overline)
         if (overText === "¯") {
           const parentNode = node.parentNode;
           // Check if this is part of a double overline structure
-          if (NodeTool.getNodeName(parentNode) === 'mover' && 
-              NodeTool.getNodeText(parentNode.lastChild)?.trim() === '¯') {
+          if (
+            NodeTool.getNodeName(parentNode) === "mover" &&
+            NodeTool.getNodeText(parentNode.lastChild)?.trim() === "¯"
+          ) {
             return `\\overline{${base}}`;
           }
           return `\\overline{${base}}`;
@@ -1071,61 +1193,68 @@ function getRender(node) {
       };
       break;
 
-    case 'munder':
+    case "munder":
       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 (!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':
+    case "munderover":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        if (!childrenArray || childrenArray.length < 3) return '';
+        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();
 
         // Special handling for chemical reaction arrow
-        if (baseText === '→' && 
-            NodeTool.getNodeName(childrenArray[1]) === 'msup') {
+        if (
+          baseText === "→" &&
+          NodeTool.getNodeName(childrenArray[1]) === "msup"
+        ) {
           return `\\xrightarrow[${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}}`;
+        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':
+    case "mmultiscripts":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        if (!childrenArray || childrenArray.length < 1) return '';
+        if (!childrenArray || childrenArray.length < 1) return "";
         const base = parse(childrenArray[0]);
-        let prescripts = '';
-        let postscripts = '';
+        let prescripts = "";
+        let postscripts = "";
         let i = 1;
 
         while (i < childrenArray.length) {
-          if (NodeTool.getNodeName(childrenArray[i]) === 'mprescripts') {
+          if (NodeTool.getNodeName(childrenArray[i]) === "mprescripts") {
             i++;
             if (i + 1 < childrenArray.length) {
-              prescripts = `_{${parse(childrenArray[i])}}^{${parse(childrenArray[i + 1])}}`;
+              prescripts = `_{${parse(childrenArray[i])}}^{${parse(
+                childrenArray[i + 1]
+              )}}`;
               i += 2;
             }
           } else {
             if (i + 1 < childrenArray.length) {
-              postscripts += `_{${parse(childrenArray[i])}}^{${parse(childrenArray[i + 1])}}`;
+              postscripts += `_{${parse(childrenArray[i])}}^{${parse(
+                childrenArray[i + 1]
+              )}}`;
               i += 2;
             } else break;
           }
@@ -1134,33 +1263,35 @@ function getRender(node) {
       };
       break;
 
-    case 'mlongdiv':
+    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])}}`;
+        if (!childrenArray || childrenArray.length < 2) return "";
+        return `\\longdiv{${parse(childrenArray[0])}}{${parse(
+          childrenArray[1]
+        )}}`;
       };
       break;
 
-    case 'mroot':
+    case "mroot":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        if (!childrenArray || childrenArray.length < 2) return '';
+        if (!childrenArray || childrenArray.length < 2) return "";
         const base = parse(childrenArray[0]);
         const index = parse(childrenArray[1]);
         return `\\sqrt[${index}]{${base}}`;
       };
       break;
 
-    case 'msqrt':
+    case "msqrt":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        const content = renderChildren(childrenArray).join('');
+        const content = renderChildren(childrenArray).join("");
         return `\\sqrt{${content}}`;
       };
       break;
 
-    case 'mtable':
+    case "mtable":
       render = function (node, children) {
         const childrenArray = Array.from(children);
 
@@ -1168,7 +1299,7 @@ function getRender(node) {
         let isNestedTable = false;
         let parent = node.parentNode;
         while (parent) {
-          if (NodeTool.getNodeName(parent) === 'mtable') {
+          if (NodeTool.getNodeName(parent) === "mtable") {
             isNestedTable = true;
             break;
           }
@@ -1176,25 +1307,27 @@ function getRender(node) {
         }
 
         // Xử lý mỗi mtr như một hàng
-        const rows = childrenArray.map(row => {
+        const rows = childrenArray.map((row) => {
           const rowChildren = Array.from(NodeTool.getChildren(row));
-          return rowChildren.map(cell => parse(cell)).join('');
+          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(' \\\\ ');
+          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') {
+          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() === '[') {
+            if (
+              childrenOfParent.length >= 2 &&
+              NodeTool.getNodeName(childrenOfParent[0]) === "mo" &&
+              NodeTool.getNodeText(childrenOfParent[0]).trim() === "["
+            ) {
               isInsideSquareBrackets = true;
               break;
             }
@@ -1203,151 +1336,166 @@ function getRender(node) {
         }
 
         if (isInsideSquareBrackets) {
-          return rows.join(' \\\\ ');
+          return rows.join(" \\\\ ");
         }
 
         // Nếu là mtable chính, bao bọc trong \begin{array}...\end{array}
-        const arrayContent = rows.join(' \\\\ ');
+        const arrayContent = rows.join(" \\\\ ");
         return `\\begin{array}{l} ${arrayContent} \\end{array}`;
       };
       break;
 
-    case 'mtr':
+    case "mtr":
       render = getRender_joinSeparator("@content", " & ");
       break;
 
-    case 'mtd':
+    case "mtd":
       render = getRender_joinSeparator("@content");
       break;
 
-    case 'mfrac':
+    case "mfrac":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        if (!childrenArray || childrenArray.length < 2) return '';
+        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}}`;
+        const linethickness = NodeTool.getAttr(node, "linethickness", "medium");
+        if (linethickness === "0") return `\\binom{${num}}{${den}}`;
         return `\\frac{${num}}{${den}}`;
       };
       break;
 
-    case 'mfenced':
+    case "mfenced":
       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('');
+        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 trường hợp dấu ngoặc đơn |
-        if (open === '|') {
-          const content = childrenArray.map(child => {
-            const parsed = parse(child);
-            // Loại bỏ các dấu | thừa và các \left|, \right| không cần thiết
-            return parsed
-              .replace(/\\left\|/g, '')
-              .replace(/\\right\|/g, '')
-              .replace(/\\left\./g, '')
-              .replace(/\|/g, '');
-          }).join('');
-          
+        if (open === "|") {
+          const content = childrenArray
+            .map((child) => {
+              const parsed = parse(child);
+              // Loại bỏ các dấu | thừa và các \left|, \right| không cần thiết
+              return parsed
+                .replace(/\\left\|/g, "")
+                .replace(/\\right\|/g, "")
+                .replace(/\\left\./g, "")
+                .replace(/\|/g, "");
+            })
+            .join("");
+
           if (!close) {
             return `\\left|${content}\\right|`;
-          } else if (close === '|') {
+          } else if (close === "|") {
             return `\\left|${content}\\right|`;
           }
         }
 
         // Xử lý đặc biệt cho mfenced chứa mtable
-        if (open === '{' && !close) {
+        if (open === "{" && !close) {
           // Kiểm tra xem có phải là một phần của biểu thức mũ không
-          const hasMtable = childrenArray.some(child => {
+          const hasMtable = childrenArray.some((child) => {
             // Kiểm tra trực tiếp mtable
-            if (NodeTool.getNodeName(child) === 'mtable') return true;
+            if (NodeTool.getNodeName(child) === "mtable") return true;
             // Kiểm tra mtable trong mrow
-            if (NodeTool.getNodeName(child) === 'mrow') {
+            if (NodeTool.getNodeName(child) === "mrow") {
               return Array.from(NodeTool.getChildren(child)).some(
-                grandChild => NodeTool.getNodeName(grandChild) === 'mtable'
+                (grandChild) => NodeTool.getNodeName(grandChild) === "mtable"
               );
             }
             return false;
           });
 
           if (hasMtable) {
-            const content = childrenArray.map(child => parse(child)).join('');
+            const content = childrenArray.map((child) => parse(child)).join("");
             return `\\left\\{${content}\\right.`;
           }
         }
 
         // Xử lý cho trường hợp [a;b)
-        if (open === '[' && close === ')') {
+        if (open === "[" && close === ")") {
           const parts = [];
           childrenArray.forEach((child, index) => {
             parts.push(parse(child));
-            if (index < childrenArray.length - 1 && separators[index % separators.length]) {
+            if (
+              index < childrenArray.length - 1 &&
+              separators[index % separators.length]
+            ) {
               parts.push(separators[index % separators.length]);
             }
           });
-          return `\\left[${parts.join('')}\\right)`;
+          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]) {
+          if (
+            index < childrenArray.length - 1 &&
+            separators[index % separators.length]
+          ) {
             parts.push(separators[index % separators.length]);
           }
         });
-        const content = parts.join('');
+        const content = parts.join("");
 
-        if (open === '{' && close === '}') return `\\{${content}\\}`;
-        if (open === '|' && close === '|') return `\\left|${content}\\right|`;
+        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}`;
       };
       break;
 
-    case 'menclose':
+    case "menclose":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        const notation = NodeTool.getAttr(node, 'notation', 'longdiv');
-        const content = renderChildren(childrenArray).join('');
+        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;
+          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':
+    case "mi":
+    case "mn":
+    case "mo":
+    case "ms":
+    case "mtext":
       render = getRender_joinSeparator("@content");
       break;
 
-    case 'mphantom':
+    case "mphantom":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        const content = renderChildren(childrenArray).join('');
+        const content = renderChildren(childrenArray).join("");
         return `\\phantom{${content}}`;
       };
       break;
 
-    case 'mstyle':
+    case "mstyle":
       render = function (node, children) {
         const childrenArray = Array.from(children);
-        const mathsize = NodeTool.getAttr(node, 'mathsize', 'normal');
-        const content = renderChildren(childrenArray).join('');
+        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;
+          case "big":
+            return `\\large{${content}}`;
+          case "small":
+            return `\\small{${content}}`;
+          default:
+            return content;
         }
       };
       break;
@@ -1361,7 +1509,7 @@ function getRender(node) {
 
 // Export the convert function
 var mathml2latex = {
-  convert: convert
+  convert: convert,
 };
 
 export default mathml2latex;