ed-mathml2tex 0.0.1

package/lib/mathml2latex.es.js

@@ -0,0 +1,1025 @@
+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' && false) {
+    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
+};
+
+export default mathml2latex;