mathjax-rails 2.5.1 → 2.6.1

data/vendor/mathjax/unpacked/jax/input/AsciiMath/config.js

@@ -30,7 +30,7 @@
 
 MathJax.InputJax.AsciiMath = MathJax.InputJax({
   id: "AsciiMath",
-  version: "2.5.0",
+  version: "2.6.0",
   directory: MathJax.InputJax.directory + "/AsciiMath",
   extensionDir: MathJax.InputJax.extensionDir + "/AsciiMath",
   

data/vendor/mathjax/unpacked/jax/input/AsciiMath/jax.js

@@ -457,6 +457,9 @@ var AMsymbols = [
 {input:"\\\\", tag:"mo", output:"\\",   tex:"backslash", ttype:CONST},
 {input:"setminus", tag:"mo", output:"\\", tex:null, ttype:CONST},
 {input:"xx", tag:"mo", output:"\u00D7", tex:"times", ttype:CONST},
+{input:"|><", tag:"mo", output:"\u22C9", tex:"ltimes", ttype:CONST},
+{input:"><|", tag:"mo", output:"\u22CA", tex:"rtimes", ttype:CONST},
+{input:"|><|", tag:"mo", output:"\u22C8", tex:"bowtie", ttype:CONST},
 {input:"-:", tag:"mo", output:"\u00F7", tex:"div", ttype:CONST},
 {input:"divide",   tag:"mo", output:"-:", tex:null, ttype:DEFINITION},
 {input:"@",  tag:"mo", output:"\u2218", tex:"circ", ttype:CONST},
@@ -549,6 +552,7 @@ var AMsymbols = [
 {input:"'",   tag:"mo", output:"\u2032",  tex:"prime", ttype:CONST},
 {input:"tilde", tag:"mover", output:"~", tex:null, ttype:UNARY, acc:true},
 {input:"\\ ",  tag:"mo", output:"\u00A0", tex:null, ttype:CONST},
+{input:"frown",  tag:"mo", output:"\u2322", tex:null, ttype:CONST},
 {input:"quad", tag:"mo", output:"\u00A0\u00A0", tex:null, ttype:CONST},
 {input:"qquad", tag:"mo", output:"\u00A0\u00A0\u00A0\u00A0", tex:null, ttype:CONST},
 {input:"cdots", tag:"mo", output:"\u22EF", tex:null, ttype:CONST},
@@ -623,6 +627,8 @@ var AMsymbols = [
 {input:"frac", tag:"mfrac", output:"/",    tex:null, ttype:BINARY},
 {input:"/",    tag:"mfrac", output:"/",    tex:null, ttype:INFIX},
 {input:"stackrel", tag:"mover", output:"stackrel", tex:null, ttype:BINARY},
+{input:"overset", tag:"mover", output:"stackrel", tex:null, ttype:BINARY},
+{input:"underset", tag:"munder", output:"stackrel", tex:null, ttype:BINARY},
 {input:"_",    tag:"msub",  output:"_",    tex:null, ttype:INFIX},
 {input:"^",    tag:"msup",  output:"^",    tex:null, ttype:INFIX},
 {input:"hat", tag:"mover", output:"\u005E", tex:null, ttype:UNARY, acc:true},
@@ -929,7 +935,7 @@ function AMparseSexpr(str) { //parses str and returns [node,tailstr]
 	node.setAttribute("mathcolor",st);
 	return [node,result2[1]];
     }
-    if (symbol.input=="root" || symbol.input=="stackrel") 
+    if (symbol.input=="root" || symbol.output=="stackrel") 
       newFrag.appendChild(result2[0]);
     newFrag.appendChild(result[0]);
     if (symbol.input=="frac") newFrag.appendChild(result2[0]);
@@ -1057,8 +1063,10 @@ function AMparseExpr(str,rightbracket) {
   if (symbol.ttype == RIGHTBRACKET || symbol.ttype == LEFTRIGHT) {
 //    if (AMnestingDepth > 0) AMnestingDepth--;
     var len = newFrag.childNodes.length;
-    if (len>0 && newFrag.childNodes[len-1].nodeName == "mrow" ) { //matrix
-    	    //removed to allow row vectors: //&& len>1 && 
+    if (len>0 && newFrag.childNodes[len-1].nodeName == "mrow" 
+            && newFrag.childNodes[len-1].lastChild
+            && newFrag.childNodes[len-1].lastChild.firstChild ) { //matrix
+      	    //removed to allow row vectors: //&& len>1 && 
     	    //newFrag.childNodes[len-2].nodeName == "mo" &&
     	    //newFrag.childNodes[len-2].firstChild.nodeValue == ","
       var right = newFrag.childNodes[len-1].lastChild.firstChild.nodeValue;

data/vendor/mathjax/unpacked/jax/input/MathML/config.js

@@ -27,7 +27,7 @@
 
 MathJax.InputJax.MathML = MathJax.InputJax({
   id: "MathML",
-  version: "2.5.0",
+  version: "2.6.1",
   directory: MathJax.InputJax.directory + "/MathML",
   extensionDir: MathJax.InputJax.extensionDir + "/MathML",
   entityDir: MathJax.InputJax.directory + "/MathML/entities",

data/vendor/mathjax/unpacked/jax/input/MathML/jax.js

@@ -76,7 +76,7 @@
       var mml, type = node.nodeName.toLowerCase().replace(/^[a-z]+:/,"");
       var match = (CLASS.match(/(^| )MJX-TeXAtom-([^ ]*)/));
       if (match) {
-        mml = this.TeXAtom(match[2]);
+        mml = this.TeXAtom(match[2],match[2] === "OP" && !CLASS.match(/MJX-fixedlimits/));
       } else if (!(MML[type] && MML[type].isa && MML[type].isa(MML.mbase))) {
         MathJax.Hub.signal.Post(["MathML Jax - unknown node type",type]);
         return MML.Error(_("UnknownNodeType","Unknown node type: %1",type));
@@ -88,9 +88,9 @@
       if (MATHML.config.useMathMLspacing) {mml.useMMLspacing = 0x08}
       return mml;
     },
-    TeXAtom: function (mclass) {
+    TeXAtom: function (mclass,movablelimits) {
       var mml = MML.TeXAtom().With({texClass:MML.TEXCLASS[mclass]});
-      if (mml.texClass === MML.TEXCLASS.OP) {mml.movesupsub = mml.movablelimits = true}
+      if (movablelimits) {mml.movesupsub = mml.movablelimits = true}
       return mml;
     },
     CheckClass: function (mml,CLASS) {
@@ -351,6 +351,8 @@
       MML.mspace.Augment({mmlSelfClosing: true});
       MML.none.Augment({mmlSelfClosing: true});
       MML.mprescripts.Augment({mmlSelfClosing:true});
+      MML.maligngroup.Augment({mmlSelfClosing:true});
+      MML.malignmark.Augment({mmlSelfClosing:true});
     }
   });
   

data/vendor/mathjax/unpacked/jax/input/TeX/config.js

@@ -27,7 +27,7 @@
 
 MathJax.InputJax.TeX = MathJax.InputJax({
   id: "TeX",
-  version: "2.5.0",
+  version: "2.6.1",
   directory: MathJax.InputJax.directory + "/TeX",
   extensionDir: MathJax.InputJax.extensionDir + "/TeX",
   

data/vendor/mathjax/unpacked/jax/input/TeX/jax.js

@@ -266,6 +266,7 @@
         if (item.isEntry) {this.EndEntry(); this.clearEnv(); return false}
         if (item.isCR)    {this.EndEntry(); this.EndRow(); this.clearEnv(); return false}
         this.EndTable(); this.clearEnv();
+        var scriptlevel = this.arraydef.scriptlevel; delete this.arraydef.scriptlevel;
         var mml = MML.mtable.apply(MML,this.table).With(this.arraydef);
         if (this.frame.length === 4) {
           mml.frame = (this.frame.dashed ? "dashed" : "solid");
@@ -276,6 +277,7 @@
           if ((this.arraydef.columnlines||"none") != "none" ||
               (this.arraydef.rowlines||"none") != "none") {mml.padding = 0} // HTML-CSS jax implements this
         }
+        if (scriptlevel) {mml = MML.mstyle(mml).With({scriptlevel: scriptlevel})}
         if (this.open || this.close) {mml = TEX.fenced(this.open,mml,this.close)}
         mml = STACKITEM.mml(mml);
         if (this.requireClose) {
@@ -341,10 +343,13 @@
     type: "fn",
     checkItem: function (item) {
       if (this.data[0]) {
-        if (item.type !== "mml" || !item.data[0]) {return [this.data[0],item]}
-        if (item.data[0].isa(MML.mspace)) {return [this.data[0],item]}
-        var mml = item.data[0]; if (mml.isEmbellished()) {mml = mml.CoreMO()}
-        if ([0,0,1,1,0,1,1,0,0,0][mml.Get("texClass")]) {return [this.data[0],item]}
+        if (item.isOpen) {return true}
+        if (item.type !== "fn") {
+          if (item.type !== "mml" || !item.data[0]) {return [this.data[0],item]}
+          if (item.data[0].isa(MML.mspace)) {return [this.data[0],item]}
+          var mml = item.data[0]; if (mml.isEmbellished()) {mml = mml.CoreMO()}
+          if ([0,0,1,1,0,1,1,0,0,0][mml.Get("texClass")]) {return [this.data[0],item]}
+        }
         return [this.data[0],MML.mo(MML.entity("#x2061")).With({texClass:MML.TEXCLASS.NONE}),item];
       }
       return this.SUPER(arguments).checkItem.apply(this,arguments);
@@ -798,10 +803,12 @@
         limits:            ['Limits',1],
         nolimits:          ['Limits',0],
 
-        overline:            ['UnderOver','00AF'],
+        overline:            ['UnderOver','00AF',null,1],
         underline:           ['UnderOver','005F'],
         overbrace:           ['UnderOver','23DE',1],
         underbrace:          ['UnderOver','23DF',1],
+        overparen:           ['UnderOver','23DC'],
+        underparen:          ['UnderOver','23DD'],
         overrightarrow:      ['UnderOver','2192'],
         underrightarrow:     ['UnderOver','2192'],
         overleftarrow:       ['UnderOver','2190'],
@@ -1257,6 +1264,8 @@
         {if (mo.defaults.hasOwnProperty(id) && mi[id] != null) {mo[id] = mi[id]}}
       for (id in MML.copyAttributes)
         {if (MML.copyAttributes.hasOwnProperty(id) && mi[id] != null) {mo[id] = mi[id]}}
+      mo.lspace = mo.rspace = "0";  // prevent mo from having space in NativeMML
+      mo.useMMLspacing &= ~(mo.SPACE_ATTR.lspace | mo.SPACE_ATTR.rspace);  // don't count these explicit settings
       return mo;
     },
     
@@ -1360,6 +1369,7 @@
       }
       op.movesupsub = (limits ? true : false);
       op.Core().movablelimits = false;
+      if (op.movablelimits) op.movablelimits = false;
     },
     
     Over: function (name,open,close) {
@@ -1426,7 +1436,7 @@
       this.Push(MML.TeXAtom(MML.munderover(c,null,mml).With({accent: true})));
     },
     
-    UnderOver: function (name,c,stack) {
+    UnderOver: function (name,c,stack,noaccent) {
       var pos = {o: "over", u: "under"}[name.charAt(1)];
       var base = this.ParseArg(name);
       if (base.Get("movablelimits")) {base.movablelimits = false}
@@ -1437,7 +1447,7 @@
       var mml = MML.munderover(base,null,null);
       mml.SetData(
         mml[pos], 
-        this.mmlToken(MML.mo(MML.entity("#x"+c)).With({stretchy:true, accent:(pos==="under")}))
+        this.mmlToken(MML.mo(MML.entity("#x"+c)).With({stretchy:true, accent:!noaccent}))
       );
       if (stack) {mml = MML.TeXAtom(mml).With({texClass:MML.TEXCLASS.OP, movesupsub:true})}
       this.Push(mml.With({subsupOK:true}));
@@ -1445,10 +1455,12 @@
     
     Overset: function (name) {
       var top = this.ParseArg(name), base = this.ParseArg(name);
+      if (base.movablelimits) base.movablelimits = false;
       this.Push(MML.mover(base,top));
     },
     Underset: function (name) {
       var bot = this.ParseArg(name), base = this.ParseArg(name);
+      if (base.movablelimits) base.movablelimits = false;
       this.Push(MML.munder(base,bot));
     },
     
@@ -1679,7 +1691,7 @@
         }
         var text = string.substr(this.i,i-this.i);
         if (!text.match(/^\s*\\text[^a-zA-Z]/)) {
-          this.Push.apply(this,this.InternalMath(text));
+          this.Push.apply(this,this.InternalMath(text,0));
           this.i = i;
         }
       }
@@ -2014,49 +2026,57 @@
     
     /*
      *  Break up a string into text and math blocks
-     *  @@@ FIXME:  skip over braced groups?  @@@
-     *  @@@ FIXME:  pass environment to TEX.Parse? @@@
      */
     InternalMath: function (text,level) {
-      var def = {displaystyle: false}; if (level != null) {def.scriptlevel = level}
-      if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
-      if (!text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {return [this.InternalText(text,def)]}
-      var i = 0, k = 0, c, match = '';
-      var mml = [];
-      while (i < text.length) {
-        c = text.charAt(i++);
-        if (c === '$') {
-          if (match === '$') {
-            mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-1),{}).mml().With(def)));
-            match = ''; k = i;
-          } else if (match === '') {
-            if (k < i-1) {mml.push(this.InternalText(text.slice(k,i-1),def))}
-            match = '$'; k = i;
-          }
-        } else if (c === '}' && match === '}') {
-          mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i),{}).mml().With(def)));
-          match = ''; k = i;
-        } else if (c === '\\') {
-          if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
-            if (k < i-1) {mml.push(this.InternalText(text.slice(k,i-1),def))}
-            match = '}'; k = i-1;
-          } else {
-            c = text.charAt(i++);
-            if (c === '(' && match === '') {
-              if (k < i-2) {mml.push(this.InternalText(text.slice(k,i-2),def))}
-              match = ')'; k = i;
-            } else if (c === ')' && match === ')') {
-              mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-2),{}).mml().With(def)));
+      var def = (this.stack.env.font ? {mathvariant: this.stack.env.font} : {});
+      var mml = [], i = 0, k = 0, c, match = '', braces = 0;
+      if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {
+        while (i < text.length) {
+          c = text.charAt(i++);
+          if (c === '$') {
+            if (match === '$' && braces === 0) {
+              mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-1),{}).mml()));
+              match = ''; k = i;
+            } else if (match === '') {
+              if (k < i-1) mml.push(this.InternalText(text.slice(k,i-1),def));
+              match = '$'; k = i;
+            }
+          } else if (c === '{' && match !== '') {
+            braces++;
+          } else if (c === '}') {
+            if (match === '}' && braces === 0) {
+              mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i),{}).mml().With(def)));
               match = ''; k = i;
-            } else if (c.match(/[${}\\]/) && match === '')  {
-              i--; text = text.substr(0,i-1) + text.substr(i); // remove \ from \$, \{, \}, or \\
+            } else if (match !== '') {
+              if (braces) braces--;
+            }
+          } else if (c === '\\') {
+            if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
+              var len = RegExp["$&"].length;
+              if (k < i-1) mml.push(this.InternalText(text.slice(k,i-1),def));
+              match = '}'; k = i-1; i += len;
+            } else {
+              c = text.charAt(i++);
+              if (c === '(' && match === '') {
+                if (k < i-2) mml.push(this.InternalText(text.slice(k,i-2),def));
+                match = ')'; k = i;
+              } else if (c === ')' && match === ')' && braces === 0) {
+                mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-2),{}).mml()));
+                match = ''; k = i;
+              } else if (c.match(/[${}\\]/) && match === '')  {
+                i--; text = text.substr(0,i-1) + text.substr(i); // remove \ from \$, \{, \}, or \\
+              }
             }
           }
         }
+        if (match !== '') TEX.Error(["MathNotTerminated","Math not terminated in text box"]);
+      }
+      if (k < text.length) mml.push(this.InternalText(text.slice(k),def));
+      if (level != null) {
+        mml = [MML.mstyle.apply(MML,mml).With({displaystyle:false,scriptlevel:level})];
+      } else if (mml.length > 1) {
+        mml = [MML.mrow.apply(MML,mml)];
       }
-      if (match !== '')
-        {TEX.Error(["MathNotTerminated","Math not terminated in text box"])}
-      if (k < text.length) {mml.push(this.InternalText(text.slice(k),def))}
       return mml;
     },
     InternalText: function (text,def) {
@@ -2208,7 +2228,7 @@
     mathPalette: function (fence,side) {
       if (fence === '{' || fence === '}') {fence = "\\"+fence}
       var D = '{\\bigg'+side+' '+fence+'}', T = '{\\big'+side+' '+fence+'}';
-      return TEX.Parse('\\mathchoice'+D+T+T+T).mml();
+      return TEX.Parse('\\mathchoice'+D+T+T+T,{}).mml();
     },
     
     //

data/vendor/mathjax/unpacked/jax/output/CommonHTML/autoload/annotation-xml.js

@@ -0,0 +1,60 @@
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ *  MathJax/jax/output/CommonHTML/autoload/annotation-xm;l.js
+ *  
+ *  Implements the CommonHTML output for <annotation-xml> elements.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2015 The MathJax Consortium
+ * 
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+  var VERSION = "2.6.0";
+  var MML = MathJax.ElementJax.mml,
+      CHTML = MathJax.OutputJax.CommonHTML;
+
+  MML["annotation-xml"].Augment({
+    toCommonHTML: function (node) {
+      var encoding = this.Get("encoding");
+      node = this.CHTMLdefaultNode(node,{childOptions:{encoding:encoding}});
+      if (this.CHTML.rscale !== 1) this.CHTML.rescale(1/this.CHTML.rscale);
+      return node;
+    }
+  });
+  
+  MML.xml.Augment({
+    toCommonHTML: function (node,options) {
+      var bbox = this.CHTML = CHTML.BBOX.zero();
+      for (var i = 0, m = this.data.length; i < m; i++) 
+        {node.appendChild(this.data[i].cloneNode(true))}
+      //
+      //  Warning: causes reflow
+      //
+      var w = node.offsetWidth, h = node.offsetHeight;
+      var strut = CHTML.addElement(node,"mjx-hd-test",{style:{height:h+"px"}});
+      bbox.d = bbox.b = (node.offsetHeight - h)/CHTML.em;
+      bbox.w = bbox.r = w/CHTML.em; bbox.h = bbox.t = h/CHTML.em - bbox.d;
+      node.removeChild(strut);
+    }
+  });
+  
+  MathJax.Hub.Startup.signal.Post("CommonHTML annotation-xml Ready");
+  MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/annotation-xml.js");
+});
+

data/vendor/mathjax/unpacked/jax/output/CommonHTML/autoload/maction.js

@@ -0,0 +1,178 @@
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ *  MathJax/jax/output/CommonHTML/autoload/maction.js
+ *  
+ *  Implements the CommonHTML output for <maction> elements.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2015 The MathJax Consortium
+ * 
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+  var VERSION = "2.6.0";
+  var MML = MathJax.ElementJax.mml,
+      CHTML = MathJax.OutputJax.CommonHTML;
+  
+  var currentTip, hover, clear;
+
+  //
+  //  Add configuration for tooltips
+  //
+  var CONFIG = CHTML.config.tooltip = MathJax.Hub.Insert({
+    delayPost: 600, delayClear: 600,
+    offsetX: 10, offsetY: 5
+  },CHTML.config.tooltip||{});
+  
+  
+  MML.maction.Augment({
+    CHTMLtooltip: CHTML.addElement(document.body,"div",{id:"MathJax_CHTML_Tooltip"}),
+    
+    toCommonHTML: function (node) {
+      var selected = this.Get("selection");
+      node = this.CHTMLcreateNode(node);
+      this.CHTML = CHTML.BBOX.empty();
+      this.CHTMLhandleStyle(node);
+      this.CHTMLhandleScale(node);
+      this.CHTMLaddChild(node,selected-1,{});
+      this.CHTML.clean();
+      this.CHTMLhandleSpace(node);
+      this.CHTMLhandleBBox(node);
+      this.CHTMLhandleColor(node);
+      
+      var type = this.Get("actiontype");
+      if (this.CHTMLaction[type] && this.CHTMLaction.hasOwnProperty(type))
+        this.CHTMLaction[type].call(this,node,selected);
+
+      return node;
+    },
+    CHTMLcoreNode: function (node) {return this.CHTMLchildNode(node,0)},
+    
+    //
+    //  Implementations for the various actions
+    //
+    CHTMLaction: {
+      toggle: function (node,selection) {
+        this.selection = selection;
+        node.onclick = MathJax.Callback(["CHTMLclick",this,CHTML.jax]);
+        node.style.cursor = "pointer";
+      },
+      
+      statusline: function (node,selection) {
+        node.onmouseover = MathJax.Callback(["CHTMLsetStatus",this]);
+        node.onmouseout  = MathJax.Callback(["CHTMLclearStatus",this]);
+        node.onmouseover.autoReset = node.onmouseout.autoReset = true;
+      },
+      
+      tooltip: function(node,selection) {
+        if (this.data[1] && this.data[1].isToken) {
+          node.title = node.alt = this.data[1].data.join("");
+        } else {
+          node.onmouseover = MathJax.Callback(["CHTMLtooltipOver",this,CHTML.jax]);
+          node.onmouseout  = MathJax.Callback(["CHTMLtooltipOut",this,CHTML.jax]);
+          node.onmouseover.autoReset = node.onmouseout.autoReset = true;
+        }
+      }
+    },
+    
+    //
+    //  Handle a click on the maction element
+    //    (remove the original rendering and rerender)
+    //
+    CHTMLclick: function (jax,event) {
+      this.selection++;
+      if (this.selection > this.data.length) this.selection = 1;
+      var hover = !!jax.hover;
+      jax.Update();
+      if (hover) {
+        var span = document.getElementById(jax.inputID+"-Span");
+        MathJax.Extension.MathEvents.Hover.Hover(jax,span);
+      }
+      return MathJax.Extension.MathEvents.Event.False(event);
+    },
+    
+    //
+    //  Set/Clear the window status message
+    //
+    CHTMLsetStatus: function (event) {
+      // FIXME:  Do something better with non-token elements
+      this.messageID = MathJax.Message.Set
+        ((this.data[1] && this.data[1].isToken) ?
+             this.data[1].data.join("") : this.data[1].toString());
+    },
+    CHTMLclearStatus: function (event) {
+      if (this.messageID) MathJax.Message.Clear(this.messageID,0);
+      delete this.messageID;
+    },
+    
+    //
+    //  Handle tooltips
+    //
+    CHTMLtooltipOver: function (jax,event) {
+      if (!event) event = window.event;
+      if (clear) {clearTimeout(clear); clear = null}
+      if (hover) clearTimeout(hover);
+      var x = event.pageX; var y = event.pageY;
+      if (x == null) {
+        x = event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
+        y = event.clientY + document.body.scrollTop + document.documentElement.scrollTop;
+      }
+      var callback = MathJax.Callback(["CHTMLtooltipPost",this,jax,x+CONFIG.offsetX,y+CONFIG.offsetY])
+      hover = setTimeout(callback,CONFIG.delayPost);
+    },
+    CHTMLtooltipOut: function (jax,event) {
+      if (hover) {clearTimeout(hover); hover = null}
+      if (clear) clearTimeout(clear);
+      var callback = MathJax.Callback(["CHTMLtooltipClear",this,80]);
+      clear = setTimeout(callback,CONFIG.delayClear);
+    },
+    CHTMLtooltipPost: function (jax,x,y) {
+      hover = null; if (clear) {clearTimeout(clear); clear = null}
+      var tip = this.CHTMLtooltip;
+      tip.style.display = "block"; tip.style.opacity = "";
+//      tip.style.filter = CHTML.config.styles["#MathJax_CHTML_Tooltip"].filter;
+      if (this === currentTip) return;
+      tip.style.left = x+"px"; tip.style.top = y+"px";
+      tip.innerHTML = '<span class="mjx-chtml"><span class="mjx-math"></span></span>';
+      CHTML.getMetrics(jax);
+      try {this.data[1].toCommonHTML(tip.firstChild.firstChild)}  catch(err) {
+        if (!err.restart) throw err;
+        tip.style.display = "none";
+        MathJax.Callback.After(["CHTMLtooltipPost",this,jax,x,y],err.restart);
+        return;
+      }
+      currentTip = this;
+    },
+    CHTMLtooltipClear: function (n) {
+      var tip = this.CHTMLtooltip;
+      if (n <= 0) {
+        tip.style.display = "none";
+        tip.style.opacity = tip.style.filter = "";
+        clear = null;
+      } else {
+        tip.style.opacity = n/100;
+        tip.style.filter = "alpha(opacity="+n+")";
+        clear = setTimeout(MathJax.Callback(["CHTMLtooltipClear",this,n-20]),50);
+      }
+    }
+  });
+
+  MathJax.Hub.Startup.signal.Post("CommonHTML maction Ready");
+  MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/maction.js");
+});
+