gollum 1.0.0

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

@@ -0,0 +1,43 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/autobold.js
+ *  
+ *  Adds \boldsymbol around mathematics that appears in a section
+ *  of an HTML page that is in bold.
+ *  
+ *  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 TEX = MathJax.InputJax.TeX;
+  var oldPrefilter = TEX.prefilterMath;
+  
+  TEX.prefilterMath = function (math,displaystyle,script) {
+    var span = script.parentNode.insertBefore(document.createElement("span"),script);
+    span.visibility = "hidden";
+    span.style.fontFamily = "Times, serif";
+    span.appendChild(document.createTextNode("ABCXYZabcxyz"));
+    var W = span.offsetWidth;
+    span.style.fontWeight = "bold";
+    if (span.offsetWidth == W) {math = "\\bf {"+math+"}"}
+    span.parentNode.removeChild(span);
+    return oldPrefilter.call(TEX,math,displaystyle,script);
+  };
+  
+  MathJax.Hub.Startup.signal.Post("TeX autobold Ready");
+
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/autobold.js");

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

@@ -0,0 +1,109 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/boldsymbol.js
+ *  
+ *  Implements the \boldsymbol{...} command to make bold
+ *  versions of all math characters (not just variables).
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  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;
+  
+  var BOLDVARIANT = {};
+  BOLDVARIANT[MML.VARIANT.NORMAL]    = MML.VARIANT.BOLD;
+  BOLDVARIANT[MML.VARIANT.ITALIC]    = MML.VARIANT.BOLDITALIC;
+  BOLDVARIANT[MML.VARIANT.FRAKTUR]   = MML.VARIANT.BOLDFRAKTUR;
+  BOLDVARIANT[MML.VARIANT.SCRIPT]    = MML.VARIANT.BOLDSCRIPT;
+  BOLDVARIANT[MML.VARIANT.SANSSERIF] = MML.VARIANT.BOLDSANSSERIF;
+  BOLDVARIANT["-tex-caligraphic"]    = "-tex-caligraphic-bold";
+  BOLDVARIANT["-tex-oldstyle"]       = "-tex-oldstyle-bold";
+  
+  TEXDEF.macros.boldsymbol = 'Boldsymbol';
+  
+  TEX.Parse.Augment({
+    mmlToken: function (token) {
+      if (this.stack.env.boldsymbol) {
+        var variant = token.Get("mathvariant");
+        if (variant == null) {token.mathvariant = MML.VARIANT.BOLD}
+        else {token.mathvariant = (BOLDVARIANT[variant]||variant)}
+      }
+      return token;
+    },
+    
+    Boldsymbol: function (name) {
+      var boldsymbol = this.stack.env.boldsymbol,
+          font = this.stack.env.font;
+      this.stack.env.boldsymbol = true;
+      this.stack.env.font = null;
+      var mml = this.ParseArg(name);
+      this.stack.env.font = font;
+      this.stack.env.boldsymbol = boldsymbol;
+      this.Push(mml);
+    }
+  });
+  
+});
+
+MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
+  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
+  var TEX = MathJax.InputJax.TeX;
+  var FONTS = HTMLCSS.FONTDATA.FONTS;
+  var VARIANT = HTMLCSS.FONTDATA.VARIANT;
+
+  if (HTMLCSS.fontInUse === "TeX") {
+    FONTS["MathJax_Caligraphic-bold"] = "Caligraphic/Bold/Main.js";
+
+    VARIANT["-tex-caligraphic-bold"] =
+      {fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"],
+       offsetA: 0x41, variantA: "bold-italic"};
+    VARIANT["-tex-oldstyle-bold"] =
+      {fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"]};
+
+    if (HTMLCSS.msieCheckGreek && HTMLCSS.Font.testFont({
+      family:"MathJax_Greek", weight:"bold", style:"italic", testString: HTMLCSS.msieCheckGreek
+    })) {
+      VARIANT["bold-italic"].offsetG = 0x391; VARIANT["bold-italic"].variantG = "-Greek-Bold-Italic";
+      VARIANT["-Greek-Bold-Italic"] = {fonts:["MathJax_Greek-bold-italic"]};
+      FONTS["MathJax_Greek-bold-italic"] = "Greek/BoldItalic/Main.js";
+    }
+    
+    if (MathJax.Hub.Browser.isChrome && !MathJax.Hub.Browser.versionAtLeast("5.0")) {
+      VARIANT["-tex-caligraphic-bold"].remap = {0x54: [0xE2F0,"-WinChrome"]};
+    }
+    
+  } else if (HTMLCSS.fontInUse === "STIX") {
+    VARIANT["-tex-caligraphic-bold"] = {
+      fonts:["STIXGeneral-bold-italic","STIXNonUnicode-bold-italic","STIXNonUnicode","STIXGeneral","STIXSizeOneSym"],
+      offsetA: 0xE247, noLowerCase: 1
+    };
+    VARIANT["-tex-oldstyle-bold"] = {
+      fonts:["STIXGeneral-bold","STIXNonUnicode-bold","STIXGeneral","STIXSizeOneSym"], offsetN: 0xE263,
+      remap: {0xE264: 0xE267, 0xE265: 0xE26B, 0xE266: 0xE26F, 0xE267: 0xE273,
+              0xE268: 0xE277, 0xE269: 0xE27B, 0xE26A: 0xE27F, 0xE26B: 0xE283,
+              0xE26C: 0xE287}
+    };
+  }
+  
+  MathJax.Hub.Startup.signal.Post("TeX boldsymbol Ready");
+
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/boldsymbol.js");

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

@@ -0,0 +1,65 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/mathchoice.js
+ *  
+ *  Implements the \mathchoice macro (rarely used)
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  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.mathchoice = 'MathChoice';
+
+  TEX.Parse.Augment({
+
+    MathChoice: function (name) {
+      var D  = this.ParseArg(name),
+          T  = this.ParseArg(name),
+          S  = this.ParseArg(name),
+          SS = this.ParseArg(name);
+      this.Push(MML.TeXmathchoice(D,T,S,SS));
+    }
+
+  });
+  
+  MML.TeXmathchoice = MML.mbase.Subclass({
+    type: "TeXmathchoice",
+    choice: function () {
+      var values = this.getValues("displaystyle","scriptlevel");
+      if (values.scriptlevel > 0) {return Math.min(3,values.scriptlevel + 1)}
+      return (values.displaystyle ? 0 : 1);
+    },
+    setTeXclass: function (prev) {return this.Core().setTeXclass(prev)},
+    isSpacelike: function () {return this.Core().isSpacelike()},
+    isEmbellished: function () {return this.Core().isEmbellished()},
+    Core: function () {return this.data[this.choice()]},
+    toHTML: function (span) {
+      span = this.HTMLcreateSpan(span);
+      span.bbox = this.Core().toHTML(span).bbox;
+      return span;
+    }
+  });
+  
+  MathJax.Hub.Startup.signal.Post("TeX mathchoice Ready");
+  
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mathchoice.js");

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

@@ -0,0 +1,185 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/newcommand.js
+ *  
+ *  Implements the \newcommand, \newenvironment and \def
+ *  macros, and is loaded automatically when needed.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  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 TEX = MathJax.InputJax.TeX;
+  var TEXDEF = TEX.Definitions;
+  
+  MathJax.Hub.Insert(TEXDEF,{
+    macros: {
+      newcommand:     'NewCommand',
+      newenvironment: 'NewEnvironment',
+      def:            'MacroDef'
+    }
+  })
+
+  TEX.Parse.Augment({
+
+    /*
+     *  Implement \newcommand{\name}[n]{...}
+     */
+    NewCommand: function (name) {
+      var cs = this.trimSpaces(this.GetArgument(name)),
+          n  = this.trimSpaces(this.GetBrackets(name)),
+          def = this.GetArgument(name);
+      if (n === '') {n = null}
+      if (cs.charAt(0) === "\\") {cs = cs.substr(1)}
+      if (!cs.match(/^(.|[a-z]+)$/i)) {TEX.Error("Illegal control sequence name for "+name)}
+      if (n != null && !n.match(/^[0-9]+$/)) {TEX.Error("Illegal number of parameters specified in "+name)}
+      TEXDEF.macros[cs] = ['Macro',def,n];
+    },
+    
+    /*
+     *  Implement \newenvironment{name}[n]{begincmd}{endcmd}
+     */
+    NewEnvironment: function (name) {
+      var env  = this.trimSpaces(this.GetArgument(name)),
+          n    = this.trimSpaces(this.GetBrackets(name)),
+          bdef = this.GetArgument(name),
+          edef = this.GetArgument(name);
+      if (n === '') {n = null}
+      if (n != null && !n.match(/^[0-9]+$/)) {TEX.Error("Illegal number of parameters specified in "+name)}
+      TEXDEF.environment[env] = ['BeginEnv','EndEnv',bdef,edef,n];
+    },
+    
+    /*
+     *  Implement \def command
+     */
+    MacroDef: function (name) {
+      var cs     = this.GetCSname(name),
+          params = this.GetTemplate(name,"\\"+cs),
+          def    = this.GetArgument(name);
+      if (!(params instanceof Array)) {TEXDEF.macros[cs] = ['Macro',def,params]}
+        else {TEXDEF.macros[cs] = ['MacroWithTemplate',def,params[0],params[1]]}
+    },
+    
+    /*
+     *  Get a CS name or give an error
+     */
+    GetCSname: function (cmd) {
+      var c = this.GetNext();
+      if (c !== "\\") {TEX.Error("\\ must be followed by a control sequence")}
+      var cs = this.trimSpaces(this.GetArgument(cmd));
+      return cs.substr(1);
+    },
+    
+    /*
+     *  Get a \def parameter template
+     */
+    GetTemplate: function (cmd,cs) {
+      var c, params = [], n = 0;
+      c = this.GetNext(); var i = this.i;
+      while (this.i < this.string.length) {
+        c = this.GetNext();
+        if (c === '#') {
+          if (i !== this.i) {params[n] = this.string.substr(i,this.i-i)}
+          c = this.string.charAt(++this.i);
+          if (!c.match(/^[1-9]$/)) {TEX.Error("Illegal use of # in template for "+cs)}
+          if (parseInt(c) != ++n) {TEX.Error("Parameters for "+cs+" must be numbered sequentially")}
+          i = this.i+1;
+        } else if (c === '{') {
+          if (i !== this.i) {params[n] = this.string.substr(i,this.i-i)}
+          if (params.length > 0) {return [n,params]} else {return n}
+        }
+        this.i++;
+      }
+      TEX.Error("Missing replacement string for definition of "+cmd);
+    },
+    
+    /*
+     *  Process a macro with a parameter template
+     */
+    MacroWithTemplate: function (name,text,n,params) {
+      if (n) {
+        var args = [], c = this.GetNext();
+        if (params[0] && !this.MatchParam(params[0]))
+          {TEX.Error("Use of "+name+" doesn't match its definition")}
+        for (var i = 0; i < n; i++) {args.push(this.GetParameter(name,params[i+1]))}
+        text = this.SubstituteArgs(args,text);
+      }
+      this.string = this.AddArgs(text,this.string.slice(this.i));
+      this.i = 0;
+    },
+    
+    /*
+     *  Process a user-defined environment
+     */
+    BeginEnv: function (begin,bdef,edef,n) {
+      if (n) {
+        var args = [];
+        for (var i = 0; i < n; i++) {args.push(this.GetArgument("\\begin{"+name+"}"))}
+        bdef = this.SubstituteArgs(args,bdef);
+        edef = this.SubstituteArgs(args,edef);
+      }
+      begin.edef = edef;
+      this.string = this.AddArgs(bdef,this.string.slice(this.i)); this.i = 0;
+      return begin;
+    },
+    EndEnv: function (begin,row) {
+      this.string = this.AddArgs(begin.edef,this.string.slice(this.i)); this.i = 0
+      return row;
+    },
+    
+    /*
+     *  Find a single parameter delimited by a trailing template
+     */
+    GetParameter: function (name,param) {
+      if (param == null) {return this.GetArgument(name)}
+      var i = this.i, j = 0, hasBraces = 0;
+      while (this.i < this.string.length) {
+        if (this.string.charAt(this.i) === '{') {
+          if (this.i === i) {hasBraces = 1}
+          this.GetArgument(name); j = this.i - i;
+        } else if (this.MatchParam(param)) {
+          if (hasBraces) {i++; j -= 2}
+          return this.string.substr(i,j);
+        } else {
+          this.i++; j++; hasBraces = 0;
+        }
+      }
+      TEX.Error("Runaway argument for "+name+"?");
+    },
+    
+    /*
+     *  Check if a template is at the current location.
+     *  (The match must be exact, with no spacing differences.  TeX is
+     *   a little more forgiving than this about spaces after macro names)
+     */
+    MatchParam: function (param) {
+      if (this.string.substr(this.i,param.length) !== param) {return 0}
+      this.i += param.length;
+      return 1;
+    }
+    
+  });
+  
+  TEX.Environment = function (name) {
+    TEXDEF.environment[name] = ['BeginEnv','EndEnv'].concat([].slice.call(arguments,1));
+  }
+
+  MathJax.Hub.Startup.signal.Post("TeX newcommand Ready");
+
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/newcommand.js");

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

@@ -0,0 +1,169 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/noErrors.js
+ *  
+ *  Prevents the TeX error messages from being displayed and shows the
+ *  original TeX code instead.  You can configure whether the dollar signs
+ *  are shown or not for in-line math, and whether to put all the TeX on
+ *  one line or use multiple-lines.
+ *  
+ *  To configure this extension, use
+ *  
+ *      MathJax.Hub.Configure({
+ *        TeX: {
+ *          noErrors: {
+ *            inlineDelimiters: ["",""],   // or ["$","$"] or ["\\(","\\)"]
+ *            multiLine: true,             // false for TeX on all one line
+ *            style: {
+ *              "font-family": "serif",
+ *              "font-size":   "80%",
+ *              "color":       "black",
+ *              "border":      "1px solid" 
+ *                // add any additional CSS styles that you want
+ *                //  (be sure there is no extra comma at the end of the last item)
+ *            }
+ *          }
+ *        }
+ *      });
+ *  
+ *  Display-style math is always shown in multi-line format, and without
+ *  delimiters, as it will already be set off in its own centered
+ *  paragraph, like standard display mathematics.
+ *  
+ *  The default settings place the invalid TeX in a multi-line box with a
+ *  black border.  If you want it to look as though the TeX is just part of
+ *  the paragraph, use
+ *
+ *      MathJax.Hub.Configure({
+ *        TeX: {
+ *          noErrors: {
+ *            inlineDelimiters: ["$","$"],   // or ["",""] or ["\\(","\\)"]
+ *            multiLine: false,
+ *            style: {
+ *              "font-size": "normal",
+ *              "border": ""
+ *            }
+ *          }
+ *        }
+ *      });
+ *  
+ *  You may also wish to set the font family, as the default is "serif"
+ *  
+ *  ---------------------------------------------------------------------
+ *  
+ *  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.
+ */
+
+(function () {
+  
+  //
+  //  The configuration defaults, augmented by the user settings
+  //  
+  MathJax.Extension["TeX/noErrors"] = {
+    config: MathJax.Hub.Insert({
+      multiLine: true,
+      inlineDelimiters: ["",""],     // or use ["$","$"] or ["\\(","\\)"]
+      style: {
+        "font-family": "serif",
+        "font-size":   "80%",
+        "color":       "black",
+        "border":      "1px solid"
+      }
+    },((MathJax.Hub.config.TeX||{}).noErrors||{}))
+  };
+  
+  var CONFIG = MathJax.Extension["TeX/noErrors"].config;
+  var NBSP = String.fromCharCode(0xA0);
+  
+  MathJax.Hub.Config({
+    TeX: {
+      Augment: {
+        //
+        //  Make error messages be the original TeX code
+        //  Mark them as errors and multi-line or not, and for
+        //  multi-line TeX, make spaces non-breakable (to get formatting right)
+        //
+        formatError: function (err,math,displaystyle,script) {
+          var delim = CONFIG.inlineDelimiters;
+          var multiLine = (displaystyle || CONFIG.multiLine);
+          if (!displaystyle) {math = delim[0] + math + delim[1]}
+          if (multiLine) {math = math.replace(/ /g,NBSP)} else {math = math.replace(/\n/g," ")}
+          return MathJax.ElementJax.mml.merror(math).With({isError:true, multiLine: multiLine});
+        }
+      }
+    },
+    
+    "HTML-CSS": {
+      styles: {
+        ".MathJax .merror": MathJax.Hub.Insert({
+          "font-style":       null,
+          "background-color": null,
+          "vertical-align":   (MathJax.Hub.Browser.isMSIE && CONFIG.multiLine ? "-2px" : "")
+        },CONFIG.style)
+      }
+    }
+  });
+
+})();
+  
+MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
+  var MML = MathJax.ElementJax.mml;
+  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
+  var CONFIG = MathJax.Extension["TeX/noErrors"].config;
+  
+  //
+  // Override math toHTML routine so that error messages
+  //   don't have the clipping and other unneeded overhead
+  //
+  var math_toHTML = MML.math.prototype.toHTML;
+  MML.math.Augment({
+    toHTML: function (span) {
+      if (this.data[0] && this.data[0].data[0] && this.data[0].data[0].isError) {
+        return this.data[0].data[0].toHTML(span);
+      }
+      return math_toHTML.call(this,span);
+    }
+  });
+  
+  //
+  //  Override merror toHTML routine so that it puts out the
+  //    TeX code in an inlin-block with line breaks as in the original
+  //
+  MML.merror.Augment({
+    toHTML: function (span) {
+      span = this.HTMLcreateSpan(span);
+      if (this.multiLine) {span.style.display = "inline-block"}
+      var text = this.data[0].data.join("").split(/\n/);
+      for (var i = 0, m = text.length; i < m; i++) {
+        HTMLCSS.addText(span,text[i]);
+        if (i !== m-1) {HTMLCSS.addElement(span,"br")}
+      }
+      var HD = HTMLCSS.getHD(span.parentNode), W = HTMLCSS.getW(span.parentNode);
+      if (m > 1) {
+        var H = (HD.h + HD.d)/2, x = HTMLCSS.TeX.x_height/2;
+        var scale = HTMLCSS.config.styles[".MathJax .merror"]["font-size"];
+        if (scale && scale.match(/%/)) {x *= parseInt(scale)/100}
+        span.parentNode.style.verticalAlign = HTMLCSS.Em(HD.d+(x-H));
+        HD.h = x + H; HD.d = H - x;
+      }
+      span.bbox = {h: HD.h, d: HD.d, w: W, lw: 0, rw: W};
+      return span;
+    }
+  });
+
+  MathJax.Hub.Startup.signal.Post("TeX noErrors Ready");
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/noErrors.js");