gollum 1.0.0

data/lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/unicode.js

@@ -0,0 +1,131 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/unicode.js
+ *  
+ *  Implements the \unicode extension to TeX to allow arbitrary unicode
+ *  code points to be entered into the TeX file.  You can specify
+ *  the height and depth of the character (the width is determined by
+ *  the browser), and the default font from which to take the character.
+ *  
+ *  Examples:
+ *      \unicode{65}                        % the character 'A'
+ *      \unicode{x41}                       % the character 'A'
+ *      \unicode[.55,0.05]{x22D6}           % less-than with dot, with height .55 and depth 0.05
+ *      \unicode[.55,0.05][Geramond]{x22D6} % same taken from Geramond font
+ *      \unicode[Garamond]{x22D6}           % same, but with default height, depth of .8,.2
+ *
+ *  Once a size and font are provided for a given conde point, they need
+ *  not be specified again in subsequent \unicode calls for that character.
+ *  Note that a font list can be given, but Internet Explorer has a buggy
+ *  implementation of font-family where it only looks in the first
+ *  available font and if the glyph is not in that, it does not look at
+ *  later fonts, but goes directly to the default font as set in the
+ *  Internet-Options/Font panel.  For this reason, the default font list is
+ *  "STIXGeneral,'Arial Unicode MS'", so if the user has STIX fonts, the
+ *  symbol will be taken from that (almost all the symbols are in
+ *  STIXGeneral), otherwise Arial Unicode MS is tried.
+ *  
+ *  To configure the default font list, use
+ *  
+ *      MathJax.Hub.Configure({
+ *        TeX: {
+ *          unicode: {
+ *            fonts: "STIXGeneral,'Arial Unicode MS'"
+ *          }
+ *        }
+ *      });
+ *
+ *  The result of \unicode will have TeX class ORD (e.g., it will act like a
+ *  variable).  Use \mathbin, \mathrel, etc, to specify a different class.
+ *  
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2009 Design Science, Inc.
+ * 
+ *  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.
+ */
+
+//
+//  The configuration defaults, augmented by the user settings
+//  
+MathJax.Extension["TeX/unicode"] = {
+  unicode: {},
+  config: MathJax.Hub.Insert({
+    fonts: "STIXGeneral,'Arial Unicode MS'"
+  },((MathJax.Hub.config.TeX||{}).unicode||{}))
+};
+  
+MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
+  var TEX = MathJax.InputJax.TeX;
+  var MML = MathJax.ElementJax.mml;
+  var FONTS = MathJax.Extension["TeX/unicode"].config.fonts;
+  var UNICODE = MathJax.Extension["TeX/unicode"].unicode;
+  
+  //
+  //  Add \unicode macro
+  //
+  TEX.Definitions.macros.unicode = 'Unicode';
+  //
+  //  Implementation of \unicode in parser
+  //
+  TEX.Parse.Augment({
+    Unicode: function(name) {
+      var HD = this.GetBrackets(name), font;
+      if (HD) {
+        HD = HD.replace(/ /g,"");
+        if (HD.match(/^(\d+(\.\d*)?|\.\d+),(\d+(\.\d*)?|\.\d+)$/))
+          {HD = HD.split(/,/); font = this.GetBrackets(name)} else {font = HD; HD = null}
+      }
+      var n = this.trimSpaces(this.GetArgument(name)),
+          N = parseInt(n.match(/^x/) ? "0"+n : n);
+      UNICODE[N] = [800,200,500,0,500,{isUnknown:true, isUnicode:true, font:FONTS}];
+      if (HD) {
+        UNICODE[N][0] = Math.floor(HD[0]*1000);
+        UNICODE[N][1] = Math.floor(HD[1]*1000);
+      }
+      var variant = this.stack.env.font, def = {};
+      if (font) {
+        def.fontfamily = font;
+        if (variant) {
+          if (variant.match(/bold/))   {def.fontweight = "bold"}
+          if (variant.match(/italic/)) {def.fontstyle = "italic"}
+        }
+        UNICODE[N][5].font = font+","+FONTS
+      } else if (variant) {def.mathvariant = variant}
+      this.Push(MML.mtext(MML.entity("#"+n)).With(def));
+    }
+  });
+
+});
+    
+MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
+  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
+  var UNICODE = MathJax.Extension["TeX/unicode"].unicode;
+
+  //
+  // Override lookupChar to add unicode character to font
+  //
+  var save_lookupChar = HTMLCSS.lookupChar;
+  HTMLCSS.Augment({
+    lookupChar: function (variant,n) {
+      var font = save_lookupChar.call(this,variant,n);
+      if (font[n][5] && font[n][5].isUnknown && UNICODE[n]) {font[n] = UNICODE[n]}
+      return font;
+    }
+  });
+
+  MathJax.Hub.Startup.signal.Post("TeX unicode Ready");
+  
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/unicode.js");

data/lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/verb.js

@@ -0,0 +1,53 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/verb.js
+ *  
+ *  Implements the \verb|...| command for including text verbatim
+ *  (with no processing of macros or special characters).
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2009 Design Science, Inc.
+ * 
+ *  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("TeX Jax Ready",function () {
+  var MML = MathJax.ElementJax.mml;
+  var TEX = MathJax.InputJax.TeX;
+  var TEXDEF = TEX.Definitions;
+  
+  TEXDEF.macros.verb = 'Verb';
+
+  TEX.Parse.Augment({
+
+    /*
+     *  Implement \verb|...|
+     */
+    Verb: function (name) {
+      var c = this.GetNext(); var start = ++this.i;
+      if (c == "" ) {TEX.Error(name+" requires an argument")}
+      while (this.i < this.string.length && this.string.charAt(this.i) != c) {this.i++}
+      if (this.i == this.string.length) 
+        {TEX.Error("Can't find closing delimiter for "+name)}
+      var text = this.string.slice(start,this.i); this.i++;
+      this.Push(MML.mtext(text).With({mathvariant:MML.VARIANT.MONOSPACE}));
+    }
+    
+  });
+  
+  MathJax.Hub.Startup.signal.Post("TeX verb Ready");
+
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/verb.js");

data/lib/gollum/frontend/public/javascript/MathJax/extensions/jsMath2jax.js

@@ -0,0 +1,77 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/jsMath2jax.js
+ *  
+ *  Implements a jsMath to Jax preprocessor that locates jsMath-style
+ *  <SPAN CLASS="math">...</SPAN> and <DIV CLASS="math">...</DIV> tags
+ *  and replaces them with SCRIPT tags for processing by MathJax.
+ *  (Note: use the tex2jax preprocessor to convert TeX delimiters or 
+ *  custom delimiters to MathJax SCRIPT tags.  This preprocessor is
+ *  only for the SPAN and DIV form of jsMath delimiters).
+ *  
+ *  To use this preprocessor, include "jsMath2jax.js" in the extensions
+ *  array in your config/MathJax.js file, or the MathJax.Hub.Config() call
+ *  in your HTML document.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2010 Design Science, Inc.
+ * 
+ *  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.Extension.jsMath2jax = {
+  config: {
+    previewTeX: true,   // Set to false to prevent preview strings from being inserted
+  },
+  
+  PreProcess: function (element) {
+    if (!this.configured) {
+      MathJax.Hub.Insert(this.config,(MathJax.Hub.config.jsMath2jax||{}));
+      this.previewClass = MathJax.Hub.config.preRemoveClass;
+      this.configured = true;
+    }
+    if (typeof(element) === "string") {element = document.getElementById(element)}
+    if (!element) {element = this.config.element || document.body}
+    var span = element.getElementsByTagName("span"), i, m;
+    for (i = 0, m = span.length; i < m; i++)
+      {if (String(span[i].className).match(/\bmath\b/)) {this.ConvertMath(span[i],"")}}
+    var div = element.getElementsByTagName("div");
+    for (i = 0, m = div.length; i < m; i++)
+      {if (String(div[i].className).match(/\bmath\b/)) {this.ConvertMath(div[i],"; mode=display")}}
+  },
+  
+  ConvertMath: function (node,mode) {
+    var parent = node.parentNode,
+        script = this.CreateMathTag(mode,node.innerHTML);
+    if (node.nextSibling) {parent.insertBefore(script,node.nextSibling)}
+      else {parent.appendChild(script)}
+    if (this.config.previewTeX) {
+      node.className = String(node.className).replace(/\bmath\b/,this.previewClass);
+    } else {
+      parent.removeChild(node);
+    }
+  },
+  
+  CreateMathTag: function (mode,tex) {
+    var script = document.createElement("script");
+    script.type = "math/tex" + mode;
+    if (MathJax.Hub.Browser.isMSIE) {script.text = tex}
+      else {script.appendChild(document.createTextNode(tex))}
+    return script;
+  }
+  
+};
+
+MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.jsMath2jax]);
+MathJax.Ajax.loadComplete("[MathJax]/extensions/jsMath2jax.js");

data/lib/gollum/frontend/public/javascript/MathJax/extensions/mml2jax.js

@@ -0,0 +1,101 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/mml2jax.js
+ *  
+ *  Implements the MathML to Jax preprocessor that locates <math> nodes
+ *  within the text of a document and replaces them with SCRIPT tags
+ *  for processing by MathJax.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2010 Design Science, Inc.
+ * 
+ *  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.Extension.mml2jax = {
+  config: {
+    element: null           // The ID of the element to be processed
+                            //   (defaults to full document)
+  },
+  MMLnamespace: "http://www.w3.org/1998/Math/MathML",
+  
+  PreProcess: function (element) {
+    if (!this.configured) {
+      MathJax.Hub.Insert(this.config,(MathJax.Hub.config.mml2jax||{}));
+      this.configured = true;
+    }
+    if (typeof(element) === "string") {element = document.getElementById(element)}
+    if (!element) {element = this.config.element || document.body}
+    var math = element.getElementsByTagName("math");
+    if (math.length === 0 && element.getElementsByTagNameNS)
+      {math = element.getElementsByTagNameNS(this.MMLnamespace,"math")}
+    if (this.msieMathTagBug) {
+      for (var i = math.length-1; i >= 0; i--) {
+        if (math[i].nodeName === "MATH") {this.msieProcessMath(math[i])}
+                                    else {this.ProcessMath(math[i])}
+      }
+    } else {
+      for (var i = math.length-1; i >= 0; i--) {this.ProcessMath(math[i])}
+    }
+  },
+  
+  ProcessMath: function (math) {
+    var parent = math.parentNode;
+    var script = document.createElement("script");
+    script.type = "math/mml";
+    parent.insertBefore(script,math);
+    if (this.msieScriptBug) {
+      var html = math.outerHTML; var prefix;
+      html = html.replace(/<\?import .*?>/,"").replace(/<(\/?)m:/g,"<$1").replace(/&nbsp;/g,"&#xA0;");
+      script.text = html;
+      parent.removeChild(math);
+    } else {
+      script.appendChild(math);
+    }
+  },
+  
+  msieProcessMath: function (math) {
+    var parent = math.parentNode;
+    var script = document.createElement("script");
+    script.type = "math/mml";
+    parent.insertBefore(script,math);
+    var mml = "";
+    while (math && math.nodeName !== "/MATH") {
+      if (math.nodeName === "#text" || math.nodeName === "#comment")
+        {mml += math.nodeValue} else {mml += this.toLowerCase(math.outerHTML)}
+      var node = math;
+      math = math.nextSibling;
+      node.parentNode.removeChild(node);
+    }
+    script.text = mml + "</math>";
+  },
+  toLowerCase: function (string) {
+    var parts = string.split(/"/);
+    for (var i = 0, m = parts.length; i < m; i += 2) {parts[i] = parts[i].toLowerCase()}
+    return parts.join('"');
+  }
+  
+};
+
+MathJax.Hub.Browser.Select({
+  MSIE: function (browser) {
+    MathJax.Hub.Insert(MathJax.Extension.mml2jax,{
+      msieScriptBug: true,
+      msieMathTagBug: true
+    })
+  }
+});
+  
+MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.mml2jax]);
+MathJax.Ajax.loadComplete("[MathJax]/extensions/mml2jax.js");

data/lib/gollum/frontend/public/javascript/MathJax/extensions/tex2jax.js

@@ -0,0 +1,242 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/tex2jax.js
+ *  
+ *  Implements the TeX to Jax preprocessor that locates TeX code
+ *  within the text of a document and replaces it with SCRIPT tags
+ *  for processing by MathJax.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2009 Design Science, Inc.
+ * 
+ *  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.Extension.tex2jax = {
+  config: {
+    element: null,          // The ID of the element to be processed
+                            //   (defaults to full document)
+
+    inlineMath: [           // The start/stop pairs for in-line math
+      ['$','$'],            //  (comment out any you don't want, or add your own, but
+      ['\\(','\\)']         //  be sure that you don't have an extra comma at the end)
+    ],
+
+    displayMath: [          // The start/stop pairs for display math
+      ['$$','$$'],          //  (comment out any you don't want, or add your own, but
+      ['\\[','\\]']         //  be sure that you don't have an extra comma at the end)
+    ],
+
+    processEscapes: 0,      // set to 1 to allow \$ to produce a dollar without
+                            //   starting in-line math mode
+
+    processEnvironments: 1, // set to 1 to process \begin{xxx}...\end{xxx} outside
+                            //   of math mode
+
+    previewTeX: 1           // set to 0 to not insert MathJax_Preview spans
+
+  },
+  
+  PreProcess: function (element) {
+    if (!this.configured) {
+      MathJax.Hub.Insert(this.config,(MathJax.Hub.config.tex2jax||{}));
+      this.configured = true;
+    }
+    if (typeof(element) === "string") {element = document.getElementById(element)}
+    if (!element) {element = this.config.element || document.body}
+    this.createPatterns();
+    this.scanElement(element,element.nextSibling);
+  },
+  
+  createPatterns: function () {
+    var starts = [], i, m, config = this.config;
+    this.match = {};
+    for (i = 0, m = config.inlineMath.length; i < m; i++) {
+      starts.push(this.patternQuote(config.inlineMath[i][0]));
+      this.match[config.inlineMath[i][0]] = {
+        mode: "",
+        end: config.inlineMath[i][1],
+        pattern: this.endPattern(config.inlineMath[i][1])
+      };
+    }
+    for (i = 0, m = config.displayMath.length; i < m; i++) {
+      starts.push(this.patternQuote(config.displayMath[i][0]));
+      this.match[config.displayMath[i][0]] = {
+        mode: "; mode=display",
+        end: config.displayMath[i][1],
+        pattern: this.endPattern(config.displayMath[i][1])
+      };
+    }
+    this.start = new RegExp(
+        starts.sort(this.sortLength).join("|") + 
+        (config.processEnvironments ? "|\\\\begin\\{([^}]*)\\}" : "") + 
+        (config.processEscapes ? "|\\\\*\\\\\\\$" : ""), "g"
+    );
+  },
+  
+  patternQuote: function (s) {return s.replace(/([\^$(){}+*?\-|\[\]\:\\])/g,'\\$1')},
+  
+  endPattern: function (end) {
+    return new RegExp(this.patternQuote(end)+"|\\\\.","g");
+  },
+  
+  sortLength: function (a,b) {
+    if (a.length !== b.length) {return b.length - a.length}
+    return (a == b ? 0 : (a < b ? -1 : 1));
+  },
+  
+  scanElement: function (element,stop,ignore) {
+    var cname, tname;
+    while (element && element != stop) {
+      if (element.nodeName.toLowerCase() === '#text') {
+        if (!ignore) {element = this.scanText(element)}
+      } else {
+        cname = (typeof(element.className) === "undefined" ? "" : element.className);
+        tname = (typeof(element.tagName)   === "undefined" ? "" : element.tagName);
+        if (typeof(cname) !== "string") {cname = String(cname)} // jsxgraph uses non-string class names!
+        if (element.firstChild && !cname.match(/(^| )MathJax/) &&
+             !tname.match(/^(script|noscript|style|textarea|pre|code)$/i)) {
+          ignore = (ignore || cname.match(/(^| )tex2jax_ignore( |$)/)) &&
+                    !cname.match(/(^| )tex2jax_process( |$)/);
+          this.scanElement(element.firstChild,stop,ignore);
+        }
+      }
+      if (element) {element = element.nextSibling}
+    }
+  },
+  
+  scanText: function (element) {
+    if (element.nodeValue.replace(/\s+/,'') == '') {return element}
+    var match, prev;
+    this.search = {start: true};
+    this.pattern = this.start;
+    while (element) {
+      this.pattern.lastIndex = 0;
+      while (element && element.nodeName.toLowerCase() === '#text' &&
+            (match = this.pattern.exec(element.nodeValue))) {
+        if (this.search.start) {element = this.startMatch(match,element)}
+                          else {element = this.endMatch(match,element)}
+      }
+      if (this.search.matched) {element = this.encloseMath(element)}
+      if (element) {
+        do {prev = element; element = element.nextSibling} 
+          while (element && (element.nodeName.toLowerCase() === 'br' ||
+                             element.nodeName.toLowerCase() === '#comment'));
+        if (!element || element.nodeName !== '#text') {return prev}
+      }
+    }
+    return element;
+  },
+  
+  startMatch: function (match,element) {
+    var delim = this.match[match[0]];
+    if (delim != null) {                              // a start delimiter
+      this.search = {
+        end: delim.end, mode: delim.mode,
+        open: element, olen: match[0].length, opos: this.pattern.lastIndex - match[0].length
+      };
+      this.switchPattern(delim.pattern);
+    } else if (match[0].substr(0,6) === "\\begin") {  // \begin{...}
+      this.search = {
+        end: "\\end{"+match[1]+"}", mode: "; mode=display",
+        open: element, olen: 0, opos: this.pattern.lastIndex - match[0].length,
+        isBeginEnd: true
+      };
+      this.switchPattern(this.endPattern(this.search.end));
+    } else {                                         // escaped dollar signs
+      var dollar = match[0].replace(/\\(.)/g,'$1');
+      element.nodeValue = element.nodeValue.substr(0,match.index) + dollar +
+                          element.nodeValue.substr(match.index + match[0].length);
+      this.pattern.lastIndex -= match[0].length - dollar.length;
+    }
+    return element;
+  },
+  
+  endMatch: function (match,element) {
+    if (match[0] == this.search.end) {
+      this.search.close = element;
+      this.search.cpos = this.pattern.lastIndex;
+      this.search.clen = (this.search.isBeginEnd ? 0 : match[0].length);
+      this.search.matched = true;
+      element = this.encloseMath(element);
+      this.switchPattern(this.start);
+    }
+    return element;
+  },
+  
+  switchPattern: function (pattern) {
+    pattern.lastIndex = this.pattern.lastIndex;
+    this.pattern = pattern;
+    this.search.start = (pattern === this.start);
+  },
+  
+  encloseMath: function (element) {
+    var search = this.search, close = search.close, CLOSE;
+    if (search.cpos === close.length) {close = close.nextSibling}
+       else {close = close.splitText(search.cpos)}
+    if (!close) {CLOSE = close = search.close.parentNode.appendChild(document.createTextNode(""))}
+    if (element === search.close) {element = close}
+    search.close = close;
+    var math = search.open.splitText(search.opos);
+    while (math.nextSibling && math.nextSibling !== close) {
+      if (math.nextSibling.nodeValue !== null) {
+        if (math.nextSibling.nodeName === "#comment") {
+          math.nodeValue += math.nextSibling.nodeValue.replace(/^\[CDATA\[(.*)\]\]$/,"$1");
+        } else {
+          math.nodeValue += math.nextSibling.nodeValue;
+        }
+      } else {math.nodeValue += ' '}
+      math.parentNode.removeChild(math.nextSibling);
+    }
+    var TeX = math.nodeValue.substr(search.olen,math.nodeValue.length-search.olen-search.clen);
+    math.parentNode.removeChild(math);
+    if (this.config.previewTeX) {this.createMathPreview(search.mode,TeX)}
+    math = this.createMathTag(search.mode,TeX);
+    this.search = {}; this.pattern.lastIndex = 0;
+    if (CLOSE) {CLOSE.parentNode.removeChild(CLOSE)}
+    return math;
+  },
+  
+  insertNode: function (node) {
+    var search = this.search;
+    if (search.close && search.close.parentNode) {
+      search.close.parentNode.insertBefore(node,search.close);
+    } else if (search.open.nextSibling) {
+      search.open.parentNode.insertBefore(node,search.open.nextSibling);
+    } else {
+      search.open.parentNode.appendChild(node);
+    }
+  },
+  
+  createMathPreview: function (mode,tex) {
+    var preview = document.createElement("span");
+    preview.className = MathJax.Hub.config.preRemoveClass;
+    preview.appendChild(document.createTextNode(tex));
+    this.insertNode(preview);
+    return preview;
+  },
+  
+  createMathTag: function (mode,tex) {
+    var script = document.createElement("script");
+    script.type = "math/tex" + mode;
+    if (MathJax.Hub.Browser.isMSIE) {script.text = tex}
+      else {script.appendChild(document.createTextNode(tex))}
+    this.insertNode(script);
+    return script;
+  }
+  
+};
+
+MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.tex2jax]);
+MathJax.Ajax.loadComplete("[MathJax]/extensions/tex2jax.js");