ed-mathml2tex 0.1.6 → 0.1.7

package/lib/mathml2latex.browser.umd.js

@@ -588,10 +588,10 @@
     }
   };
 
-  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));
     };
   }
 
@@ -603,9 +603,11 @@
     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}";
       }
@@ -614,38 +616,71 @@
     // 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
@@ -673,7 +708,7 @@
   // @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() === "") {
@@ -681,32 +716,32 @@
     }
 
     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());
@@ -715,10 +750,10 @@
     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 ",
@@ -737,12 +772,14 @@
       ">": " > ",
       "=": " = ",
       ",": ", ", // 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) {
@@ -750,7 +787,7 @@
 
     // 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₂)
@@ -774,27 +811,41 @@
   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;
@@ -802,84 +853,124 @@
 
   // 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;
+
+          // Luôn escape dấu ngoặc nhọn cho LaTeX
+          let escapedOp = op;
+          if (op === "{" || op === "}") {
+            escapedOp = `\\${op}`;
+          }
 
           if (Brackets.isRight(op)) {
             const nearLeft = lefts[lefts.length - 1];
-            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();
+            if (nearLeft && Brackets.isPair(nearLeft, op)) {
+              const parentNode = node.parentNode;
+              const isInPower =
+                parentNode && NodeTool.getNodeName(parentNode) === "msup";
+
+              if (stretchy && !isInPower) {
+                parts.push(`\\right${escapedOp}`); // Dùng escapedOp
               } else {
-                parts.push(op);
+                parts.push(escapedOp); // Dùng escapedOp
               }
+              lefts.pop();
             } else {
-              parts.push(op);
+              parts.push(escapedOp); // Ngoặc phải không khớp
             }
           } 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}`); // Dùng escapedOp
             } else {
-              parts.push(op); // Chỉ thêm dấu ngoặc đơn giản
+              parts.push(escapedOp); // Dùng escapedOp
             }
-            lefts.push(op);
+            lefts.push(op); // Dùng `op` gốc để so sánh cặp
           }
         } else {
           parts.push(parseOperator(node));
@@ -888,7 +979,6 @@
         parts.push(parse(node));
       }
     });
-
     lefts = undefined;
     return parts;
   }
@@ -898,41 +988,49 @@
     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>)
@@ -940,41 +1038,55 @@
               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.`;
@@ -983,36 +1095,41 @@
             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;
           }
@@ -1020,52 +1137,57 @@
         };
         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}}`;
@@ -1077,61 +1199,68 @@
         };
         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;
             }
@@ -1140,33 +1269,35 @@
         };
         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);
 
@@ -1174,7 +1305,7 @@
           let isNestedTable = false;
           let parent = node.parentNode;
           while (parent) {
-            if (NodeTool.getNodeName(parent) === 'mtable') {
+            if (NodeTool.getNodeName(parent) === "mtable") {
               isNestedTable = true;
               break;
             }
@@ -1182,25 +1313,27 @@
           }
 
           // 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;
               }
@@ -1209,151 +1342,166 @@
           }
 
           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;
@@ -1367,7 +1515,7 @@
 
   // Export the convert function
   var mathml2latex = {
-    convert: convert
+    convert: convert,
   };
 
   return mathml2latex;