www

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE
commit 82dc8af1ae9a5724fdbf1f0dd45360221c3bc87a
parent c17c4e6dfa954bb0761bb10abaf9deaf56ad5f4e
Author: Christian Perfect <christianperfect@gmail.com>
Date:   Fri, 16 May 2014 14:15:53 +0100

content-mathml: make it compatible with IE8; code style fixes

Diffstat:

Munpacked/extensions/MathML/content-mathml.js | 2270+++++++++++++++++++++++++++++++++++++++++--------------------------------------


1 file changed, 1169 insertions(+), 1101 deletions(-)

diff --git a/unpacked/extensions/MathML/content-mathml.js b/unpacked/extensions/MathML/content-mathml.js
@@ -5,9 +5,9 @@
  *
  *  MathJax/extensions/MathML/content-mathml.js
  *
- *  This file implements an XSLT transform to convert Content-MathML to
+ *  This file provides methods to convert Content-MathML to
  *  Presentation MathML for processing by MathJax.  The transform is
- *  performed in a pre-filter for the MathML input jax, so that the
+ *  performed in a DOM filter for the MathML input jax, so that the
  *  Show Math As menu will still show the Original MathML as Content MathML,
  *  but the Presentation MathML can be obtained from the main MathML menu.
  *  
@@ -19,7 +19,7 @@
  *  
  *  in your configuration.
  *
- *  A portion of this file is taken from ctop.xsl which is
+ *  A portion of this file is taken from ctop.js which is
  *  Copyright (c) David Carlisle 2001, 2002, 2008, 2009, 2013,
  *  and is used by permission of David Carlisle, who has agreed to allow us
  *  to release it under the Apache2 license (see below).  That portion is
@@ -52,59 +52,103 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
    *
    */
 
+
+  var isMSIE = HUB.Browser.isMSIE;
+
+  if (isMSIE) {
+    document.namespaces.add("m","http://www.w3.org/1998/Math/MathML");
+  }
+
   var CONFIG = HUB.CombineConfig("MathML.content-mathml",{
-		// render `a+(-b)` as `a-b`?
-		collapsePlusMinus: true,
+    // render `a+(-b)` as `a-b`?
+    collapsePlusMinus: true,
 
-		/* mathvariant to use with corresponding <ci> type attribute */
-		cistyles: {
-			"vector": 'bold-italic',
-			"matrix": 'bold-upright'
-		},
+      /* mathvariant to use with corresponding <ci> type attribute */
+      cistyles: {
+        vector: 'bold-italic',
+      matrix: 'bold-upright'
+      },
 
-		/* Symbol names to translate to characters
-		 */
-		symbols: {
-			"gamma": '\u03B3'
-		}
+      /* Symbol names to translate to characters
+      */
+      symbols: {
+        gamma: '\u03B3'
+      }
 
-	});
+  });
 
   var CToP = {
     version: '2.4',
     settings: CONFIG,
 
     /* Transform the given <math> elements from Content MathML to Presentation MathML and replace the original elements
-     */
-    transformElements: function(elements){
-      for (var i = 0; i< elements.length;i++){
+    */
+    transformElements: function(elements) {
+      for (var i = 0, l = elements.length; i<l; i++ ) {
         var mathNode = CToP.transformElement(elements[i]);
         elements[i].parentNode.replaceChild(mathNode,elements[i]); 
       }
     },
-    
+
     /* Transform a Content MathML element into Presentation MathML, and return the new element
-     */
+    */
     transformElement: function(element) {
-      var mathNode = element.cloneNode(false);
-      for(var j=0;j<element.childNodes.length; j++ ) {
+      var mathNode = CToP.cloneNode(element);
+      for (var j = 0, l = element.childNodes.length; j<l; j++ ) {
         CToP.applyTransform(mathNode,element.childNodes[j],0);
       }
       return mathNode;
     },
 
+    getTextContent: function(element) {
+      return element.text !== undefined ? element.text : element.innerText !== undefined ? element.innerText : element.textContent;
+    },
+
+    setTextContent: function(element,textContent) {
+      for (var i = 0, l = element.childNodes.length; i<l; i++) {
+        if (element.childNodes[i].nodeType === 3) {
+          element.removeChild(element.childNodes[i]);
+          i--;
+          l--;
+        }
+      }
+      element.appendChild(document.createTextNode(textContent));
+    },
+
+    cloneNode: function(element,deep) {
+      var clone;
+      if (element.nodeType === 1) {
+        var clone = CToP.createElement(element.nodeName);
+        for (var i = 0, l = element.attributes.length; i<l; i++ ) {
+          clone.setAttribute(element.attributes[i].nodeName,element.attributes[i].nodeValue);
+        }
+        if (deep) {
+          for (var i = 0, l = element.childNodes.length; i<l; i++ ) {
+            var clonedChild = CToP.cloneNode(element.childNodes[i],true);
+            clone.appendChild(clonedChild);
+          }
+        }
+      } else if (element.nodeType === 3) {
+        clone = document.createTextNode(element.nodeValue);
+      }
+      return clone;
+    },
+
     /* Create an element with given name, belonging to the MathML namespace
-     */
+    */
     createElement: function(name) {
-      return document.createElementNS("http://www.w3.org/1998/Math/MathML",name);
+      var math = (isMSIE ? document.createElement("m:"+name) :
+          document.createElementNS("http://www.w3.org/1998/Math/MathML",name));
+      math.isMathJax = true;
+      return math;
     },
 
     /* Get node's children
-     */
+    */
     getChildren: function(node) {
-      var children=[];
-      for(var j=0;j<node.childNodes.length; j++ ) {
-        if(node.childNodes[j].nodeType==document.ELEMENT_NODE) {
+      var children = [];
+      for (var j = 0, l = node.childNodes.length; j<l; j++ ) {
+        if (node.childNodes[j].nodeType === 1) {
           children.push(node.childNodes[j]);
         }
       }
@@ -112,77 +156,77 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
     },
 
     /* Classify node's children as argumentss, variable bindings, or qualifiers
-     */
+    */
     classifyChildren: function(contentMMLNode) {
       var args = [], bvars = [], qualifiers = [];
-      for(var j=0;j<contentMMLNode.childNodes.length; j++ ) {
-        if(contentMMLNode.childNodes[j].nodeType==document.ELEMENT_NODE) {
-          var childNode = contentMMLNode.childNodes[j], name = childNode.localName;
-          if(name=='bvar'){
+      for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) {
+        if (contentMMLNode.childNodes[j].nodeType === 1) {
+          var childNode = contentMMLNode.childNodes[j], name = childNode.nodeName;
+          if (name === 'bvar') {
             bvars.push(childNode);
-          } else if(name=='condition'||
-              name=='degree'||
-              name=='momentabout'||
-              name=='logbase'||
-              name=='lowlimit'||
-              name=='uplimit'||
-              (name=='interval' && args.length<2)||
-              name=='domainofapplication') {
+          } else if (name === 'condition'||
+              name === 'degree'||
+              name === 'momentabout'||
+              name === 'logbase'||
+              name === 'lowlimit'||
+              name === 'uplimit'||
+              (name === 'interval' && args.length<2)||
+              name === 'domainofapplication') {
                 qualifiers.push(childNode);
-          } else {
-            args.push(childNode);
-          }
+              } else {
+                args.push(childNode);
+              }
         }
       }
       return {
         args:args, 
-        bvars:bvars, 
-        qualifiers:qualifiers
+          bvars:bvars, 
+          qualifiers:qualifiers
       };
     },
 
     /* Add an element with given name and text content
-     */
+    */
     appendToken: function(parentNode,name,textContent) {
       var element = CToP.createElement(name);
-      element.textContent = textContent;
+      element.appendChild(document.createTextNode(textContent));
       parentNode.appendChild(element);
       return element;
     },
 
     /* Transform a Content MathML node to Presentation MathML node(s), and attach it to the parent
-     */
+    */
     applyTransform: function(parentNode,contentMMLNode,precedence) {
-      if(!contentMMLNode) {
+      if (!contentMMLNode) {
         var merror = CToP.createElement('merror');
         CToP.appendToken(merror,'mtext','Missing child node');
         parentNode.appendChild(merror);
         return;
       }
-      if (contentMMLNode.nodeType==document.ELEMENT_NODE) {
-        if(CToP.tokens[contentMMLNode.localName]) {
-          CToP.tokens[contentMMLNode.localName](parentNode,contentMMLNode,precedence);
-        } else if (contentMMLNode.childNodes.length==0) {
-          CToP.appendToken(parentNode,'mi',contentMMLNode.localName);
+      if (contentMMLNode.nodeType === 1) {
+        if (CToP.tokens[contentMMLNode.nodeName]) {
+          CToP.tokens[contentMMLNode.nodeName](parentNode,contentMMLNode,precedence);
+        } else if (contentMMLNode.childNodes.length === 0) {
+          CToP.appendToken(parentNode,'mi',contentMMLNode.nodeName);
         } else {
-          var clonedChild = contentMMLNode.cloneNode(false);
+          var clonedChild = CToP.cloneNode(contentMMLNode);
           parentNode.appendChild(clonedChild);
-          for(var j=0;j<contentMMLNode.childNodes.length; j++ ) {
+          for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) {
             CToP.applyTransform(clonedChild,contentMMLNode.childNodes[j],precedence);
           }
         }
-      } else if (contentMMLNode.nodeType==document.TEXT_NODE) {
-        parentNode.appendChild(contentMMLNode.cloneNode(false));
+      } else if (contentMMLNode.nodeType === 3) {
+        parentNode.appendChild(CToP.cloneNode(contentMMLNode));
       }
     },
 
     /* Make an mfenced environment
-     */
+    */
     createmfenced: function(children,open,close) {
       var mf = CToP.createElement('mfenced');
       mf.setAttribute('open',open);
       mf.setAttribute('close',close);
-      for(var j=0;j<children.length; j++ ) {
+      for (var j = 0, l = children.length; j<l; j++ ) {
         CToP.applyTransform(mf,children[j],0);
       }
       return mf;
@@ -206,8 +250,8 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
           var children = CToP.classifyChildren(contentMMLNode);
 
           var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers;
-          if(bvars.length) {
-            var firstArg=children.args[0];
+          if (bvars.length) {
+            var firstArg = children.args[0];
             args = args.slice(1);
             var mfenced = CToP.createElement('mfenced');
             mfenced.setAttribute('open',open);
@@ -227,18 +271,18 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
        */
       token: function(name) {
         return function(parentNode,contentMMLNode) {
-          if(contentMMLNode.childNodes.length==1 && contentMMLNode.childNodes[0].nodeType==document.TEXT_NODE) {
-            CToP.appendToken(parentNode,name,contentMMLNode.textContent);
+          if (contentMMLNode.childNodes.length === 1 && contentMMLNode.childNodes[0].nodeType === 3) {
+            CToP.appendToken(parentNode,name,CToP.getTextContent(contentMMLNode));
           } else {
             var mrow = CToP.createElement('mrow');
-            for(var j=0;j<contentMMLNode.childNodes.length; j++ ) {
-              if (contentMMLNode.childNodes[j].nodeType==document.TEXT_NODE) {
-                CToP.appendToken(parentNode,name,contentMMLNode.childNodes[j].textContent);
+            for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) {
+              if (contentMMLNode.childNodes[j].nodeType === 3) {
+                CToP.appendToken(parentNode,name,CToP.getTextContent(contentMMLNode.childNodes[j]));
               }else{
                 CToP.applyTransform(mrow,contentMMLNode.childNodes[j],0);
               }
             }
-            if(mrow.childNodes.length) {
+            if (mrow.childNodes.length) {
               parentNode.appendChild(mrow);
             }
           }
@@ -252,19 +296,19 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
       binary: function(name,tokenPrecedence) {
         return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
           var mrow = CToP.createElement('mrow');
-          var needsBrackets = tokenPrecedence<precedence || (tokenPrecedence==precedence && name=="-");
-          if(needsBrackets) {
+          var needsBrackets = tokenPrecedence<precedence || (tokenPrecedence == precedence && name === "-");
+          if (needsBrackets) {
             CToP.appendToken(mrow,'mo','(');
           }
-          if(args.length>1){
+          if (args.length>1) {
             CToP.applyTransform(mrow,args[0],tokenPrecedence);
           }
           CToP.appendToken(mrow,'mo',name);
-          if(args.length>0){
-            var z = args[(args.length==1)?0:1];
+          if (args.length>0) {
+            var z = args[(args.length === 1)?0:1];
             CToP.applyTransform(mrow,z,tokenPrecedence);
           }	
-          if(needsBrackets) {
+          if (needsBrackets) {
             CToP.appendToken(mrow,'mo',')');
           }
           parentNode.appendChild(mrow);
@@ -279,16 +323,16 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
         return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
           var mrow = CToP.createElement('mrow');
           var needsBrackets = precedence>tokenPrecedence;
-          if(needsBrackets) {
+          if (needsBrackets) {
             CToP.appendToken(mrow,'mo','(');
           }
-          for(var j=0;j<args.length; j++ ) {
-            if(j>0) {
+          for (var j = 0, l = args.length; j<l; j++ ) {
+            if (j>0) {
               CToP.appendToken(mrow,'mo',name);
             }
             CToP.applyTransform(mrow,args[j],tokenPrecedence);
           }
-          if(needsBrackets) {
+          if (needsBrackets) {
             CToP.appendToken(mrow,'mo',')');
           }
           parentNode.appendChild(mrow);
@@ -303,42 +347,42 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
         return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
           var mrow = CToP.createElement('mrow');
           var mo = CToP.createElement('mo');
-          mo.textContent = name;
+          CToP.setTextContent(mo,name);
           var munderover = CToP.createElement('munderover');
           munderover.appendChild(mo);
           var mrow1 = CToP.createElement('mrow');
-          for(var i=0; i<qualifiers.length;i++){
-            if(qualifiers[i].localName=='lowlimit'||
-                qualifiers[i].localName=='condition'||
-                qualifiers[i].localName=='domainofapplication')
+          for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+            if (qualifiers[i].nodeName === 'lowlimit'||
+                qualifiers[i].nodeName === 'condition'||
+                qualifiers[i].nodeName === 'domainofapplication')
             {
-              if(qualifiers[i].localName=='lowlimit'){
-                for(var j=0; j<bvars.length;j++){
+              if (qualifiers[i].nodeName === 'lowlimit') {
+                for (var j = 0, num_bars = bvars.length; j<num_bvars; j++ ) {
                   var bvar = bvars[j];
                   var children = CToP.getChildren(bvar);
-                  if(children.length){
+                  if (children.length) {
                     CToP.applyTransform(mrow1,children[0],0);
                   }
                 }
-                if(bvars.length){
+                if (bvars.length) {
                   CToP.appendToken(mrow1,"mo",limitSymbol);
                 }
               }
               var children = CToP.getChildren(qualifiers[i]);
-              for(j=0;j<children.length;j++){
+              for (j = 0;j<children.length;j++) {
                 CToP.applyTransform(mrow1,children[j],0);
               }
             } else {
               var children = CToP.getChildren(qualifiers[i]);
-              if (qualifiers[i].localName=='interval' && children.length==2) {
-                for(var j=0; j<bvars.length;j++){
+              if (qualifiers[i].nodeName === 'interval' && children.length === 2) {
+                for (var j = 0, num_bvars = bvars.length; j<num_bvars; j++ ) {
                   var bvar = b[j];
                   var children = CToP.getChildren(bvar);
-                  if(children.length){
+                  if (children.length) {
                     CToP.applyTransform(mrow1,children[0],0);
                   }
                 }
-                if(bvars.length){
+                if (bvars.length) {
                   CToP.appendToken(mrow1,"mo","=");
                 }
                 CToP.applyTransform(mrow1,CToP.getChildren(qualifiers[i])[0],0);
@@ -347,11 +391,11 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
           }
           munderover.appendChild(mrow1);
           var mjrow = CToP.createElement('mrow');
-          for(var i=0; i<qualifiers.length;i++){
-            if(qualifiers[i].localName=='uplimit' ||qualifiers[i].localName=='interval' )
+          for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+            if (qualifiers[i].nodeName === 'uplimit' ||qualifiers[i].nodeName === 'interval' )
             {
               var children = CToP.getChildren(qualifiers[i]);
-              for(j=0;j<children.length;j++){
+              for (var j = 0, num_children = children.length; j<num_children; j++ ) {
                 CToP.applyTransform(mjrow,children[j],0);
               }
             }
@@ -359,7 +403,7 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
           munderover.appendChild(mjrow);
           mrow.appendChild(munderover);
 
-          for(var i=0; i<args.length;i++){
+          for (var i = 0, num_args = args.length; i<num_args; i++ ) {
             CToP.applyTransform(mrow,args[i],precedence);
           }
 
@@ -374,48 +418,48 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
       bind: function(name,argSeparator,conditionSeparator) {
         return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
           var mrow = CToP.createElement('mrow');
-          if(name) {
+          if (name) {
             CToP.appendToken(mrow,'mo',name);
           }
-          for(var j=0; j<bvars.length;j++){
+          for (var j = 0, l = bvars.length; j<l; j++ ) {
             var bvar = bvars[j];
-            if(j>0) {
+            if (j>0) {
               CToP.appendToken(mrow,'mo',',');
             }
             var children = CToP.getChildren(bvar);
-            if(children.length){
+            if (children.length) {
               CToP.applyTransform(mrow,children[0],0);
             }
           }
 
           var conditions_mrow = CToP.createElement('mrow');
           var conditions = false, children;
-          for(var i=0; i<qualifiers.length;i++){
-            if(qualifiers[i].localName=='condition')	{
+          for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+            if (qualifiers[i].nodeName === 'condition')	{
               conditions = true;
               children = CToP.getChildren(qualifiers[i]);
-              for(var j=0;j<children.length;j++){
+              for (var j = 0, num_children = children.length; j<num_children; j++ ) {
                 CToP.applyTransform(conditions_mrow,children[j],0);
               }
             }
           }
-          if(conditions){
+          if (conditions) {
             CToP.appendToken(mrow,'mo',conditionSeparator);
           }
           mrow.appendChild(conditions_mrow);
-          for(var i=0; i<qualifiers.length;i++){
-            if(qualifiers[i].localName!='condition')	{
+          for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+            if (qualifiers[i].nodeName != 'condition')	{
               CToP.appendToken(mrow,'mo','\u2208');
               children = CToP.getChildren(qualifiers[i]);
-              for(var j=0;j<children.length;j++){
+              for (var j = 0, num_children = children.length; j<num_children; j++ ) {
                 CToP.applyTransform(mrow,children[j],0);
               }
             }
           }
-          if(args.length && (bvars.length||children.length)) {
+          if (args.length && (bvars.length||children.length)) {
             CToP.appendToken(mrow,'mo',argSeparator);
           }
-          for(var i=0; i<args.length;i++){
+          for (var i = 0, l = args.length; i<l; i++ ) {
             CToP.applyTransform(mrow,args[i],0);
           }
           parentNode.appendChild(mrow);
@@ -431,7 +475,7 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
       fn: function(name) {
         return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
           var mrow = CToP.createElement('mrow');
-          if(firstArg.childNodes.length){
+          if (firstArg.childNodes.length) {
             CToP.applyTransform(mrow,firstArg,1);
           } else {
             CToP.appendToken(mrow,'mi',name);
@@ -452,15 +496,15 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
           CToP.appendToken(mrow,'mi',name);
           var mrow2 = CToP.createElement('mrow');
           CToP.appendToken(mrow2,'mo','{');
-          for(var i=0;i<args.length;i++) {
-            if(i>0) {
+          for (var i = 0, l = args.length; i<l; i++ ) {
+            if (i>0) {
               CToP.appendToken(mrow2,'mo',',');
             }
             CToP.applyTransform(mrow2,args[i],0);
           }
-          if(qualifiers.length) {
+          if (qualifiers.length) {
             CToP.appendToken(mrow2,'mo','|');
-            for(var i=0;i<qualifiers.length;i++) {
+            for (var i = 0, l = qualifiers.length; i<l; i++ ) {
               CToP.applyTransform(mrow2,qualifiers[i],0);
             }
           }
@@ -473,1162 +517,1186 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
   }
 
   /* Functions to transform variable/atom tokens
-   */
+  */
   CToP.tokens = {
-    "ci": function(parentNode,contentMMLNode,precedence) {
-      if(contentMMLNode.childNodes.length==1 && contentMMLNode.childNodes[0].nodeType==document.TEXT_NODE) {
-        var mi = CToP.appendToken(parentNode,'mi',contentMMLNode.textContent);
+    ci: function(parentNode,contentMMLNode,precedence) {
+      if (contentMMLNode.childNodes.length === 1 && contentMMLNode.childNodes[0].nodeType === 3) {
+        var mi = CToP.appendToken(parentNode,'mi',CToP.getTextContent(contentMMLNode));
         var type = contentMMLNode.getAttribute('type');
-        if(type in CToP.settings.cistyles) {
+        if (type in CToP.settings.cistyles) {
           mi.setAttribute('mathvariant',CToP.settings.cistyles[type]);
         }
       } else {
         CToP.transforms.token('mi')(parentNode,contentMMLNode,precedence);
       }
     },
-    "cs": CToP.transforms.token('ms'),
+    cs: CToP.transforms.token('ms'),
 
-    "csymbol": function(parentNode,contentMMLNode,precedence) {
+    csymbol: function(parentNode,contentMMLNode,precedence) {
       var cd = contentMMLNode.getAttribute('cd');
-      if(cd && CToP.contentDictionaries[cd]) {
+      if (cd && CToP.contentDictionaries[cd]) {
         CToP.contentDictionaries[cd](parentNode,contentMMLNode,precedence);
-      } else if(CToP.settings.symbols[name]){
+      } else if (CToP.settings.symbols[name]) {
         CToP.appendToken(parentNode,'mi',CToP.settings.symbols[name]);
       } else {
-        CToP.tokens['ci'](parentNode,contentMMLNode);
+        CToP.tokens.ci(parentNode,contentMMLNode);
       }
     },
-    "fn": function(parentNode,contentMMLNode,precedence) {
+    fn: function(parentNode,contentMMLNode,precedence) {
       CToP.applyTransform(parentNode,CToP.getChildren(contentMMLNode)[0],precedence);
     },
 
-    "naturalnumbers": CToP.transforms.identifier('\u2115'),
-    "integers": CToP.transforms.identifier('\u2124'),
-    "reals": CToP.transforms.identifier('\u211D'),
-    "rationals": CToP.transforms.identifier('\u211A'),
-    "complexes": CToP.transforms.identifier('\u2102'),
-    "primes": CToP.transforms.identifier('\u2119'),
-    "exponentiale": CToP.transforms.identifier('e'),
-    "imaginaryi": CToP.transforms.identifier('i'),
-    "notanumber": CToP.transforms.identifier('NaN'),
-    "eulergamma": CToP.transforms.identifier('\u03B3'),
-    "gamma": CToP.transforms.identifier('\u0263'),
-    "pi": CToP.transforms.identifier('\u03C0'),
-    "infinity": CToP.transforms.identifier('\u221E'),
-    "emptyset": CToP.transforms.identifier('\u2205'),
+    naturalnumbers: CToP.transforms.identifier('\u2115'),
+    integers: CToP.transforms.identifier('\u2124'),
+    reals: CToP.transforms.identifier('\u211D'),
+    rationals: CToP.transforms.identifier('\u211A'),
+    complexes: CToP.transforms.identifier('\u2102'),
+    primes: CToP.transforms.identifier('\u2119'),
+    exponentiale: CToP.transforms.identifier('e'),
+    imaginaryi: CToP.transforms.identifier('i'),
+    notanumber: CToP.transforms.identifier('NaN'),
+    eulergamma: CToP.transforms.identifier('\u03B3'),
+    gamma: CToP.transforms.identifier('\u0263'),
+    pi: CToP.transforms.identifier('\u03C0'),
+    infinity: CToP.transforms.identifier('\u221E'),
+    emptyset: CToP.transforms.identifier('\u2205'),
     "true": CToP.transforms.identifier('true'),
     "false": CToP.transforms.identifier('false'),
-    'set': CToP.transforms.set('{','}'),
-    'list': CToP.transforms.set('(',')')
-  }
-
-  CToP.tokens['interval'] = function(parentNode,contentMMLNode,precedence) {
-    var closure = contentMMLNode.getAttribute('closure');
-
-    var open, close;
-    switch(closure) {
-      case 'open':
-        open = '(';
-        close = ')';
-        break;
-      case 'open-closed':
-        open = '(';
-        close = ']';
-        break;
-      case 'closed-open':
-        open = '[';
-        close = ')';
-        break;
-      case 'closed':
-      default:
-        open = '[';
-        close = ']';
-    }
+    set: CToP.transforms.set('{','}'),
+    list: CToP.transforms.set('(',')'),
 
-    parentNode.appendChild(CToP.createmfenced(CToP.getChildren(contentMMLNode),open,close));
-  }
-  CToP.tokens['apply'] = CToP.tokens['reln'] = CToP.tokens['bind'] = function(parentNode,contentMMLNode,precedence) {
-    var children = CToP.classifyChildren(contentMMLNode);
-
-    var firstArg=children.args[0];
-    var args = children.args.slice(1), bvars = children.bvars, qualifiers = children.qualifiers;
-
-    if(firstArg) {
-      var name = firstArg.localName;
-      name = (name=="csymbol") ? firstArg.textContent.toLowerCase() : name;
-      if(CToP.applyTokens[name]) {
-        CToP.applyTokens[name](parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-      } else {
-        CToP.transforms.fn(name)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-      }
-    } else {
-      parentNode.appendChild(CToP.createElement('mrow'));
-    }
-  }
+    interval: function(parentNode,contentMMLNode,precedence) {
+      var closure = contentMMLNode.getAttribute('closure');
 
-  CToP.tokens['cn'] = function(parentNode,contentMMLNode,precedence) {
-    var type = contentMMLNode.getAttribute("type");
-    var base = contentMMLNode.getAttribute("base");
-    if(type || base) {
-      if(base) {
-        type = 'based-integer';
-      }
-      switch(type) {
-        case 'integer':
-        case 'real':
-        case 'double':
-        case 'constant':
-          CToP.transforms.token('mn')(parentNode,contentMMLNode);
+      var open, close;
+      switch(closure) {
+        case 'open':
+          open = '(';
+          close = ')';
+          break;
+        case 'open-closed':
+          open = '(';
+          close = ']';
           break;
-        case 'hexdouble':
-          CToP.appendToken(parentNode,'mn','0x'+contentMMLNode.textContent);
+        case 'closed-open':
+          open = '[';
+          close = ')';
           break;
+        case 'closed':
         default:
-          var apply = CToP.createElement('apply');
-          var mrow = CToP.createElement('mrow');
-          var c = CToP.createElement(type);
-          apply.appendChild(c);
-          if(base) {
-            CToP.appendToken(apply,'mn',base);
-          }
-          for(var j=0;j<contentMMLNode.childNodes.length; j++ ) {
-            if (contentMMLNode.childNodes[j].nodeType==document.TEXT_NODE) {
-              CToP.appendToken(mrow,'cn',contentMMLNode.childNodes[j].textContent);
-            }else if (contentMMLNode.childNodes[j].localName=='sep'){
-              apply.appendChild(mrow);
-              mrow = CToP.createElement('mrow');
-            } else {
-              mrow.appendChild(contentMMLNode.childNodes[j].cloneNode(true));
-            }
-          }
-          apply.appendChild(mrow);
-          CToP.applyTransform(parentNode,apply,0);
+          open = '[';
+          close = ']';
       }
-    } else {  
-      CToP.transforms.token('mn')(parentNode,contentMMLNode);
-    }
-  }
 
-  CToP.tokens['vector'] = function(parentNode,contentMMLNode,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','(');
+      parentNode.appendChild(CToP.createmfenced(CToP.getChildren(contentMMLNode),open,close));
+    },
 
-    var mtable = CToP.createElement('mtable');
-    var children = CToP.getChildren(contentMMLNode);
-    for(var i=0;i<children.length;i++) {
-      var mtr = CToP.createElement('mtr');
-      var mtd = CToP.createElement('mtd');
-      CToP.applyTransform(mtd,children[i],0);
-      mtr.appendChild(mtd);
-      mtable.appendChild(mtr);
-    }
+    apply: function(parentNode,contentMMLNode,precedence) {
+      var children = CToP.classifyChildren(contentMMLNode);
 
-    mrow.appendChild(mtable);
-    CToP.appendToken(mrow,'mo',')');
-    parentNode.appendChild(mrow);
-  }
+      var firstArg = children.args[0];
+      var args = children.args.slice(1), bvars = children.bvars, qualifiers = children.qualifiers;
 
-  CToP.tokens['piecewise'] = function(parentNode,contentMMLNode,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','{');
-    var mtable = CToP.createElement('mtable');
-    mrow.appendChild(mtable);
-    var children = CToP.getChildren(contentMMLNode);
-    for(var i=0;i<children.length;i++){
-      CToP.applyTransform(mtable,children[i],0);
-    }
-    parentNode.appendChild(mrow);
-  }
+      if (firstArg) {
+        var name = firstArg.nodeName;
+        name = (name === "csymbol") ? CToP.getTextContent(firstArg).toLowerCase() : name;
+        if (CToP.applyTokens[name]) {
+          CToP.applyTokens[name](parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
+        } else {
+          CToP.transforms.fn(name)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
+        }
+      } else {
+        parentNode.appendChild(CToP.createElement('mrow'));
+      }
+    },
+
+    cn: function(parentNode,contentMMLNode,precedence) {
+      var type = contentMMLNode.getAttribute("type");
+      var base = contentMMLNode.getAttribute("base");
+      if (type || base) {
+        if (base) {
+          type = 'based-integer';
+        }
+        switch(type) {
+          case 'integer':
+          case 'real':
+          case 'double':
+          case 'constant':
+            CToP.transforms.token('mn')(parentNode,contentMMLNode);
+            break;
+          case 'hexdouble':
+            CToP.appendToken(parentNode,'mn','0x'+CToP.getTextContent(contentMMLNode));
+            break;
+          default:
+            var apply = CToP.createElement('apply');
+            var mrow = CToP.createElement('mrow');
+            var c = CToP.createElement(type);
+            apply.appendChild(c);
+            if (base) {
+              CToP.appendToken(apply,'mn',base);
+            }
+            for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) {
+              if (contentMMLNode.childNodes[j].nodeType === 3) {
+                CToP.appendToken(mrow,'cn',CToP.getTextContent(contentMMLNode.childNodes[j]));
+              }else if (contentMMLNode.childNodes[j].nodeName === 'sep') {
+                apply.appendChild(mrow);
+                mrow = CToP.createElement('mrow');
+              } else {
+                mrow.appendChild(CToP.cloneNode(contentMMLNode.childNodes[j],true));
+              }
+            }
+            apply.appendChild(mrow);
+            CToP.applyTransform(parentNode,apply,0);
+        }
+      } else {  
+        CToP.transforms.token('mn')(parentNode,contentMMLNode);
+      }
+    },
+
+    vector: function(parentNode,contentMMLNode,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','(');
 
-  CToP.tokens['piece'] = function(parentNode,contentMMLNode,precedence) {
-    var mtr = CToP.createElement('mtr');
-    var children = CToP.getChildren(contentMMLNode);
-    for(i=0;i<children.length;i++){
-      var mtd = CToP.createElement('mtd');
-      mtr.appendChild(mtd);
-      CToP.applyTransform(mtd,children[i],0);
-      if(i==0){
+      var mtable = CToP.createElement('mtable');
+      var children = CToP.getChildren(contentMMLNode);
+      for (var i = 0, l = children.length; i<l; i++ ) {
+        var mtr = CToP.createElement('mtr');
         var mtd = CToP.createElement('mtd');
-        CToP.appendToken(mtd,"mtext","\u00A0if\u00A0");
+        CToP.applyTransform(mtd,children[i],0);
         mtr.appendChild(mtd);
+        mtable.appendChild(mtr);
       }
-    }
-    parentNode.appendChild(mtr);
-  }
 
-  CToP.tokens['otherwise'] = function(parentNode,contentMMLNode,precedence) {
-    var mtr = CToP.createElement('mtr');
-    var children = CToP.getChildren(contentMMLNode);
-    if(children.length){
-      var mtd = CToP.createElement('mtd');
-      mtr.appendChild(mtd);
-      CToP.applyTransform(mtd,children[0],0);
-      var mtd = CToP.createElement('mtd');
-      mtd.setAttribute('columnspan','2');
-      CToP.appendToken(mtd,"mtext","\u00A0otherwise");
-      mtr.appendChild(mtd);
-    }
-    parentNode.appendChild(mtr);
-  }
-
-  CToP.tokens['matrix'] = function(parentNode,contentMMLNode,precedence) {
-    var children = CToP.classifyChildren(contentMMLNode);
-    var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers;
+      mrow.appendChild(mtable);
+      CToP.appendToken(mrow,'mo',')');
+      parentNode.appendChild(mrow);
+    },
 
-    if(bvars.length || qualifiers.length) {
+    piecewise: function(parentNode,contentMMLNode,precedence) {
       var mrow = CToP.createElement('mrow');
-      CToP.appendToken(mrow,"mo","[");
-      var msub = CToP.createElement('msub');
-      CToP.appendToken(msub,'mi','m');
-      var mrow2 = CToP.createElement('mrow');
-      for(var i=0;i<bvars.length;i++){
-        if(i!=0){
-          CToP.appendToken(mrow2,'mo',',');
-        }	
-        CToP.applyTransform(mrow2,bvars[i].childNodes[0],0);
-      }
-      msub.appendChild(mrow2);
-      mrow.appendChild(msub);
-      var msub2 = msub.cloneNode(true);
-      CToP.appendToken(mrow,'mo','|');
-      mrow.appendChild(msub2);
-      CToP.appendToken(mrow,'mo','=');
-      for(var i=0;i<args.length;i++){
-        if(i!=0){
-          CToP.appendToken(mrow,'mo',',');
-        }	
-        CToP.applyTransform(mrow,args[i],0);
-      }
-      CToP.appendToken(mrow,'mo',';');
-      for(var i=0;i<qualifiers.length;i++){
-        if(i!=0){
-          CToP.appendToken(mrow,'mo',',');
-        }	
-        CToP.applyTransform(mrow,qualifiers[i],0);
-      }
-      CToP.appendToken(mrow,'mo',']');
-      parentNode.appendChild(mrow);
-    } else {
-      var mfenced = CToP.createElement('mfenced');
+      CToP.appendToken(mrow,'mo','{');
       var mtable = CToP.createElement('mtable');
-      for(var i=0;i<args.length;i++){
-        CToP.applyTransform(mtable,args[i],0);
+      mrow.appendChild(mtable);
+      var children = CToP.getChildren(contentMMLNode);
+      for (var i = 0, l = children.length; i<l; i++ ) {
+        CToP.applyTransform(mtable,children[i],0);
       }
-      mfenced.appendChild(mtable);
-      parentNode.appendChild(mfenced);
-    }
-  }
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.tokens['matrixrow'] = function(parentNode,contentMMLNode,precedence) {
-    var mtr = CToP.createElement('mtr');
-    var children = CToP.getChildren(contentMMLNode);
-    for(var i=0;i<children.length;i++){
-      var mtd = CToP.createElement('mtd');
-      CToP.applyTransform(mtd,children[i],0);
-      mtr.appendChild(mtd);
-    }
-    parentNode.appendChild(mtr);
-  }
+    piece: function(parentNode,contentMMLNode,precedence) {
+      var mtr = CToP.createElement('mtr');
+      var children = CToP.getChildren(contentMMLNode);
+      for (i = 0, l = children.length; i<l; i++ ) {
+        var mtd = CToP.createElement('mtd');
+        mtr.appendChild(mtd);
+        CToP.applyTransform(mtd,children[i],0);
+        if (i === 0) {
+          var mtd = CToP.createElement('mtd');
+          CToP.appendToken(mtd,"mtext","\u00A0if\u00A0");
+          mtr.appendChild(mtd);
+        }
+      }
+      parentNode.appendChild(mtr);
+    },
 
-  CToP.tokens['condition'] = function(parentNode,contentMMLNode,precedence) {
-    var mrow = CToP.createElement('mrow');
-    var children = CToP.getChildren(contentMMLNode);
-    for(var i=0;i<children.length;i++){
-      CToP.applyTransform(mrow,children[i],0);
-    }
-    parentNode.appendChild(mrow);
-  }
-  CToP.tokens['lambda'] = function(parentNode,contentMMLNode,precedence) {
-    var firstArg = CToP.createElement('lambda');
-    var children = CToP.classifyChildren(contentMMLNode);
-    var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers;
-
-    if(bvars.length){
-      CToP.applyTokens["lambda"](parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    } else {
-      var mrow=CToP.createElement('mrow');
-      for(var i=0;i<args.length;i++){
-        CToP.applyTransform(mrow,args[i],0);
+    otherwise: function(parentNode,contentMMLNode,precedence) {
+      var mtr = CToP.createElement('mtr');
+      var children = CToP.getChildren(contentMMLNode);
+      if (children.length) {
+        var mtd = CToP.createElement('mtd');
+        mtr.appendChild(mtd);
+        CToP.applyTransform(mtd,children[0],0);
+        var mtd = CToP.createElement('mtd');
+        mtd.setAttribute('columnspan','2');
+        CToP.appendToken(mtd,"mtext","\u00A0otherwise");
+        mtr.appendChild(mtd);
       }
-      if(qualifiers.length){
+      parentNode.appendChild(mtr);
+    },
+
+    matrix: function(parentNode,contentMMLNode,precedence) {
+      var children = CToP.classifyChildren(contentMMLNode);
+      var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers;
+
+      if (bvars.length || qualifiers.length) {
+        var mrow = CToP.createElement('mrow');
+        CToP.appendToken(mrow,"mo","[");
         var msub = CToP.createElement('msub');
-        CToP.appendToken(msub,'mo','|');
+        CToP.appendToken(msub,'mi','m');
         var mrow2 = CToP.createElement('mrow');
-        for(var i=0;i<qualifiers.length;i++){
-          var children = CToP.getChildren(qualifiers[i]);
-          for(var j=0;j<children.length;j++){
-            CToP.applyTransform(mrow2,children[j],0);
-          }
+        for (var i = 0, l = bvars.length; i<l; i++ ) {
+          if (i != 0) {
+            CToP.appendToken(mrow2,'mo',',');
+          }	
+          CToP.applyTransform(mrow2,bvars[i].childNodes[0],0);
         }
         msub.appendChild(mrow2);
         mrow.appendChild(msub);
+        var msub2 = CToP.cloneNode(msub,true);
+        CToP.appendToken(mrow,'mo','|');
+        mrow.appendChild(msub2);
+        CToP.appendToken(mrow,'mo','=');
+        for (var i = 0, l = args.length; i<l; i++ ) {
+          if (i != 0) {
+            CToP.appendToken(mrow,'mo',',');
+          }	
+          CToP.applyTransform(mrow,args[i],0);
+        }
+        CToP.appendToken(mrow,'mo',';');
+        for (var i = 0, l = qualifiers.length; i<l; i++) {
+          if (i != 0) {
+            CToP.appendToken(mrow,'mo',',');
+          }	
+          CToP.applyTransform(mrow,qualifiers[i],0);
+        }
+        CToP.appendToken(mrow,'mo',']');
+        parentNode.appendChild(mrow);
+      } else {
+        var mfenced = CToP.createElement('mfenced');
+        var mtable = CToP.createElement('mtable');
+        for (var i = 0, l = args.length; i<l; i++ ) {
+          CToP.applyTransform(mtable,args[i],0);
+        }
+        mfenced.appendChild(mtable);
+        parentNode.appendChild(mfenced);
+      }
+    },
+
+    matrixrow: function(parentNode,contentMMLNode,precedence) {
+      var mtr = CToP.createElement('mtr');
+      var children = CToP.getChildren(contentMMLNode);
+      for (var i = 0, l = children.length; i<l; i++ ) {
+        var mtd = CToP.createElement('mtd');
+        CToP.applyTransform(mtd,children[i],0);
+        mtr.appendChild(mtd);
+      }
+      parentNode.appendChild(mtr);
+    },
+
+    condition: function(parentNode,contentMMLNode,precedence) {
+      var mrow = CToP.createElement('mrow');
+      var children = CToP.getChildren(contentMMLNode);
+      for (var i = 0, l = children.length; i<l; i++ ) {
+        CToP.applyTransform(mrow,children[i],0);
       }
       parentNode.appendChild(mrow);
-    }
-  }
-  CToP.tokens["ident"] = function(parentNode,contentMMLNode,precedence) {
-    CToP.appendToken(parentNode,"mi","id")
-  }
+    },
 
-  CToP.tokens["domainofapplication"] = function(parentNode,contentMMLNode,precedence) {
-    var merror = CToP.createElement('merror');
-    CToP.appendToken(merror,'mtext','unexpected domainofapplication');
-    parentNode.appendChild(merror);
-  }
+    lambda: function(parentNode,contentMMLNode,precedence) {
+      var firstArg = CToP.createElement('lambda');
+      var children = CToP.classifyChildren(contentMMLNode);
+      var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers;
 
-  CToP.tokens["share"] = function(parentNode,contentMMLNode,precedence) {
-    var mi = CToP.createElement('mi');
-    mi.setAttribute('href',contentMMLNode.getAttribute('href'));
-    mi.textContent = "Share " + contentMMLNode.getAttribute('href');
-    parentNode.appendChild(mi);
-  }
+      if (bvars.length) {
+        CToP.applyTokens.lambda(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
+      } else {
+        var mrow = CToP.createElement('mrow');
+        for (var i = 0, l = args.length; i<l; i++ ) {
+          CToP.applyTransform(mrow,args[i],0);
+        }
+        if (qualifiers.length) {
+          var msub = CToP.createElement('msub');
+          CToP.appendToken(msub,'mo','|');
+          var mrow2 = CToP.createElement('mrow');
+          for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+            var children = CToP.getChildren(qualifiers[i]);
+            for (var j = 0, num_children = children.length; j<num_children; j++ ) {
+              CToP.applyTransform(mrow2,children[j],0);
+            }
+          }
+          msub.appendChild(mrow2);
+          mrow.appendChild(msub);
+        }
+        parentNode.appendChild(mrow);
+      }
+    },
 
-  CToP.tokens["cerror"] = function(parentNode,contentMMLNode,precedence) {
-    var merror = CToP.createElement('merror');
-    var children = CToP.getChildren(contentMMLNode);
-    for(var i=0;i<children.length;i++){
-      CToP.applyTransform(merror,children[i],0);
-    }
-    parentNode.appendChild(merror);
-  }
+    ident: function(parentNode,contentMMLNode,precedence) {
+      CToP.appendToken(parentNode,"mi","id")
+    },
 
-  CToP.tokens["semantics"] = function(parentNode,contentMMLNode,precedence)  {
-    var mrow = CToP.createElement('mrow');
-    var children = CToP.getChildren(contentMMLNode);
-    if(children.length){
-      var z = children[0];
-      for(var i=0;i<children.length;i++){
-        if(children[i].localName=='annotation-xml' && children[i].getAttribute('encoding')=='MathML-Presentation'){
-          z = children[i];
-          break;
+    domainofapplication: function(parentNode,contentMMLNode,precedence) {
+      var merror = CToP.createElement('merror');
+      CToP.appendToken(merror,'mtext','unexpected domainofapplication');
+      parentNode.appendChild(merror);
+    },
+
+    share: function(parentNode,contentMMLNode,precedence) {
+      var mi = CToP.createElement('mi');
+      mi.setAttribute('href',contentMMLNode.getAttribute('href'));
+      CToP.setTextContent(mi,"Share " + contentMMLNode.getAttribute('href'));
+      parentNode.appendChild(mi);
+    },
+
+    cerror: function(parentNode,contentMMLNode,precedence) {
+      var merror = CToP.createElement('merror');
+      var children = CToP.getChildren(contentMMLNode);
+      for (var i = 0, l = children.length; i<l; i++ ) {
+        CToP.applyTransform(merror,children[i],0);
+      }
+      parentNode.appendChild(merror);
+    },
+
+    semantics: function(parentNode,contentMMLNode,precedence)  {
+      var mrow = CToP.createElement('mrow');
+      var children = CToP.getChildren(contentMMLNode);
+      if (children.length) {
+        var z = children[0];
+        for (var i = 0, l = children.length; i<l; i++ ) {
+          if (children[i].nodeName === 'annotation-xml' && children[i].getAttribute('encoding') === 'MathML-Presentation') {
+            z = children[i];
+            break;
+          }
         }
+        CToP.applyTransform(mrow,z,0);
       }
-      CToP.applyTransform(mrow,z,0);
-    }
-    parentNode.appendChild(mrow);
-  }
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.tokens["annotation-xml"] = function(parentNode,contentMMLNode,precedence)  {
-    var mrow = CToP.createElement('mrow');
-    var children = CToP.getChildren(contentMMLNode);
-    for(var i=0;i<children.length;i++){
-      CToP.applyTransform(mrow,children[i],0);
+    "annotation-xml": function(parentNode,contentMMLNode,precedence)  {
+      var mrow = CToP.createElement('mrow');
+      var children = CToP.getChildren(contentMMLNode);
+      for (var i = 0, l = children.length; i<l; i++ ) {
+        CToP.applyTransform(mrow,children[i],0);
+      }
+      parentNode.appendChild(mrow);
     }
-    parentNode.appendChild(mrow);
-  }
+  };
 
+  CToP.tokens.reln = CToP.tokens.bind = CToP.tokens.apply;
 
   CToP.contentDictionaries = {
     "setname1": function(parentNode,contentMMLNode,precedence) {
       var sets = {
-        "C": '\u2102',
-        "N": '\u2115',
-        "P": '\u2119',
-        "Q": '\u211A',
-        "R": '\u211D',
-        "Z": '\u2124'
-      }
-      var name = contentMMLNode.textContent;
+        C: '\u2102',
+        N: '\u2115',
+        P: '\u2119',
+        Q: '\u211A',
+        R: '\u211D',
+        Z: '\u2124'
+      }
+      var name = CToP.getTextContent(contentMMLNode);
       CToP.appendToken(parentNode,'mi',sets[name]);
     },
-    "aritherror": function(parentNode,contentMMLNode,precedence) {
-      var name = contentMMLNode.textContent;
+    aritherror: function(parentNode,contentMMLNode,precedence) {
+      var name = CToP.getTextContent(contentMMLNode);
       CToP.appendToken(parentNode,'mi',name+':');
     }
   }
 
   /* Functions to transform function/operation application tokens
-   */
+  */
   CToP.applyTokens = {
-    "rem": CToP.transforms.binary('mod',3),
-    "divide": CToP.transforms.binary('/',3),
-    "remainder": CToP.transforms.binary('mod',3),
-    "implies": CToP.transforms.binary('\u21D2',3),
-    "factorof": CToP.transforms.binary('|',3),
+    rem: CToP.transforms.binary('mod',3),
+    divide: CToP.transforms.binary('/',3),
+    remainder: CToP.transforms.binary('mod',3),
+    implies: CToP.transforms.binary('\u21D2',3),
+    factorof: CToP.transforms.binary('|',3),
     "in": CToP.transforms.binary('\u2208',3),
-    "notin": CToP.transforms.binary('\u2209',3),
-    "notsubset": CToP.transforms.binary('\u2288',2),
-    "notprsubset": CToP.transforms.binary('\u2284',2),
-    "setdiff": CToP.transforms.binary('\u2216',2),
-    "eq": CToP.transforms.infix('=',1),
-    "compose": CToP.transforms.infix('\u2218',0),
+    notin: CToP.transforms.binary('\u2209',3),
+    notsubset: CToP.transforms.binary('\u2288',2),
+    notprsubset: CToP.transforms.binary('\u2284',2),
+    setdiff: CToP.transforms.binary('\u2216',2),
+    eq: CToP.transforms.infix('=',1),
+    compose: CToP.transforms.infix('\u2218',0),
     "left_compose": CToP.transforms.infix('\u2218',1),
-    "xor": CToP.transforms.infix('xor',3),
-    "neq": CToP.transforms.infix('\u2260',1),
-    "gt": CToP.transforms.infix('>',1),
-    "lt": CToP.transforms.infix('<',1),
-    "geq": CToP.transforms.infix('\u2265',1),
-    "leq": CToP.transforms.infix('\u2264',1),
-    "equivalent": CToP.transforms.infix('\u2261',1),
-    "approx": CToP.transforms.infix('\u2248',1),
-    "subset": CToP.transforms.infix('\u2286',2),
-    "prsubset": CToP.transforms.infix('\u2282',2),
-    "cartesianproduct": CToP.transforms.infix('\u00D7',2),
+    xor: CToP.transforms.infix('xor',3),
+    neq: CToP.transforms.infix('\u2260',1),
+    gt: CToP.transforms.infix('>',1),
+    lt: CToP.transforms.infix('<',1),
+    geq: CToP.transforms.infix('\u2265',1),
+    leq: CToP.transforms.infix('\u2264',1),
+    equivalent: CToP.transforms.infix('\u2261',1),
+    approx: CToP.transforms.infix('\u2248',1),
+    subset: CToP.transforms.infix('\u2286',2),
+    prsubset: CToP.transforms.infix('\u2282',2),
+    cartesianproduct: CToP.transforms.infix('\u00D7',2),
     "cartesian_product": CToP.transforms.infix('\u00D7',2),
-    "vectorproduct": CToP.transforms.infix('\u00D7',2),
-    "scalarproduct": CToP.transforms.infix('.',2),
-    "outerproduct": CToP.transforms.infix('\u2297',2),
-    "sum": CToP.transforms.iteration('\u2211','='),
-    "product": CToP.transforms.iteration('\u220F','='),
-    "forall": CToP.transforms.bind('\u2200','.',','),
-    "exists": CToP.transforms.bind('\u2203','.',','),
-    "lambda": CToP.transforms.bind('\u03BB','.',','),
-    "limit": CToP.transforms.iteration('lim','\u2192'),
-    "sdev": CToP.transforms.fn('\u03c3'),
-    "determinant": CToP.transforms.fn('det'),
-    "max": CToP.transforms.minmax('max'),
-    "min": CToP.transforms.minmax('min'),
-    "real": CToP.transforms.fn('\u211b'),
-    "imaginary": CToP.transforms.fn('\u2111'),
-    "set": CToP.transforms.set('{','}'),
-    "list": CToP.transforms.set('(',')')
-  }
-  CToP.applyTokens['exp'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var msup = CToP.createElement('msup');
-    CToP.appendToken(msup,'mi','e');
-    CToP.applyTransform(msup,args[0],0);
-    parentNode.appendChild(msup);
-  }
+    vectorproduct: CToP.transforms.infix('\u00D7',2),
+    scalarproduct: CToP.transforms.infix('.',2),
+    outerproduct: CToP.transforms.infix('\u2297',2),
+    sum: CToP.transforms.iteration('\u2211','='),
+    product: CToP.transforms.iteration('\u220F','='),
+    forall: CToP.transforms.bind('\u2200','.',','),
+    exists: CToP.transforms.bind('\u2203','.',','),
+    lambda: CToP.transforms.bind('\u03BB','.',','),
+    limit: CToP.transforms.iteration('lim','\u2192'),
+    sdev: CToP.transforms.fn('\u03c3'),
+    determinant: CToP.transforms.fn('det'),
+    max: CToP.transforms.minmax('max'),
+    min: CToP.transforms.minmax('min'),
+    real: CToP.transforms.fn('\u211b'),
+    imaginary: CToP.transforms.fn('\u2111'),
+    set: CToP.transforms.set('{','}'),
+    list: CToP.transforms.set('(',')'),
+
+    exp: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var msup = CToP.createElement('msup');
+      CToP.appendToken(msup,'mi','e');
+      CToP.applyTransform(msup,args[0],0);
+      parentNode.appendChild(msup);
+    },
 
-  CToP.applyTokens['union'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    if(bvars.length) {
-      CToP.transforms.iteration('\u22C3','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    } else {
-      CToP.transforms.infix('\u222A',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    }
-  }
-  CToP.applyTokens['intersect'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    if(bvars.length) {
-      CToP.transforms.iteration('\u22C2','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    } else {
-      var mrow = CToP.createElement('mrow');
-      var needsBrackets = precedence>2;
-      if(needsBrackets) {
-        CToP.appendToken(mrow,'mo','(');
+    union: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      if (bvars.length) {
+        CToP.transforms.iteration('\u22C3','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
+      } else {
+        CToP.transforms.infix('\u222A',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
       }
-      for(var j=0;j<args.length; j++ ) {
-        var argBrackets = false;
-        if(j>0) {
-          CToP.appendToken(mrow,'mo','\u2229');
-          if(args[j].localName=='apply') {
-            var child = CToP.getChildren(args[j])[0];
-            argBrackets = child.localName == 'union';
-          }
-        }
-        if(argBrackets) {
+    },
+
+    intersect: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      if (bvars.length) {
+        CToP.transforms.iteration('\u22C2','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
+      } else {
+        var mrow = CToP.createElement('mrow');
+        var needsBrackets = precedence>2;
+        if (needsBrackets) {
           CToP.appendToken(mrow,'mo','(');
         }
-        CToP.applyTransform(mrow,args[j],2);
-        if(argBrackets) {
+        for (var j = 0, l = args.length; j<l; j++ ) {
+          var argBrackets = false;
+          if (j>0) {
+            CToP.appendToken(mrow,'mo','\u2229');
+            if (args[j].nodeName === 'apply') {
+              var child = CToP.getChildren(args[j])[0];
+              argBrackets = child.nodeName  ===  'union';
+            }
+          }
+          if (argBrackets) {
+            CToP.appendToken(mrow,'mo','(');
+          }
+          CToP.applyTransform(mrow,args[j],2);
+          if (argBrackets) {
+            CToP.appendToken(mrow,'mo',')');
+          }
+        }
+        if (needsBrackets) {
           CToP.appendToken(mrow,'mo',')');
         }
+        parentNode.appendChild(mrow);
       }
-      if(needsBrackets) {
-        CToP.appendToken(mrow,'mo',')');
-      }
+    },
+
+    floor: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u230a');
+      CToP.applyTransform(mrow,args[0],0);
+      CToP.appendToken(mrow,'mo','\u230b');
       parentNode.appendChild(mrow);
-    }
-  }
+    },
 
-  CToP.applyTokens['floor'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u230a');
-    CToP.applyTransform(mrow,args[0],0);
-    CToP.appendToken(mrow,'mo','\u230b');
-    parentNode.appendChild(mrow);
-  }
-  CToP.applyTokens['conjugate'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mover = CToP.createElement('mover');
-    CToP.applyTransform(mover,args[0],0);
-    CToP.appendToken(mover,'mo','\u00af');
-    parentNode.appendChild(mover);
-  }
-  CToP.applyTokens['abs'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','|');
-    CToP.applyTransform(mrow,args[0],0);
-    CToP.appendToken(mrow,'mo','|');
-    parentNode.appendChild(mrow);
-  }
-  CToP.applyTokens['and'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    if(bvars.length || qualifiers.length) {
-      CToP.transforms.iteration('\u22c0','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4);
-    } else {
-      CToP.transforms.infix('\u2227',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    }
-  }
-  CToP.applyTokens['or'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    if(bvars.length || qualifiers.length) {
-      CToP.transforms.iteration('\u22c1','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4);
-    } else {
-      CToP.transforms.infix('\u2228',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    }
-  }
-  CToP.applyTokens['xor'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    if(bvars.length || qualifiers.length) {
-      CToP.transforms.iteration('xor','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4);
-    } else {
-      CToP.transforms.infix('xor',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-    }
-  }
-  CToP.applyTokens['card'] = CToP.applyTokens['size'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','|');
-    CToP.applyTransform(mrow,args[0],0);
-    CToP.appendToken(mrow,'mo','|');
-    parentNode.appendChild(mrow);
-  }
-  CToP.applyTokens['mean'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    if(args.length==1) {
+    conjugate: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
       var mover = CToP.createElement('mover');
       CToP.applyTransform(mover,args[0],0);
       CToP.appendToken(mover,'mo','\u00af');
       parentNode.appendChild(mover);
-    } else {
-      parentNode.appendChild(CToP.createmfenced(args,'\u27e8','\u27e9'));
-    }
-  }
-  CToP.applyTokens['moment'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var degree,momentabout;
+    },
+
+    abs: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','|');
+      CToP.applyTransform(mrow,args[0],0);
+      CToP.appendToken(mrow,'mo','|');
+      parentNode.appendChild(mrow);
+    },
 
-    for(var i=0; i<qualifiers.length;i++){
-      if(qualifiers[i].localName=='degree') {
-        degree = qualifiers[i];
-      } else if(qualifiers[i].localName=='momentabout') {
-        momentabout = qualifiers[i];
+    and: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      if (bvars.length || qualifiers.length) {
+        CToP.transforms.iteration('\u22c0','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4);
+      } else {
+        CToP.transforms.infix('\u2227',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
       }
-    }
+    },
 
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u27e8');
-    var argrow = CToP.createElement('mrow');
-    if(args.length>1) {
-      argrow.appendChild(CToP.createmfenced(args,'(',')'));
-    } else {
-      CToP.applyTransform(argrow,args[0],0);
-    }
-    if(degree) {
-      var msup = CToP.createElement('msup');
-      msup.appendChild(argrow);
-      var children = CToP.getChildren(degree);
-      for(var j=0;j<children.length;j++){
-        CToP.applyTransform(msup,children[j],0);
+    or: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      if (bvars.length || qualifiers.length) {
+        CToP.transforms.iteration('\u22c1','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4);
+      } else {
+        CToP.transforms.infix('\u2228',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
       }
-      mrow.appendChild(msup);
-    } else {
-      mrow.appendChild(argrow);
-    }
-    CToP.appendToken(mrow,'mo','\u27e9');
+    },
 
-    if(momentabout) {
-      var msub = CToP.createElement('msub');
-      msub.appendChild(mrow);
-      var children = CToP.getChildren(momentabout);
-      for(var j=0;j<children.length;j++){
-        CToP.applyTransform(msub,children[j],0);
+    xor: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      if (bvars.length || qualifiers.length) {
+        CToP.transforms.iteration('xor','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4);
+      } else {
+        CToP.transforms.infix('xor',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
       }
-      parentNode.appendChild(msub);
-    } else {
+    },
+
+    card: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','|');
+      CToP.applyTransform(mrow,args[0],0);
+      CToP.appendToken(mrow,'mo','|');
       parentNode.appendChild(mrow);
-    }
-  }
+    },
 
-  CToP.applyTokens['variance'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    var msup = CToP.createElement('msup');
-    CToP.appendToken(msup,'mo','\u03c3');
-    CToP.appendToken(msup,'mn','2');
-    mrow.appendChild(msup);
-    CToP.appendToken(mrow,'mo','\u2061');
-    mrow.appendChild(CToP.createmfenced(args,'(',')'));
-    parentNode.appendChild(mrow);
-  }
-  CToP.applyTokens['grad'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u2207');
-    CToP.appendToken(mrow,'mo','\u2061');
-    mrow.appendChild(CToP.createmfenced(args,'(',')'));
-    parentNode.appendChild(mrow);
-  };
-  CToP.applyTokens['laplacian'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    var msup = CToP.createElement('msup');
-    CToP.appendToken(msup,'mo','\u2207');
-    CToP.appendToken(msup,'mn','2');
-    mrow.appendChild(msup);
-    CToP.appendToken(mrow,'mo','\u2061');
-    mrow.appendChild(CToP.createmfenced(args,'(',')'));
-    parentNode.appendChild(mrow);
-  };
-  CToP.applyTokens['curl'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u2207');
-    CToP.appendToken(mrow,'mo','\u00d7');
-    var needsBrackets = args[0].localName == 'apply';
-    if(needsBrackets) {
-      mrow.appendChild(CToP.createmfenced(args,'(', ')'));
-    }
-    else {
-      CToP.applyTransform(mrow,args[0],precedence);
-    }
-    parentNode.appendChild(mrow);
-  };
-  CToP.applyTokens['divergence'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u2207');
-    CToP.appendToken(mrow,'mo','\u22c5');
-    var needsBrackets = args[0].localName == 'apply';
-    if(needsBrackets) {
-      mrow.appendChild(CToP.createmfenced(args,'(', ')'));
-    }
-    else {
-      CToP.applyTransform(mrow,args[0],precedence);
-    }
-    parentNode.appendChild(mrow);
-  };
-  CToP.applyTokens['not'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u00ac');
-    var needsBrackets = args[0].localName=='apply' || args[0].localName=='bind';
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo','(');
-    }
-    CToP.applyTransform(mrow,args[0],precedence);
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo',')');
-    }
-    parentNode.appendChild(mrow)
-  }
-  CToP.applyTokens['divide'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mfrac = CToP.createElement('mfrac');
-    CToP.applyTransform(mfrac,args[0],0);
-    CToP.applyTransform(mfrac,args[1],0);
-    parentNode.appendChild(mfrac);
-  }
-  CToP.applyTokens['tendsto'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var type;
-    if(firstArg.localName=='tendsto') {
-      type = firstArg.getAttribute('type');
-    } else {
-      type = args[0].textContent;
-      args = args.slice(1);
-    }
-    var name = (type=='above')? '\u2198' :
-      (type=='below') ? '\u2197' : '\u2192' ;
-    CToP.transforms.binary(name,2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
-  }
-  CToP.applyTokens['minus'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var tokenPrecedence = args.length==1 ? 5 : 2;
+    mean: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      if (args.length === 1) {
+        var mover = CToP.createElement('mover');
+        CToP.applyTransform(mover,args[0],0);
+        CToP.appendToken(mover,'mo','\u00af');
+        parentNode.appendChild(mover);
+      } else {
+        parentNode.appendChild(CToP.createmfenced(args,'\u27e8','\u27e9'));
+      }
+    },
 
-    var mrow = CToP.createElement('mrow');
-    var needsBrackets = tokenPrecedence<precedence;
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo','(');
-    }
+    moment: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var degree,momentabout;
 
-    if(args.length==1) {
-      CToP.appendToken(mrow,'mo','-');
-      CToP.applyTransform(mrow,args[0],tokenPrecedence);
-    } else {
-      CToP.applyTransform(mrow,args[0],tokenPrecedence);
-      CToP.appendToken(mrow,'mo','-');
-      var bracketArg;
-      if(args[1].localName=='apply') {
-        var argOp = CToP.getChildren(args[1])[0];
-        bracketArg = argOp.localName=='plus' || argOp.localName=='minus';
-      }
-      if(bracketArg) {
-        CToP.appendToken(mrow,'mo','(');
+      for (var i = 0, l = qualifiers.length; i<l; i++ ) {
+        if (qualifiers[i].nodeName === 'degree') {
+          degree = qualifiers[i];
+        } else if (qualifiers[i].nodeName === 'momentabout') {
+          momentabout = qualifiers[i];
+        }
       }
-      CToP.applyTransform(mrow,args[1],tokenPrecedence);
-      if(bracketArg) {
-        CToP.appendToken(mrow,'mo',')');
+
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u27e8');
+      var argrow = CToP.createElement('mrow');
+      if (args.length>1) {
+        argrow.appendChild(CToP.createmfenced(args,'(',')'));
+      } else {
+        CToP.applyTransform(argrow,args[0],0);
       }
-    }
+      if (degree) {
+        var msup = CToP.createElement('msup');
+        msup.appendChild(argrow);
+        var children = CToP.getChildren(degree);
+        for (var j = 0, l = children.length; j<l; j++ ) {
+          CToP.applyTransform(msup,children[j],0);
+        }
+        mrow.appendChild(msup);
+      } else {
+        mrow.appendChild(argrow);
+      }
+      CToP.appendToken(mrow,'mo','\u27e9');
 
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo',')');
-    }
-    parentNode.appendChild(mrow);
-  }
-  CToP.applyTokens['complex-cartesian'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.applyTransform(mrow,args[0],0);
-    CToP.appendToken(mrow,'mo','+');
-    CToP.applyTransform(mrow,args[1],0);
-    CToP.appendToken(mrow,'mo','\u2062');
-    CToP.appendToken(mrow,'mi','i');
-    parentNode.appendChild(mrow);
-  }
+      if (momentabout) {
+        var msub = CToP.createElement('msub');
+        msub.appendChild(mrow);
+        var children = CToP.getChildren(momentabout);
+        for (var j = 0, l = children.length; j<l; j++ ) {
+          CToP.applyTransform(msub,children[j],0);
+        }
+        parentNode.appendChild(msub);
+      } else {
+        parentNode.appendChild(mrow);
+      }
+    },
 
-  CToP.applyTokens['complex-polar'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    CToP.applyTransform(mrow,args[0],0);
-    CToP.appendToken(mrow,'mo','\u2062');
-    var msup = CToP.createElement('msup');
-    CToP.appendToken(msup,'mi','e');
-    var exponent = CToP.createElement('mrow');
-    CToP.applyTransform(exponent,args[1],0);
-    CToP.appendToken(exponent,'mo','\u2062');
-    CToP.appendToken(exponent,'mi','i');
-    msup.appendChild(exponent);
-    mrow.appendChild(msup);
-    parentNode.appendChild(mrow);
-  }
+    variance: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      var msup = CToP.createElement('msup');
+      CToP.appendToken(msup,'mo','\u03c3');
+      CToP.appendToken(msup,'mn','2');
+      mrow.appendChild(msup);
+      CToP.appendToken(mrow,'mo','\u2061');
+      mrow.appendChild(CToP.createmfenced(args,'(',')'));
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens['integer'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    CToP.applyTransform(parentNode,args[0],0);
-  }
+    grad: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u2207');
+      CToP.appendToken(mrow,'mo','\u2061');
+      mrow.appendChild(CToP.createmfenced(args,'(',')'));
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens['based-integer'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var msub = CToP.createElement('msub');
-    CToP.applyTransform(msub,args[1],0);
-    CToP.applyTransform(msub,args[0],0);
-    parentNode.appendChild(msub);
-  }
+    laplacian: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      var msup = CToP.createElement('msup');
+      CToP.appendToken(msup,'mo','\u2207');
+      CToP.appendToken(msup,'mn','2');
+      mrow.appendChild(msup);
+      CToP.appendToken(mrow,'mo','\u2061');
+      mrow.appendChild(CToP.createmfenced(args,'(',')'));
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens['rational'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mfrac = CToP.createElement('mfrac');
-    CToP.applyTransform(mfrac,args[0],0);
-    CToP.applyTransform(mfrac,args[1],0);
-    parentNode.appendChild(mfrac);
-  }
+    curl: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u2207');
+      CToP.appendToken(mrow,'mo','\u00d7');
+      var needsBrackets = args[0].nodeName === 'apply';
+      if (needsBrackets) {
+        mrow.appendChild(CToP.createmfenced(args,'(', ')'));
+      }
+      else {
+        CToP.applyTransform(mrow,args[0],precedence);
+      }
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens['times'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    var needsBrackets = precedence>3;
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo','(');
-    }
-    for(var j=0;j<args.length; j++ ) {
-      if(j>0) {
-        CToP.appendToken(mrow,'mo',(args[j].localName=='cn') ? "\u00D7" :"\u2062");
+    divergence: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u2207');
+      CToP.appendToken(mrow,'mo','\u22c5');
+      var needsBrackets = args[0].nodeName === 'apply';
+      if (needsBrackets) {
+        mrow.appendChild(CToP.createmfenced(args,'(', ')'));
       }
-      CToP.applyTransform(mrow,args[j],3);
-    }
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo',')');
-    }
-    parentNode.appendChild(mrow);
-  }
+      else {
+        CToP.applyTransform(mrow,args[0],precedence);
+      }
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens["plus"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var mrow = CToP.createElement('mrow');
-    var needsBrackets = precedence>2;
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo','(');
-    }
-    for(var j=0;j<args.length; j++ ) {
-      var arg = args[j];
-      var children = CToP.getChildren(arg);
-      if(j>0) {
-        var n;
-        if(CToP.settings.collapsePlusMinus) {
-          if(arg.localName=='cn' && !(children.length) && (n=Number(arg.textContent)) <0) {
-            CToP.appendToken(mrow,'mo','\u2212');
-            CToP.appendToken(mrow,'mn', -n);
-          } else if(arg.localName=='apply' && children.length==2 && children[0].localName=='minus') {
-            CToP.appendToken(mrow,'mo','\u2212');
-            CToP.applyTransform(mrow,children[1],2);
-          } else if(arg.localName=='apply' && children.length>2 && children[0].localName=='times' && children[1].localName=='cn' && ( n=Number(children[1].textContent) < 0)) {
-            CToP.appendToken(mrow,'mo','\u2212');
-            children[1].textContent=-n;// fix me: modifying document
-            CToP.applyTransform(mrow,arg,2);
-          } else{
-            CToP.appendToken(mrow,'mo','+');
-            CToP.applyTransform(mrow,arg,2);
-          }
-        } else {
-          CToP.appendToken(mrow,'mo','+');
-          CToP.applyTransform(mrow,arg,2);
-        }
-      } else {
-        CToP.applyTransform(mrow,arg,2);	
+    not: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u00ac');
+      var needsBrackets = args[0].nodeName === 'apply' || args[0].nodeName === 'bind';
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo','(');
       }
-    }
-    if(needsBrackets) {
-      CToP.appendToken(mrow,'mo',')');
-    }
-    parentNode.appendChild(mrow);
-  }
+      CToP.applyTransform(mrow,args[0],precedence);
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo',')');
+      }
+      parentNode.appendChild(mrow)
+    },
 
-  CToP.applyTokens['transpose'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var msup = CToP.createElement('msup');
-    CToP.applyTransform(msup,args[0],precedence);
-    CToP.appendToken(msup,'mi','T');
-    parentNode.appendChild(msup);
-  }
+    divide: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mfrac = CToP.createElement('mfrac');
+      CToP.applyTransform(mfrac,args[0],0);
+      CToP.applyTransform(mfrac,args[1],0);
+      parentNode.appendChild(mfrac);
+    },
 
-  CToP.applyTokens['power'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var msup = CToP.createElement('msup');
-    CToP.applyTransform(msup,args[0],3);
-    CToP.applyTransform(msup,args[1],precedence);
-    parentNode.appendChild(msup);
-  }
+    tendsto: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var type;
+      if (firstArg.nodeName === 'tendsto') {
+        type = firstArg.getAttribute('type');
+      } else {
+        type = CToP.getTextContent(args[0]);
+        args = args.slice(1);
+      }
+      var name = (type === 'above')? '\u2198' :
+        (type === 'below') ? '\u2197' : '\u2192' ;
+      CToP.transforms.binary(name,2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence);
+    },
 
-  CToP.applyTokens['selector'] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
-    var msub = CToP.createElement('msub');
-    var mrow = args ? args[0]: CToP.createElement('mrow');
-    CToP.applyTransform(msub,mrow,0);
-    var mrow2 = CToP.createElement('mrow');
-    for(var i=1;i<args.length;i++){
-      if(i!=1){
-        CToP.appendToken(mrow2,'mo',',');
-      }	
-      CToP.applyTransform(mrow2,args[i],0);
-    }
-    msub.appendChild(mrow2);
-    parentNode.appendChild(msub);
-  }
+    minus: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var tokenPrecedence = args.length === 1 ? 5 : 2;
 
-  CToP.applyTokens["log"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var mrow = CToP.createElement('mrow');
-    var mi = CToP.createElement('mi');
-    mi.textContent = 'log';
-    if(qualifiers.length && qualifiers[0].localName=='logbase'){
-      var msub = CToP.createElement('msub');
-      msub.appendChild(mi);
-      CToP.applyTransform(msub,CToP.getChildren(qualifiers[0])[0],0);
-      mrow.appendChild(msub);
-    } else {
-      mrow.appendChild(mi);
-    }
-    CToP.applyTransform(mrow,args[0],7);
-    parentNode.appendChild(mrow);
-  }
+      var mrow = CToP.createElement('mrow');
+      var needsBrackets = tokenPrecedence<precedence;
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo','(');
+      }
 
-  CToP.applyTokens["int"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var mrow = CToP.createElement('mrow');
-    var mo = CToP.createElement('mo');
-    mo.textContent='\u222B';
-    var msubsup = CToP.createElement('msubsup');
-    msubsup.appendChild(mo);
-    var mrow1 = CToP.createElement('mrow');
-    for(var i=0; i<qualifiers.length;i++){
-      if(qualifiers[i].localName=='lowlimit'||
-          qualifiers[i].localName=='condition'||
-          qualifiers[i].localName=='domainofapplication')
-      {
-        var children = CToP.getChildren(qualifiers[i]);
-        for(var j=0;j<children.length;j++){
-          CToP.applyTransform(mrow1,children[j],0);
-        }
+      if (args.length === 1) {
+        CToP.appendToken(mrow,'mo','-');
+        CToP.applyTransform(mrow,args[0],tokenPrecedence);
       } else {
-        var children = CToP.getChildren(qualifiers[i]);
-        if (qualifiers[i].localName=='interval' && children.length==2) {
-          CToP.applyTransform(mrow1,children[0],0);
+        CToP.applyTransform(mrow,args[0],tokenPrecedence);
+        CToP.appendToken(mrow,'mo','-');
+        var bracketArg;
+        if (args[1].nodeName === 'apply') {
+          var argOp = CToP.getChildren(args[1])[0];
+          bracketArg = argOp.nodeName === 'plus' || argOp.nodeName === 'minus';
         }
-      }
-    }
-    msubsup.appendChild(mrow1);
-    var mrow2 = CToP.createElement('mrow');
-    for(var i=0; i<qualifiers.length;i++){
-      if(qualifiers[i].localName=='uplimit'){
-        var children = CToP.getChildren(qualifiers[i]);
-        for(j=0;j<children.length;j++){
-          CToP.applyTransform(mrow2,children[j],0);
+        if (bracketArg) {
+          CToP.appendToken(mrow,'mo','(');
+        }
+        CToP.applyTransform(mrow,args[1],tokenPrecedence);
+        if (bracketArg) {
+          CToP.appendToken(mrow,'mo',')');
         }
-        break;
-      } else if(qualifiers[i].localName=='interval' ){
-        var children = CToP.getChildren(qualifiers[i]);
-        CToP.applyTransform(mrow2,children[children.length-1],0);
-        break;
       }
-    }
-    msubsup.appendChild(mrow2);
-    mrow.appendChild(msubsup);
-    for(var i=0; i<args.length;i++){
-      CToP.applyTransform(mrow,args[i],0);
-    }
-    for(var i=0; i<bvars.length;i++){
-      var bvar = bvars[i];
-      var children = CToP.getChildren(bvar);
-      if(children.length){
-        var mrow3 = CToP.createElement("mrow");
-        CToP.appendToken(mrow3,'mi','d');
-        CToP.applyTransform(mrow3,children[0],0);
-        mrow.appendChild(mrow3);
+
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo',')');
       }
-    }
-    parentNode.appendChild(mrow);
-  }
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens["inverse"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var msup = CToP.createElement('msup');
-    var arg = (args.length) ? args[0] : CToP.createElement('mrow');
-    CToP.applyTransform(msup,arg,precedence);
-    var mfenced = CToP.createElement('mfenced');
-    CToP.appendToken(mfenced,'mn','-1');
-    msup.appendChild(mfenced);
-    parentNode.appendChild(msup);
-  }
+    "complex-cartesian": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      CToP.applyTransform(mrow,args[0],0);
+      CToP.appendToken(mrow,'mo','+');
+      CToP.applyTransform(mrow,args[1],0);
+      CToP.appendToken(mrow,'mo','\u2062');
+      CToP.appendToken(mrow,'mi','i');
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens["quotient"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var mrow = CToP.createElement('mrow');
-    CToP.appendToken(mrow,'mo','\u230A');
-    if(args.length) {
+    "complex-polar": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
       CToP.applyTransform(mrow,args[0],0);
-      CToP.appendToken(mrow,'mo','/');
-      if(args.length>1){
-        CToP.applyTransform(mrow,args[1],0);
-      }
-    }
-    CToP.appendToken(mrow,'mo','\u230B');
-    parentNode.appendChild(mrow);
-  }
+      CToP.appendToken(mrow,'mo','\u2062');
+      var msup = CToP.createElement('msup');
+      CToP.appendToken(msup,'mi','e');
+      var exponent = CToP.createElement('mrow');
+      CToP.applyTransform(exponent,args[1],0);
+      CToP.appendToken(exponent,'mo','\u2062');
+      CToP.appendToken(exponent,'mi','i');
+      msup.appendChild(exponent);
+      mrow.appendChild(msup);
+      parentNode.appendChild(mrow);
+    },
 
-  CToP.applyTokens["factorial"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var mrow = CToP.createElement('mrow');
-    CToP.applyTransform(mrow,args[0],4);
-    CToP.appendToken(mrow,'mo','!');
-    parentNode.appendChild(mrow);
-  }
+    integer: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      CToP.applyTransform(parentNode,args[0],0);
+    },
 
-  CToP.applyTokens["root"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var mr;
-    if(firstArg.localName=='root' && (qualifiers.length==0 || (qualifiers[0].localName=='degree' && qualifiers[0].textContent=='2'))){
-      mr = CToP.createElement('msqrt');
-      for(var i=0;i<args.length;i++){
-        CToP.applyTransform(mr,args[i],0);
-      }
-    } else {
-      mr = CToP.createElement('mroot');
-      CToP.applyTransform(mr,args[0],0);
-      var arg = (firstArg.localName=='root') ? qualifiers[0].childNodes[0] : args[1];
-      CToP.applyTransform(mr,arg,0);
-    }
-    parentNode.appendChild(mr);
-  }
+    "based-integer": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var msub = CToP.createElement('msub');
+      CToP.applyTransform(msub,args[1],0);
+      CToP.applyTransform(msub,args[0],0);
+      parentNode.appendChild(msub);
+    },
 
-  CToP.applyTokens["diff"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    if(bvars.length){	// d/dx form
-      var outNode;
+    rational: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
       var mfrac = CToP.createElement('mfrac');
-      var toprow = CToP.createElement('mrow');
-      var bottomrow = CToP.createElement('mrow');
-      mfrac.appendChild(toprow);
-      mfrac.appendChild(bottomrow);
+      CToP.applyTransform(mfrac,args[0],0);
+      CToP.applyTransform(mfrac,args[1],0);
+      parentNode.appendChild(mfrac);
+    },
 
-      var bvar;
-      var degreeNode;
-
-      var d = CToP.createElement('mi');
-      d.textContent = 'd';
-
-      var children = CToP.getChildren(bvars[0]);
-      for(var j=0;j<children.length;j++){
-        if(children[j].localName=='degree'){
-          var childNode = CToP.getChildren(children[j])[0];
-          if(childNode.textContent!='1'){
-            degreeNode = childNode;
-            var msup = CToP.createElement('msup');
-            msup.appendChild(d);
-            d = msup;
-            CToP.applyTransform(d,degreeNode,0);
-          }
-        } else {
-          bvar = children[j];
+    times: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      var needsBrackets = precedence>3;
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo','(');
+      }
+      for (var j = 0, l = args.length; j<l; j++ ) {
+        if (j>0) {
+          CToP.appendToken(mrow,'mo',(args[j].nodeName === 'cn') ? "\u00D7" :"\u2062");
         }
+        CToP.applyTransform(mrow,args[j],3);
+      }
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo',')');
       }
-      toprow.appendChild(d);
+      parentNode.appendChild(mrow);
+    },
 
-      if(args.length){
-        switch(args[0].localName) {
-          case 'apply':
-          case 'bind':
-          case 'reln':
-            var mrow = CToP.createElement('mrow');
-            mrow.appendChild(mfrac);
-            CToP.applyTransform(mrow,args[0],3);
-            outNode = mrow;
-            break;
-          default:
-            CToP.applyTransform(toprow,args[0],0);
-            outNode = mfrac;
+    plus: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var mrow = CToP.createElement('mrow');
+      var needsBrackets = precedence>2;
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo','(');
+      }
+      for (var j = 0, l = args.length; j<l; j++ ) {
+        var arg = args[j];
+        var children = CToP.getChildren(arg);
+        if (j>0) {
+          var n;
+          if (CToP.settings.collapsePlusMinus) {
+            if (arg.nodeName === 'cn' && !(children.length) && (n = Number(CToP.getTextContent(arg))) <0) {
+              CToP.appendToken(mrow,'mo','\u2212');
+              CToP.appendToken(mrow,'mn', -n);
+            } else if (arg.nodeName === 'apply' && children.length === 2 && children[0].nodeName === 'minus') {
+              CToP.appendToken(mrow,'mo','\u2212');
+              CToP.applyTransform(mrow,children[1],2);
+            } else if (arg.nodeName === 'apply' && children.length>2 && children[0].nodeName === 'times' && children[1].nodeName === 'cn' && ( n = Number(CToP.getTextContent(children[1])) < 0)) {
+              CToP.appendToken(mrow,'mo','\u2212');
+              CToP.getTextContent(children[1]) = -n;// fix me: modifying document
+              CToP.applyTransform(mrow,arg,2);
+            } else{
+              CToP.appendToken(mrow,'mo','+');
+              CToP.applyTransform(mrow,arg,2);
+            }
+          } else {
+            CToP.appendToken(mrow,'mo','+');
+            CToP.applyTransform(mrow,arg,2);
+          }
+        } else {
+          CToP.applyTransform(mrow,arg,2);	
         }
       }
+      if (needsBrackets) {
+        CToP.appendToken(mrow,'mo',')');
+      }
+      parentNode.appendChild(mrow);
+    },
+
+    transpose: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var msup = CToP.createElement('msup');
+      CToP.applyTransform(msup,args[0],precedence);
+      CToP.appendToken(msup,'mi','T');
+      parentNode.appendChild(msup);
+    },
+
+    power: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var msup = CToP.createElement('msup');
+      CToP.applyTransform(msup,args[0],3);
+      CToP.applyTransform(msup,args[1],precedence);
+      parentNode.appendChild(msup);
+    },
 
-      CToP.appendToken(bottomrow,'mi','d');
+    selector: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) {
+      var msub = CToP.createElement('msub');
+      var mrow = args ? args[0]: CToP.createElement('mrow');
+      CToP.applyTransform(msub,mrow,0);
+      var mrow2 = CToP.createElement('mrow');
+      for (var i = 1, l = args.length; i<l; i++ ) {
+        if (i != 1) {
+          CToP.appendToken(mrow2,'mo',',');
+        }	
+        CToP.applyTransform(mrow2,args[i],0);
+      }
+      msub.appendChild(mrow2);
+      parentNode.appendChild(msub);
+    },
 
-      if(degreeNode){
-        var msup2 = CToP.createElement('msup');
-        CToP.applyTransform(msup2,bvar,0);
-        CToP.applyTransform(msup2,degreeNode,0);
-        bottomrow.appendChild(msup2);
+    log: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      var mrow = CToP.createElement('mrow');
+      var mi = CToP.createElement('mi');
+      CToP.setTextContent(mi,'log');
+      if (qualifiers.length && qualifiers[0].nodeName === 'logbase') {
+        var msub = CToP.createElement('msub');
+        msub.appendChild(mi);
+        CToP.applyTransform(msub,CToP.getChildren(qualifiers[0])[0],0);
+        mrow.appendChild(msub);
       } else {
-        CToP.applyTransform(bottomrow,bvar,0);
+        mrow.appendChild(mi);
       }
+      CToP.applyTransform(mrow,args[0],7);
+      parentNode.appendChild(mrow);
+    },
 
+    "int": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      var mrow = CToP.createElement('mrow');
+      var mo = CToP.createElement('mo');
+      CToP.setTextContent(mo,'\u222B');
+      var msubsup = CToP.createElement('msubsup');
+      msubsup.appendChild(mo);
+      var mrow1 = CToP.createElement('mrow');
+      for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+        if (qualifiers[i].nodeName === 'lowlimit'||
+            qualifiers[i].nodeName === 'condition'||
+            qualifiers[i].nodeName === 'domainofapplication')
+        {
+          var children = CToP.getChildren(qualifiers[i]);
+          for (var j = 0, num_children = children.length; j<num_children; j++ ) {
+            CToP.applyTransform(mrow1,children[j],0);
+          }
+        } else {
+          var children = CToP.getChildren(qualifiers[i]);
+          if (qualifiers[i].nodeName === 'interval' && children.length === 2) {
+            CToP.applyTransform(mrow1,children[0],0);
+          }
+        }
+      }
+      msubsup.appendChild(mrow1);
+      var mrow2 = CToP.createElement('mrow');
+      for (var i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) {
+        if (qualifiers[i].nodeName === 'uplimit') {
+          var children = CToP.getChildren(qualifiers[i]);
+          for (j = 0, num_children = children.length; j<num_children; j++ ) {
+            CToP.applyTransform(mrow2,children[j],0);
+          }
+          break;
+        } else if (qualifiers[i].nodeName === 'interval' ) {
+          var children = CToP.getChildren(qualifiers[i]);
+          CToP.applyTransform(mrow2,children[children.length-1],0);
+          break;
+        }
+      }
+      msubsup.appendChild(mrow2);
+      mrow.appendChild(msubsup);
+      for (var i = 0, l = args.length; i<l; i++ ) {
+        CToP.applyTransform(mrow,args[i],0);
+      }
+      for (var i = 0, l = bvars.length; i<l; i++ ) {
+        var bvar = bvars[i];
+        var children = CToP.getChildren(bvar);
+        if (children.length) {
+          var mrow3 = CToP.createElement("mrow");
+          CToP.appendToken(mrow3,'mi','d');
+          CToP.applyTransform(mrow3,children[0],0);
+          mrow.appendChild(mrow3);
+        }
+      }
+      parentNode.appendChild(mrow);
+    },
 
-      parentNode.appendChild(outNode);
-    } else {	// f' form
+    inverse: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
       var msup = CToP.createElement('msup');
-      var mrow = CToP.createElement('mrow');
-      msup.appendChild(mrow);
-      CToP.applyTransform(mrow,args[0],0); 
-      CToP.appendToken(m,'mo','\u2032'); // tick
+      var arg = (args.length) ? args[0] : CToP.createElement('mrow');
+      CToP.applyTransform(msup,arg,precedence);
+      var mfenced = CToP.createElement('mfenced');
+      CToP.appendToken(mfenced,'mn','-1');
+      msup.appendChild(mfenced);
       parentNode.appendChild(msup);
-    }
-  }
+    },
 
-  CToP.applyTokens["partialdiff"] = function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
-    var m, mi, msup, mrow, mo, z;
-
-    var mfrac = CToP.createElement('mfrac');
-    var toprow = CToP.createElement('mrow');
-    var bottomrow = CToP.createElement('mrow');
-    mfrac.appendChild(toprow);
-    mfrac.appendChild(bottomrow);
-
-    var degreeNode, differendNode;
-
-    if(bvars.length==0 && args.length==2 && args[0].localName=='list'){
-      if(args[1].localName=='lambda') {	// `d^(n+m)/(dx^n dy^m) f` form, through a lambda
-        var degree = CToP.getChildren(args[0]).length;
-        if(degree!=1) {
-          msup = CToP.createElement('msup');
-          CToP.appendToken(msup,'mo','\u2202');	// curly d
-          CToP.appendToken(msup,'mn',degree);
-          toprow.appendChild(msup);
-        } else {
-          CToP.appendToken(toprow,'mo','\u2202');
+    quotient: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      var mrow = CToP.createElement('mrow');
+      CToP.appendToken(mrow,'mo','\u230A');
+      if (args.length) {
+        CToP.applyTransform(mrow,args[0],0);
+        CToP.appendToken(mrow,'mo','/');
+        if (args.length>1) {
+          CToP.applyTransform(mrow,args[1],0);
         }
+      }
+      CToP.appendToken(mrow,'mo','\u230B');
+      parentNode.appendChild(mrow);
+    },
 
-        var children = CToP.getChildren(args[1]);
-
-        differendNode = children[children.length - 1];	// thing being differentiated
+    factorial: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      var mrow = CToP.createElement('mrow');
+      CToP.applyTransform(mrow,args[0],4);
+      CToP.appendToken(mrow,'mo','!');
+      parentNode.appendChild(mrow);
+    },
 
-        var bvarNames = [];
-        var lambdaChildren = CToP.getChildren(args[1]);	// names of bound variables
-        var lambdaSequence = CToP.getChildren(args[0]);	// indices of bound variable names, in order
-        for(var i=0;i<lambdaChildren.length;i++){
-          if(lambdaChildren[i].localName=='bvar'){
-            bvarNames.push(CToP.getChildren(lambdaChildren[i])[0]);
-          }
+    root: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      var mr;
+      if (firstArg.nodeName === 'root' && (qualifiers.length === 0 || (qualifiers[0].nodeName === 'degree' && CToP.getTextContent(qualifiers[0]) === '2'))) {
+        mr = CToP.createElement('msqrt');
+        for (var i = 0, l = args.length; i<l; i++ ) {
+          CToP.applyTransform(mr,args[i],0);
         }
+      } else {
+        mr = CToP.createElement('mroot');
+        CToP.applyTransform(mr,args[0],0);
+        var arg = (firstArg.nodeName === 'root') ? qualifiers[0].childNodes[0] : args[1];
+        CToP.applyTransform(mr,arg,0);
+      }
+      parentNode.appendChild(mr);
+    },
 
-        var lastN = null, degree = 0;
-        function addDiff(n,degree) {
-          CToP.appendToken(bottomrow,'mo','\u2202');
-          var bvar = bvarNames[n];
-          if(degree>1) {
-            var msup = CToP.createElement('msup');
-            CToP.applyTransform(msup,bvar,0);
-            CToP.appendToken(msup,'mn',degree);
-            bottomrow.appendChild(msup);
+    diff: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      if (bvars.length) {	// d/dx form
+        var outNode;
+        var mfrac = CToP.createElement('mfrac');
+        var toprow = CToP.createElement('mrow');
+        var bottomrow = CToP.createElement('mrow');
+        mfrac.appendChild(toprow);
+        mfrac.appendChild(bottomrow);
+
+        var bvar;
+        var degreeNode;
+
+        var d = CToP.createElement('mi');
+        CToP.setTextContent(d,'d');
+
+        var children = CToP.getChildren(bvars[0]);
+        for (var j = 0, l = children.length; j<l; j++ ) {
+          if (children[j].nodeName === 'degree') {
+            var childNode = CToP.getChildren(children[j])[0];
+            if (CToP.getTextContent(childNode) != '1') {
+              degreeNode = childNode;
+              var msup = CToP.createElement('msup');
+              msup.appendChild(d);
+              d = msup;
+              CToP.applyTransform(d,degreeNode,0);
+            }
           } else {
-            CToP.applyTransform(bottomrow,bvar,0);
+            bvar = children[j];
           }
         }
-        for(var i=0;i<lambdaSequence.length;i++){
-          var n = Number(lambdaSequence[i].textContent)-1;
-          if(lastN!==null && n!=lastN) {
-            addDiff(lastN,degree);
-            degree = 0;
+        toprow.appendChild(d);
+
+        if (args.length) {
+          switch(args[0].nodeName) {
+            case 'apply':
+            case 'bind':
+            case 'reln':
+              var mrow = CToP.createElement('mrow');
+              mrow.appendChild(mfrac);
+              CToP.applyTransform(mrow,args[0],3);
+              outNode = mrow;
+              break;
+            default:
+              CToP.applyTransform(toprow,args[0],0);
+              outNode = mfrac;
           }
-          lastN = n;
-          degree += 1;
         }
-        if(lastN) {
-          addDiff(lastN,degree);
+
+        CToP.appendToken(bottomrow,'mi','d');
+
+        if (degreeNode) {
+          var msup2 = CToP.createElement('msup');
+          CToP.applyTransform(msup2,bvar,0);
+          CToP.applyTransform(msup2,degreeNode,0);
+          bottomrow.appendChild(msup2);
+        } else {
+          CToP.applyTransform(bottomrow,bvar,0);
         }
-      } else {	// `D_i_j f` form
+
+
+        parentNode.appendChild(outNode);
+      } else {	// f' form
+        var msup = CToP.createElement('msup');
         var mrow = CToP.createElement('mrow');
-        var msub = CToP.createElement('msub');
-        CToP.appendToken(msub,'mi','D');
-        var bvar = CToP.getChildren(args[0]);
-        msub.appendChild(CToP.createmfenced(bvar,'',''));
-        mrow.appendChild(msub);
-        CToP.applyTransform(mrow,args[1],0);
-        parentNode.appendChild(mrow);
-        return;
+        msup.appendChild(mrow);
+        CToP.applyTransform(mrow,args[0],0); 
+        CToP.appendToken(m,'mo','\u2032'); // tick
+        parentNode.appendChild(msup);
       }
-    } else {	// `d^(n+m)/(dx^n dy^m) f` form, with bvars
-      var msup = CToP.createElement('msup');
-      toprow.appendChild(msup);
-      CToP.appendToken(msup,'mo','\u2202');
+    },
+
+    partialdiff: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence)  {
+      var m, mi, msup, mrow, mo, z;
+
+      var mfrac = CToP.createElement('mfrac');
+      var toprow = CToP.createElement('mrow');
+      var bottomrow = CToP.createElement('mrow');
+      mfrac.appendChild(toprow);
+      mfrac.appendChild(bottomrow);
+
+      var degreeNode, differendNode;
 
-      var degreeRow = CToP.createElement('mrow');
-      msup.appendChild(degreeRow);
+      if (bvars.length === 0 && args.length === 2 && args[0].nodeName === 'list') {
+        if (args[1].nodeName === 'lambda') {	// `d^(n+m)/(dx^n dy^m) f` form, through a lambda
+          var degree = CToP.getChildren(args[0]).length;
+          if (degree != 1) {
+            msup = CToP.createElement('msup');
+            CToP.appendToken(msup,'mo','\u2202');	// curly d
+            CToP.appendToken(msup,'mn',degree);
+            toprow.appendChild(msup);
+          } else {
+            CToP.appendToken(toprow,'mo','\u2202');
+          }
 
-      var qualifier;
+          var children = CToP.getChildren(args[1]);
 
-      if(qualifiers.length && qualifiers[0].localName=='degree' && CToP.getChildren(qualifiers[0]).length){
-        qualifier = CToP.getChildren(qualifiers[0])[0];
-        CToP.applyTransform(degreeRow,qualifier,0);
-      } else {
-        var degree = 0;
-        var hadFirst = false;
-        for(var i=0;i<bvars.length;i++){
-          var children = CToP.getChildren(bvars[i]);
-          if(children.length==2){
-            for(j=0;j<2;j++){
-              if(children[j].localName=='degree') {
-                if(/^\s*\d+\s*$/.test(children[j].textContent)){
-                  degree += Number(children[j].textContent);
-                } else {
-                  if(hadFirst){
-                    CToP.appendToken(degreeRow,'mo','+');
+          differendNode = children[children.length - 1];	// thing being differentiated
+
+          var bvarNames = [];
+          var lambdaChildren = CToP.getChildren(args[1]);	// names of bound variables
+          var lambdaSequence = CToP.getChildren(args[0]);	// indices of bound variable names, in order
+          for (var i = 0, l = lambdaChildren.length; i<l; i++ ) {
+            if (lambdaChildren[i].nodeName === 'bvar') {
+              bvarNames.push(CToP.getChildren(lambdaChildren[i])[0]);
+            }
+          }
+
+          var lastN = null, degree = 0;
+          function addDiff(n,degree) {
+            CToP.appendToken(bottomrow,'mo','\u2202');
+            var bvar = bvarNames[n];
+            if (degree>1) {
+              var msup = CToP.createElement('msup');
+              CToP.applyTransform(msup,bvar,0);
+              CToP.appendToken(msup,'mn',degree);
+              bottomrow.appendChild(msup);
+            } else {
+              CToP.applyTransform(bottomrow,bvar,0);
+            }
+          }
+          for (var i = 0, l = lambdaSequence.length; i<l; i++ ) {
+            var n = Number(CToP.getTextContent(lambdaSequence[i]))-1;
+            if (lastN !== null && n != lastN) {
+              addDiff(lastN,degree);
+              degree = 0;
+            }
+            lastN = n;
+            degree += 1;
+          }
+          if (lastN) {
+            addDiff(lastN,degree);
+          }
+        } else {	// `D_i_j f` form
+          var mrow = CToP.createElement('mrow');
+          var msub = CToP.createElement('msub');
+          CToP.appendToken(msub,'mi','D');
+          var bvar = CToP.getChildren(args[0]);
+          msub.appendChild(CToP.createmfenced(bvar,'',''));
+          mrow.appendChild(msub);
+          CToP.applyTransform(mrow,args[1],0);
+          parentNode.appendChild(mrow);
+          return;
+        }
+      } else {	// `d^(n+m)/(dx^n dy^m) f` form, with bvars
+        var msup = CToP.createElement('msup');
+        toprow.appendChild(msup);
+        CToP.appendToken(msup,'mo','\u2202');
+
+        var degreeRow = CToP.createElement('mrow');
+        msup.appendChild(degreeRow);
+
+        var qualifier;
+
+        if (qualifiers.length && qualifiers[0].nodeName === 'degree' && CToP.getChildren(qualifiers[0]).length) {
+          qualifier = CToP.getChildren(qualifiers[0])[0];
+          CToP.applyTransform(degreeRow,qualifier,0);
+        } else {
+          var degree = 0;
+          var hadFirst = false;
+          for (var i = 0, l = bvars.length; i<l; i++ ) {
+            var children = CToP.getChildren(bvars[i]);
+            if (children.length === 2) {
+              for (j = 0;j<2;j++) {
+                if (children[j].nodeName === 'degree') {
+                  if (/^\s*\d+\s*$/.test(CToP.getTextContent(children[j]))) {
+                    degree += Number(CToP.getTextContent(children[j]));
+                  } else {
+                    if (hadFirst) {
+                      CToP.appendToken(degreeRow,'mo','+');
+                    }
+                    hadFirst = true;
+                    CToP.applyTransform(degreeRow,CToP.getChildren(children[j])[0],0);
                   }
-                  hadFirst = true;
-                  CToP.applyTransform(degreeRow,CToP.getChildren(children[j])[0],0);
                 }
               }
+            } else {
+              degree++;
             }
-          } else {
-            degree++;
+          }
+          if (degree>0) {
+            if (hadFirst) {
+              CToP.appendToken(degreeRow,'mo','+');
+            }   
+            CToP.appendToken(degreeRow,'mn',degree);
           }
         }
-        if(degree>0){
-          if(hadFirst){
-            CToP.appendToken(degreeRow,'mo','+');
-          }   
-          CToP.appendToken(degreeRow,'mn',degree);
-        }
-      }
 
-      if(args.length){
-        differendNode = args[0];
-      }
+        if (args.length) {
+          differendNode = args[0];
+        }
 
-      for(var i=0;i<bvars.length;i++){
-        CToP.appendToken(bottomrow,'mo','\u2202');
-        var children = CToP.getChildren(bvars[i]);
+        for (var i = 0, l = bvars.length; i<l; i++ ) {
+          CToP.appendToken(bottomrow,'mo','\u2202');
+          var children = CToP.getChildren(bvars[i]);
 
-        if(children.length==2){
-          for(j=0;j<2;j++){
-            if(children[j].localName=='degree'){
+          if (children.length === 2) {
+            for (j = 0;j<2;j++) {
+              if (children[j].nodeName === 'degree') {
                 var msup2 = CToP.createElement('msup');
                 CToP.applyTransform(msup2,children[1-j],0);
                 var bvarDegreeNode = CToP.getChildren(children[j])[0];
                 CToP.applyTransform(msup2,bvarDegreeNode,0);
                 bottomrow.appendChild(msup2);
+              }
             }
-          }
-        } else if(children.length==1) {
+          } else if (children.length === 1) {
             CToP.applyTransform(bottomrow,children[0],0);
+          }
         }
       }
-    }
-    if(differendNode) {
-      switch(differendNode.localName) {
-        case 'apply':
-        case 'bind':
-        case 'reln':
-          var mrow = CToP.createElement('mrow');
-          mrow.appendChild(mfrac);
-          CToP.applyTransform(mrow,differendNode,3);
-          outNode = mrow;
-          break;
-        default:
-          CToP.applyTransform(toprow,differendNode,0);
-          outNode = mfrac;
+      if (differendNode) {
+        switch(differendNode.nodeName) {
+          case 'apply':
+          case 'bind':
+          case 'reln':
+            var mrow = CToP.createElement('mrow');
+            mrow.appendChild(mfrac);
+            CToP.applyTransform(mrow,differendNode,3);
+            outNode = mrow;
+            break;
+          default:
+            CToP.applyTransform(toprow,differendNode,0);
+            outNode = mfrac;
+        }
+      } else {
+        outNode = mfrac;
       }
-    } else {
-      outNode = mfrac;
+      parentNode.appendChild(outNode);
     }
-    parentNode.appendChild(outNode);
-  }
+  };
+  CToP.applyTokens.size = CToP.applyTokens.card;
 
   return CToP;
 })(MathJax.Hub);
@@ -1636,15 +1704,15 @@ MathJax.Extension["MathML/content-mathml"] = (function(HUB) {
 
 MathJax.Hub.Register.StartupHook("MathML Jax Ready",function () {
 
-  var MATHML = MathJax.InputJax.MathML,
-      PARSE = MATHML.Parse.prototype;
-      var CToP = MathJax.Extension["MathML/content-mathml"];
+  var MATHML = MathJax.InputJax.MathML;
+
+  var CToP = MathJax.Extension["MathML/content-mathml"];
 
   MATHML.DOMfilterHooks.Add(function (data) {
     data.math = CToP.transformElement(data.math);
   });
 
-  MathJax.Hub.Startup.signal.Post("MathML content-mathml Ready");
+  MathJax.Hub.Startup.signal.Post("MathML/content-mathml Ready");
 });
 
 MathJax.Ajax.loadComplete("[MathJax]/extensions/MathML/content-mathml.js");