ed-mathml2tex 0.0.1

package/lib/mathml2latex.browser.umd.js

@@ -0,0 +1,1033 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = global || self, global.MathML2LaTeX = factory());
+}(this, (function () { 'use strict';
+
+  const Brackets = {
+    left: ['(', '[', '{', '|', '‖', '⟨', '⌊', '⌈', '⌜'],
+    right: [')', ']', '}', '|', '‖', '⟩', '⌋', '⌉', '⌝'],
+    isPair: function(l, r){
+      const idx = this.left.indexOf(l);
+      return r === this.right[idx];
+    },
+    contains: function(it) {
+      return this.isLeft(it) || this.isRight(it);
+    },
+    isLeft: function(it) {
+      return this.left.indexOf(it) > -1
+    },
+    isRight: function(it) {
+      return this.right.indexOf(it) > -1;
+    },
+    parseLeft: function(it, stretchy = true) {
+      if(this.left.indexOf(it) < 0){ return it}
+      let r = '';
+      switch(it){
+        case '(':
+        case '[':
+        case '|': r = `\\left${it}`;
+          break;
+        case '‖': r = '\\left\\|';
+          break;
+        case '{': r = '\\left\\{';
+          break;
+        case '⟨': r = '\\left\\langle ';
+          break;
+        case '⌊': r = '\\left\\lfloor ';
+          break;
+        case '⌈': r = '\\left\\lceil ';
+          break;
+        case '⌜': r = '\\left\\ulcorner ';
+          break;
+      }
+      return (stretchy ? r : r.replace('\\left', ''));
+    },
+
+    parseRight: function(it, stretchy = true) {
+      if(this.right.indexOf(it) < 0){ return it}
+      let r = '';
+      switch(it){
+        case ')':
+        case ']':
+        case '|': r = `\\right${it}`;
+          break;
+        case '‖': r = '\\right\\|';
+          break;
+        case '}': r = '\\right\\}';
+          break;
+        case '⟩': r = ' \\right\\rangle';
+          break;
+        case '⌋': r = ' \\right\\rfloor';
+          break;
+        case '⌉': r = ' \\right\\rceil';
+          break;
+        case '⌝': r = ' \\right\\urcorner';
+          break;
+      }
+      return (stretchy ? r : r.replace('\\right', ''));
+    }
+  };
+
+  /*
+   * Set up window for Node.js
+   */
+
+  const root = (typeof window !== 'undefined' ? window : {});
+
+  /*
+   * Parsing HTML strings
+   */
+
+  function canParseHTMLNatively () {
+    const Parser = root.DOMParser;
+    let canParse = false;
+
+    // Adapted from https://gist.github.com/1129031
+    // Firefox/Opera/IE throw errors on unsupported types
+    try {
+      // WebKit returns null on unsupported types
+      if (new Parser().parseFromString('', 'text/html')) {
+        canParse = true;
+      }
+    } catch (e) {}
+
+    return canParse
+  }
+
+  function createHTMLParser () {
+    const Parser = function () {};
+
+    if (typeof process !== 'undefined' && true) {
+      if (shouldUseActiveX()) {
+        Parser.prototype.parseFromString = function (string) {
+          const doc = new window.ActiveXObject('htmlfile');
+          doc.designMode = 'on'; // disable on-page scripts
+          doc.open();
+          doc.write(string);
+          doc.close();
+          return doc
+        };
+      } else {
+        Parser.prototype.parseFromString = function (string) {
+          const doc = document.implementation.createHTMLDocument('');
+          doc.open();
+          doc.write(string);
+          doc.close();
+          return doc
+        };
+      }
+    } else {
+      Parser.prototype.parseFromString = function (string) {
+        const doc = document.implementation.createHTMLDocument('');
+        doc.open();
+        doc.write(string);
+        doc.close();
+        return doc
+      };
+    }
+    return Parser
+  }
+
+  function shouldUseActiveX () {
+    let useActiveX = false;
+    try {
+      document.implementation.createHTMLDocument('').open();
+    } catch (e) {
+      if (window.ActiveXObject) useActiveX = true;
+    }
+    return useActiveX
+  }
+
+  const HTMLParser = canParseHTMLNatively() ? root.DOMParser : createHTMLParser();
+
+  const NodeTool = {
+    parseMath: function(html) {
+      const parser = new HTMLParser();
+      const doc = parser.parseFromString(html, 'text/html');
+      return doc.querySelector('math');
+    },
+    getChildren: function(node) {
+      return node.children;
+    },
+    getNodeName: function(node) {
+      return node.tagName.toLowerCase();
+    },
+    getNodeText: function(node) {
+      return node.textContent;
+    },
+    getAttr: function(node, attrName, defaultValue) {
+      const value = node.getAttribute(attrName);
+      if ( value === null) {
+        return defaultValue;
+      } else {
+        return value;
+      }
+    },
+    getPrevNode: function(node) {
+      return node.previousElementSibling;
+    },
+    getNextNode: function(node) {
+      return node.nextElementSibling;
+    }
+  };
+
+  // @see https://en.wikibooks.org/wiki/LaTeX/Mathematics#List_of_mathematical_symbols
+  // @see https://www.andy-roberts.net/res/writing/latex/symbols.pdf   (more completed)
+  // @see http://www.rpi.edu/dept/arc/training/latex/LaTeX_symbols.pdf (wtf)
+  // https://oeis.org/wiki/List_of_LaTeX_mathematical_symbols
+
+  // accessed directly from keyboard
+  // + - = ! / ( ) [ ] < > | ' : *
+
+  const MathSymbol = {
+    parseIdentifier: function(it) {
+      if(it.length === 0){ return '' }
+      if(it.length === 1){
+        const charCode = it.charCodeAt(0);
+        // First check special math sets
+        let index = this.mathSets.decimals.indexOf(charCode);
+        if (index > -1) {
+          return this.mathSets.scripts[index] + ' ';
+        }
+        // Then check greek letters
+        index = this.greekLetter.decimals.indexOf(charCode);
+        if (index > -1) {
+          return this.greekLetter.scripts[index] + ' ';
+        }
+        return it;
+      } else {
+        return this.parseMathFunction(it);
+      }
+    },
+
+    parseOperator: function(it) {
+      if(it.length === 0){ return ''}
+      // Handle backslash operator
+      if(it === '\\'){ return '\\setminus '}
+      if(it.length === 1){
+        const charCode = it.charCodeAt(0);
+        // First check special operators
+        let index = this.specialOperators.decimals.indexOf(charCode);
+        if (index > -1) {
+          return this.specialOperators.scripts[index] + ' ';
+        }
+
+        const opSymbols = [
+          this.bigCommand,
+          this.relation,
+          this.binaryOperation,
+          this.setAndLogic,
+          this.delimiter,
+          this.other
+        ];
+
+        const padSpaceBothSide = [false, true, true, false, false, false];
+
+        for(let i = 0; i < opSymbols.length; i++){
+          const opSymbol = opSymbols[i];
+          const index = opSymbol.decimals.indexOf(charCode);
+          if(index > -1) {
+            if(padSpaceBothSide[i]){
+              return [' ', opSymbol.scripts[index], ' '].join('');
+            }else {
+              return opSymbol.scripts[index] + ' ';
+            }
+          }
+        }
+        return it;
+      } else {
+        return this.parseMathFunction(it);
+      }
+    },
+
+    parseMathFunction: function (it) {
+      const marker = T.createMarker();
+      const replacements = [];
+      this.mathFunction.names.forEach((name, index) => {
+        const regExp = new RegExp(name, 'g');
+        if(it.match(regExp)){
+          replacements.push(this.mathFunction.scripts[index]);
+          it = it.replace(regExp, marker.next() + ' ');
+        }
+      });
+      return marker.replaceBack(it, replacements);
+    },
+
+    //FIXME COMPLETE ME
+    overScript: {
+      decimals: [9182, 8594],
+      templates: [
+        "\\overbrace{@v}",
+        "\\vec{@v}"
+      ]
+    },
+
+    //FIXME COMPLETE ME
+    underScript: {
+      decimals: [9183],
+      templates: [
+        "\\underbrace{@v}"
+      ]
+    },
+
+    // sum, integral...
+    bigCommand: {
+      decimals: [8721, 8719, 8720, 10753, 10754, 10752, 8899, 8898, 10756, 10758, 8897, 8896, 8747, 8750, 8748, 8749, 10764, 8747],
+      scripts: [
+        "\\sum",
+        "\\prod",
+        "\\coprod",
+        "\\bigoplus",
+        "\\bigotimes",
+        "\\bigodot",
+        "\\bigcup",
+        "\\bigcap",
+        "\\biguplus",
+        "\\bigsqcup",
+        "\\bigvee",
+        "\\bigwedge",
+        "\\int",
+        "\\oint",
+        "\\iint",
+        "\\iiint",
+        "\\iiiint",
+        "\\idotsint",
+      ]
+    },
+
+    // mo
+    relation: {
+      decimals: [60, 62, 61, 8741, 8742, 8804, 8805, 8784, 8781, 8904, 8810, 8811, 8801, 8866, 8867, 8834, 8835, 8776, 8712, 8715, 8838, 8839, 8773, 8995, 8994, 8840, 8841, 8771, 8872, 8713, 8847, 8848, 126, 8764, 8869, 8739, 8849, 8850, 8733, 8826, 8827, 10927, 10928, 8800, 8738, 8737],
+      scripts: [
+        "<",
+        ">",
+        "=",
+        "\\parallel",
+        "\\nparallel",
+        "\\leq",
+        "\\geq",
+        "\\doteq",
+        "\\asymp",
+        "\\bowtie",
+        "\\ll",
+        "\\gg",
+        "\\equiv",
+        "\\vdash",
+        "\\dashv",
+        "\\subset",
+        "\\supset",
+        "\\approx",
+        "\\in",
+        "\\ni",
+        "\\subseteq",
+        "\\supseteq",
+        "\\cong",
+        "\\smile",
+        "\\frown",
+        "\\nsubseteq",
+        "\\nsupseteq",
+        "\\simeq",
+        "\\models",
+        "\\notin",
+        "\\sqsubset",
+        "\\sqsupset",
+        "\\sim",
+        "\\sim",
+        "\\perp",
+        "\\mid",
+        "\\sqsubseteq",
+        "\\sqsupseteq",
+        "\\propto",
+        "\\prec",
+        "\\succ",
+        "\\preceq",
+        "\\succeq",
+        "\\neq",
+        "\\sphericalangle",
+        "\\measuredangle"
+          ]
+    },
+
+    // complete
+    binaryOperation: {
+      decimals: [43, 45, 177, 8745, 8900, 8853, 8723, 8746, 9651, 8854, 215, 8846, 9661, 8855, 247, 8851, 9667, 8856, 8727, 8852, 9657, 8857, 8902, 8744, 9711, 8728, 8224, 8743, 8729, 8726, 8225, 8901, 8768, 10815],
+      scripts: [
+        "+",
+        "-",
+        "\\pm",
+        "\\cap",
+        "\\diamond",
+        "\\oplus",
+        "\\mp",
+        "\\cup",
+        "\\bigtriangleup",
+        "\\ominus",
+        "\\times",
+        "\\uplus",
+        "\\bigtriangledown",
+        "\\otimes",
+        "\\div",
+        "\\sqcap",
+        "\\triangleleft",
+        "\\oslash",
+        "\\ast",
+        "\\sqcup",
+        "\\triangleright",
+        "\\odot",
+        "\\star",
+        "\\vee",
+        "\\bigcirc",
+        "\\circ",
+        "\\dagger",
+        "\\wedge",
+        "\\bullet",
+        "\\setminus",
+        "\\ddagger",
+        "\\cdot",
+        "\\wr",
+        "\\amalg"
+          ]
+    },
+
+    setAndLogic: {
+      decimals: [8707, 8594, 8594, 8708, 8592, 8592, 8704, 8614, 172, 10233, 8834, 8658, 10233, 8835, 8596, 8712, 10234, 8713, 8660, 8715, 8868, 8743, 8869, 8744, 8709, 8709],
+      scripts: [
+        "\\exists",
+        "\\rightarrow",
+        "\\to",
+        "\\nexists",
+        "\\leftarrow",
+        "\\gets",
+        "\\forall",
+        "\\mapsto",
+        "\\neg",
+        "\\implies",
+        "\\subset",
+        "\\Rightarrow",
+        "\\implies",
+        "\\supset",
+        "\\leftrightarrow",
+        "\\in",
+        "\\iff",
+        "\\notin",
+        "\\Leftrightarrow",
+        "\\ni",
+        "\\top",
+        "\\land",
+        "\\bot",
+        "\\lor",
+        "\\emptyset",
+        "\\varnothing"
+          ]
+    },
+
+    delimiter: {
+      decimals: [124, 8739, 8214, 47, 8726, 123, 125, 10216, 10217, 8593, 8657, 8968, 8969, 8595, 8659, 8970, 8971],
+      scripts: [
+        "|",
+        "\\mid",
+        "\\|",
+        "/",
+        "\\backslash",
+        "\\{",
+        "\\}",
+        "\\langle",
+        "\\rangle",
+        "\\uparrow",
+        "\\Uparrow",
+        "\\lceil",
+        "\\rceil",
+        "\\downarrow",
+        "\\Downarrow",
+        "\\lfloor",
+        "\\rfloor"
+      ]
+    },
+
+    greekLetter: {
+      decimals: [ 913, 945, 925, 957, 914, 946, 926, 958, 915, 947, 927, 959, 916, 948, 928, 960, 982, 917, 1013, 949, 929, 961, 1009, 918, 950, 931, 963, 962, 919, 951, 932, 964, 920, 952, 977, 933, 965, 921, 953, 934, 981, 966, 922, 954, 1008, 935, 967, 923, 955, 936, 968, 924, 956, 937, 969 ],
+      scripts: [
+        "A"         , "\\alpha"   ,
+        "N"         , "\\nu"      ,
+        "B"         , "\\beta"    ,
+        "\\Xi"      , "\\xi"      ,
+        "\\Gamma"   , "\\gamma"   ,
+        "O"         , "o"         ,
+        "\\Delta"   , "\\delta"   ,
+        "\\Pi"      , "\\pi"      , "\\varpi"      ,
+        "E"         , "\\epsilon" , "\\varepsilon" ,
+        "P"         , "\\rho"     , "\\varrho"     ,
+        "Z"         , "\\zeta"    ,
+        "\\Sigma"   , "\\sigma"   , "\\varsigma"   ,
+        "H"         , "\\eta"     ,
+        "T"         , "\\tau"     ,
+        "\\Theta"   , "\\theta"   , "\\vartheta"   ,
+        "\\Upsilon" , "\\upsilon" ,
+        "I"         , "\\iota"    ,
+        "\\Phi"     , "\\phi"     , "\\varphi"     ,
+        "K"         , "\\kappa"   , "\\varkappa"   ,
+        "X"         , "\\chi"     ,
+        "\\Lambda"  , "\\lambda"  ,
+        "\\Psi"     , "\\psi"     ,
+        "M"         , "\\mu"      ,
+        "\\Omega"   , "\\omega"
+          ]
+    },
+
+    other: {
+      decimals: [8706, 305, 8476, 8711, 8501, 240, 567, 8465, 9723, 8502, 8463, 8467, 8472, 8734, 8503],
+      scripts: [
+        "\\partial",
+        "\\imath",
+        "\\Re",
+        "\\nabla",
+        "\\aleph",
+        "\\eth",
+        "\\jmath",
+        "\\Im",
+        "\\Box",
+        "\\beth",
+        "\\hbar",
+        "\\ell",
+        "\\wp",
+        "\\infty",
+        "\\gimel"
+      ]
+    },
+
+    // complete
+    // Be careful, the order of these name matters (overlap situation).
+    mathFunction: {
+
+      names: [
+        "arcsin" , "sinh"   , "sin" , "sec" ,
+        "arccos" , "cosh"   , "cos" , "csc" ,
+        "arctan" , "tanh"   , "tan" ,
+        "arccot" , "coth"   , "cot" ,
+
+        "limsup" , "liminf" , "exp" , "ker" ,
+        "deg"    , "gcd"    , "lg"  , "ln"  ,
+        "Pr"     , "sup"    , "det" , "hom" ,
+        "lim"    , "log"    , "arg" , "dim" ,
+        "inf"    , "max"    , "min" ,
+      ],
+      scripts: [
+        "\\arcsin" , "\\sinh"   , "\\sin" , "\\sec" ,
+        "\\arccos" , "\\cosh"   , "\\cos" , "\\csc" ,
+        "\\arctan" , "\\tanh"   , "\\tan" ,
+        "\\arccot" , "\\coth"   , "\\cot" ,
+
+        "\\limsup" , "\\liminf" , "\\exp" , "\\ker" ,
+        "\\deg"    , "\\gcd"    , "\\lg"  , "\\ln"  ,
+        "\\Pr"     , "\\sup"    , "\\det" , "\\hom" ,
+        "\\lim"    , "\\log"    , "\\arg" , "\\dim" ,
+        "\\inf"    , "\\max"    , "\\min" ,
+      ]
+    },
+
+    // Add special operators section
+    specialOperators: {
+      decimals: [
+        8712,  // ∈
+        8713,  // ∉
+        8746,  // ∪
+        8745,  // ∩
+        92,    // \
+      ],
+      scripts: [
+        "\\in",
+        "\\notin",
+        "\\cup",
+        "\\cap",
+        "\\setminus"
+      ]
+    },
+
+    // Update mathSets section
+    mathSets: {
+      decimals: [
+        8477,  // ℝ
+        8484,  // ℤ
+        8469,  // ℕ
+        8474,  // ℚ
+        8450,  // ℂ
+        8709,  // ∅
+        8734   // ∞
+      ],
+      scripts: [
+        "\\mathbb{R}",
+        "\\mathbb{Z}",
+        "\\mathbb{N}",
+        "\\mathbb{Q}",
+        "\\mathbb{C}",
+        "\\emptyset",
+        "\\infty"
+      ]
+    }
+  };
+
+  const T = {}; // Tool
+  T.createMarker = function() {
+    return {
+      idx: -1,
+      reReplace: /@\[\[(\d+)\]\]/mg,
+      next: function() {
+        return `@[[${++this.idx}]]`
+      },
+      replaceBack: function(str, replacements) {
+        return str.replace(this.reReplace, (match, p1) => {
+          const index = parseInt(p1);
+          return replacements[index];
+        });
+      }
+    }
+  };
+
+  function convert(mathmlHtml){
+    const math = NodeTool.parseMath(mathmlHtml);
+    return toLatex(parse(math));
+  }
+
+  function toLatex(result) {
+    // 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, '');
+    return result;
+  }
+
+  function parse(node) {
+    const children = NodeTool.getChildren(node);
+    if (!children || children.length === 0) {
+      return parseLeaf(node);
+    } else {
+      return parseContainer(node, children);
+    }
+  }
+
+  // @see https://www.w3.org/TR/MathML3/chapter7.html
+  function parseLeaf(node) {
+    let r = '';
+    const nodeName = NodeTool.getNodeName(node);
+    switch(nodeName){
+      case 'mi': r = parseElementMi(node);
+        break;
+      case 'mn': r = parseElementMn(node);
+        break;
+      case 'mo': r = parseOperator(node);
+        break;
+      case 'ms': r = parseElementMs(node);
+        break;
+      case 'mtext': r = parseElementMtext(node);
+        break;
+      case 'mglyph': r = parseElementMglyph(node);
+        break;
+      case 'mprescripts': r = '';
+        break;
+      case 'mspace': r = parseElementMspace();
+      case 'none': r = '\\:';
+      //TODO other usecase of 'none' ?
+        break;
+      default: r = escapeSpecialChars(NodeTool.getNodeText(node).trim());
+        break;
+    }
+    return r;
+  }
+
+  // operator token, mathematical operators
+  function parseOperator(node) {
+    let it = NodeTool.getNodeText(node).trim();
+    it = MathSymbol.parseOperator(it);
+    return escapeSpecialChars(it);
+  }
+
+  // Math identifier
+  function parseElementMi(node){
+    let it = NodeTool.getNodeText(node).trim();
+    it = MathSymbol.parseIdentifier(it);
+    return escapeSpecialChars(it);
+  }
+
+  // Math Number
+  function parseElementMn(node){
+    let it = NodeTool.getNodeText(node).trim();
+    return escapeSpecialChars(it);
+  }
+
+  // Math String
+  function parseElementMs(node){
+    const content = NodeTool.getNodeText(node).trimRight();
+    const it = escapeSpecialChars(content);
+    return ['"', it, '"'].join('');
+  }
+
+  // Math Text
+  function parseElementMtext(node){
+    const content = NodeTool.getNodeText(node);
+    const it = escapeSpecialChars(content);
+    return `\\text{${it}}`;
+  }
+
+  // Math glyph (image)
+  function parseElementMglyph(node){
+    const it = ['"', NodeTool.getAttr(node, 'alt', ''), '"'].join('');
+    return escapeSpecialChars(it);
+  }
+
+  // TODO need or not
+  function parseElementMspace(node){
+    return '';
+  }
+
+  function escapeSpecialChars(text) {
+    const specialChars = /\$|%|_|&|#|\{|\}/g;
+    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)}`);
+    }
+  }
+
+  function renderChildren(children) {
+    const parts = [];
+    let lefts = [];
+    Array.prototype.forEach.call(children, (node) => {
+      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;
+          // 操作符是括號
+          if(Brackets.isRight(op)){
+            const nearLeft = lefts[lefts.length - 1];
+            if(nearLeft){
+              if(Brackets.isPair(nearLeft, op)){
+                parts.push(Brackets.parseRight(op, stretchy));
+                lefts.pop();
+              } else {
+                // some brackets left side is same as right side.
+                if(Brackets.isLeft(op)) {
+                  parts.push(Brackets.parseLeft(op, stretchy));
+                  lefts.push(op);
+                } else {
+                  console.error("bracket not match");
+                }
+              }
+            }else {
+              // some brackets left side is same as right side.
+              if(Brackets.isLeft(op)) {
+                parts.push(Brackets.parseLeft(op, stretchy));
+                lefts.push(op);
+              }else {
+                console.error("bracket not match");
+              }
+            }
+          } else {
+            parts.push(Brackets.parseLeft(op, stretchy));
+            lefts.push(op);
+          }
+        } else {
+          parts.push(parseOperator(node));
+        }
+      } else {
+        parts.push(parse(node));
+      }
+    });
+    // 這裏非常不嚴謹
+    if(lefts.length > 0){
+      for(let i=0; i < lefts.length; i++){
+        parts.push("\\right.");
+      }
+    }
+    lefts = undefined;
+    return parts;
+  }
+
+
+  function getRender(node) {
+    let render = undefined;
+    const nodeName = NodeTool.getNodeName(node);
+    switch(nodeName){
+      case 'msub':
+        render = getRender_default("@1_{@2}");
+        break;
+      case 'msup':
+        render = getRender_default("@1^{@2}");
+        break;
+      case 'msubsup':
+        render = getRender_default("@1_{@2}^{@3}");
+        break;
+      case 'mover':
+        render = renderMover;
+        break;
+      case 'munder':
+        render = renderMunder;
+        break;
+      case 'munderover':
+        render = getRender_default("@1\\limits_{@2}^{@3}");
+        break;
+      case 'mmultiscripts':
+        render = renderMmultiscripts;
+        break;
+      case 'mroot':
+        render = getRender_default("\\sqrt[@2]{@1}");
+        break;
+      case 'msqrt':
+        render = getRender_joinSeparator("\\sqrt{@content}");
+        break;
+      case 'mtable':
+        render = renderTable;
+        break;
+      case 'mtr':
+        render = getRender_joinSeparator("@content \\\\ ", ' & ');
+        break;
+      case 'mtd':
+        render = getRender_joinSeparator("@content");
+        break;
+      case 'mfrac':
+        render = renderMfrac;
+        break;
+      case 'mfenced':
+        render = renderMfenced;
+        break;
+      case 'mi':
+      case 'mn':
+      case 'mo':
+      case 'ms':
+      case 'mtext':
+        // they may contains <mglyph>
+        render = getRender_joinSeparator("@content");
+        break;
+      case 'mphantom':
+        render = renderMphantom;
+        break;
+      default:
+        // math, mstyle, mrow
+        render = getRender_joinSeparator("@content");
+        break;
+    }
+    return render;
+  }
+
+  function renderTable(node, children) {
+    const template = "\\begin{matrix} @content \\end{matrix}";
+    const render = getRender_joinSeparator(template);
+    return render(node, children);
+  }
+
+  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("\\DELETE_BRACKET_L\\binom{@1}{@2}\\DELETE_BRACKET_R");
+      } else {
+        render = getRender_default("{}_{@2}^{@1}");
+      }
+    } else {
+      render = getRender_default("\\frac{@1}{@2}");
+    }
+    return render(node, children);
+  }
+
+  function renderMfenced(node, children){
+    const [open, close, separatorsStr] = [
+      NodeTool.getAttr(node, 'open', '('),
+      NodeTool.getAttr(node, 'close', ')'),
+      NodeTool.getAttr(node, 'separators', ',')
+    ];
+    const [left, right] = [
+      Brackets.parseLeft(open),
+      Brackets.parseRight(close)
+    ];
+
+    const separators = separatorsStr.split('').filter((c) => c.trim().length === 1);
+    const template = `${left}@content${right}`;
+    const render = getRender_joinSeparators(template, separators);
+    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 renderMover(node, children){
+    const nodes = flattenNodeTreeByNodeName(node, 'mover');
+    let result = undefined;
+    for(let i = 0; i < nodes.length - 1; i++) {
+      if(!result){ result = parse(nodes[i]); }
+      const over = parse(nodes[i + 1]);
+      const template = getMatchValueByChar({
+        decimals: MathSymbol.overScript.decimals,
+        values: MathSymbol.overScript.templates,
+        judgeChar: over,
+        defaultValue: "@1^{@2}"
+      });
+      result = renderTemplate(template.replace("@v", "@1"), [result, over]);
+    }
+    return result;
+  }
+
+  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 under = parse(nodes[i + 1]);
+      const template = getMatchValueByChar({
+        decimals: MathSymbol.underScript.decimals,
+        values: MathSymbol.underScript.templates,
+        judgeChar: under,
+        defaultValue: "@1\\limits_{@2}"
+      });
+      result =  renderTemplate(template.replace("@v", "@1"), [result, under]);
+    }
+    return result;
+  }
+
+  function flattenNodeTreeByNodeName(root, nodeName) {
+    let result = [];
+    const children = NodeTool.getChildren(root);
+    Array.prototype.forEach.call(children, (node) => {
+      if (NodeTool.getNodeName(node) === nodeName) {
+        result = result.concat(flattenNodeTreeByNodeName(node, nodeName));
+      } else {
+        result.push(node);
+      }
+    });
+    return result;
+  }
+
+
+  function getMatchValueByChar(params) {
+    const {decimals, values, judgeChar, defaultValue=null} = params;
+    if (judgeChar && judgeChar.length === 1) {
+      const index = decimals.indexOf(judgeChar.charCodeAt(0));
+      if (index > -1) {
+        return values[index];
+      }
+    }
+    return defaultValue;
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/MathML/Element/mphantom
+  // FIXME :)
+  function renderMphantom(node, children) {
+      return '';
+  }
+
+
+
+  function getRender_default(template) {
+    return function(node, children) {
+      const parts = renderChildren(children);
+      return renderTemplate(template, parts)
+    }
+  }
+
+  function renderTemplate(template, values) {
+    return template.replace(/\@\d+/g, (m) => {
+      const idx = parseInt(m.substring(1, m.length)) - 1;
+      return values[idx];
+    });
+  }
+
+  function getRender_joinSeparator(template, separator = '') {
+    return function(node, children) {
+      const parts = renderChildren(children);
+      return template.replace("@content", parts.join(separator));
+    }
+  }
+
+  function getRender_joinSeparators(template, separators) {
+    return function(node, children) {
+      const parts = renderChildren(children);
+      let content = '';
+      if(separators.length === 0){
+        content = parts.join('');
+      } else {
+        content =  parts.reduce((accumulator, part, index) => {
+          accumulator += part;
+          if(index < parts.length - 1){
+            accumulator += (separators[index] || separators[separators.length - 1]);
+          }
+          return accumulator;
+        }, '');
+      }
+      return template.replace("@content", content);
+    }
+  }
+
+  // Add exports at the end of file
+  var mathml2latex = {
+    convert: convert
+  };
+
+  return mathml2latex;
+
+})));