orange-gollum 1.0.0

data/lib/orange-gollum/assets/js/MathJax/extensions/TeX/AMSmath.js

@@ -0,0 +1,376 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/AMSmath.js
+ *
+ *  Implements AMS math environments and macros.
+ *  
+ *  ---------------------------------------------------------------------
+ *  
+ *  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 STACKITEM = TEX.Stack.Item;
+  
+  var COLS = function (W) {return W.join("em ") + "em"};
+  
+  MathJax.Hub.Insert(TEXDEF,{
+    macros: {
+      mathring:   ['Accent','2DA'],  // or 0x30A
+      
+      nobreakspace: 'Tilde',
+      negmedspace:    ['Spacer',MML.LENGTH.NEGATIVEMEDIUMMATHSPACE],
+      negthickspace:  ['Spacer',MML.LENGTH.NEGATIVETHICKMATHSPACE],
+      
+      intI:       ['Macro','\\mathchoice{\\!}{}{}{}\\!\\!\\int'],
+//    iint:       ['MultiIntegral','\\int\\intI'],          // now in core TeX input jax
+//    iiint:      ['MultiIntegral','\\int\\intI\\intI'],    // now in core TeX input jax
+      iiiint:     ['MultiIntegral','\\int\\intI\\intI\\intI'],
+      idotsint:   ['MultiIntegral','\\int\\cdots\\int'],
+      
+      dddot:      ['Macro','\\mathop{#1}\\limits^{\\textstyle \\mathord{.}\\mathord{.}\\mathord{.}}',1],
+      ddddot:     ['Macro','\\mathop{#1}\\limits^{\\textstyle \\mathord{.}\\mathord{.}\\mathord{.}\\mathord{.}}',1],
+      
+      sideset:    ['Macro','\\mathop{\\mathop{\\rlap{\\phantom{#3}}}\\nolimits#1\\!\\mathop{#3}\\nolimits#2}',3],
+      
+      boxed:      ['Macro','\\fbox{$\\displaystyle{#1}$}',1],
+      
+      tag:         'HandleTag',
+      notag:       'HandleNoTag',
+      
+      substack:   ['Macro','\\begin{subarray}{c}#1\\end{subarray}',1],
+      
+      injlim:     ['Macro','\\mathop{\\rm inj\\,lim}'],
+      projlim:    ['Macro','\\mathop{\\rm proj\\,lim}'],
+      varliminf:  ['Macro','\\mathop{\\underline{\\rm lim}}'],
+      varlimsup:  ['Macro','\\mathop{\\overline{\\rm lim}}'],
+      varinjlim:  ['Macro','\\mathop{\\underrightarrow{\\rm lim\\Rule{-1pt}{0pt}{1pt}}\\Rule{0pt}{0pt}{.45em}}'],
+      varprojlim: ['Macro','\\mathop{\\underleftarrow{\\rm lim\\Rule{-1pt}{0pt}{1pt}}\\Rule{0pt}{0pt}{.45em}}'],
+      
+      DeclareMathOperator: 'HandleDeclareOp',
+      operatorname:        'HandleOperatorName',
+      
+      genfrac:     'Genfrac',
+      frac:       ['Genfrac',"","","",""],
+      tfrac:      ['Genfrac',"","","",1],
+      dfrac:      ['Genfrac',"","","",0],
+      binom:      ['Genfrac',"(",")","0em",""],
+      tbinom:     ['Genfrac',"(",")","0em",1],
+      dbinom:     ['Genfrac',"(",")","0em",0],
+      
+      cfrac:       'CFrac',
+      
+      shoveleft:  ['HandleShove',MML.ALIGN.LEFT],
+      shoveright: ['HandleShove',MML.ALIGN.RIGHT],
+      
+      xrightarrow: ['xArrow',0x2192,5,6],
+      xleftarrow:  ['xArrow',0x2190,7,3]
+    },
+    
+    environment: {
+      align:         ['AMSarray',null,true,true,  'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18])],
+      'align*':      ['AMSarray',null,false,true, 'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18])],
+      multline:      ['Multline',null,true],
+      'multline*':   ['Multline',null,false],
+      split:         ['AMSarray',null,false,false,'rl',COLS([5/18])],
+      gather:        ['AMSarray',null,true,true,  'c'],
+      'gather*':     ['AMSarray',null,false,true, 'c'],
+      
+      alignat:       ['AlignAt',null,true,true],
+      'alignat*':    ['AlignAt',null,false,true],
+      alignedat:     ['AlignAt',null,false,false],
+
+      aligned:       ['Array',null,null,null,'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18]),".5em",'D'],
+      gathered:      ['Array',null,null,null,'c',null,".5em",'D'],
+
+      subarray:      ['Array',null,null,null,null,COLS([0,0,0,0]),"0.1em",'S',1],
+      smallmatrix:   ['Array',null,null,null,'c',COLS([1/3]),".2em",'S',1]
+    },
+    
+    delimiter: {
+      '\\lvert':     ['2223',{texClass:MML.TEXCLASS.OPEN}],
+      '\\rvert':     ['2223',{texClass:MML.TEXCLASS.CLOSE}],
+      '\\lVert':     ['2225',{texClass:MML.TEXCLASS.OPEN}],
+      '\\rVert':     ['2225',{texClass:MML.TEXCLASS.CLOSE}]
+    }
+  });
+    
+
+  TEX.Parse.Augment({
+
+    /*
+     *  Add the tag to the environment to be added to the table row later
+     */
+    HandleTag: function (name) {
+      var arg = this.trimSpaces(this.GetArgument(name));
+      if (arg === "*") {arg = this.GetArgument(name)} else {arg = "("+arg+")"}
+      if (this.stack.global.notag)
+        {TEX.Error(name+" not allowed in "+this.stack.global.notag+" environment")}
+      if (this.stack.global.tag) {TEX.Error("Multiple "+name)}
+      this.stack.global.tag = MML.mtd.apply(MML,this.InternalMath(arg));
+    },
+    HandleNoTag: function (name) {
+      if (this.stack.global.tag) {delete this.stack.global.tag}
+    },
+    
+    /*
+     *  Handle \DeclareMathOperator
+     */
+    HandleDeclareOp: function (name) {
+      var limits = "";
+      var cs = this.trimSpaces(this.GetArgument(name));
+      if (cs == "*") {
+        limits = "\\limits";
+        cs = this.trimSpaces(this.GetArgument(name));
+      }
+      if (cs.charAt(0) == "\\") {cs = cs.substr(1)}
+      var op = this.GetArgument(name);
+      op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
+      TEX.Definitions.macros[cs] = ['Macro','\\mathop{\\rm '+op+'}'+limits];
+    },
+    
+    HandleOperatorName: function (name) {
+      var limits = "\\nolimits";
+      var op = this.trimSpaces(this.GetArgument(name));
+      if (op == "*") {
+        limits = "\\limits";
+        op = this.trimSpaces(this.GetArgument(name));
+      }
+      op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
+      this.string = '\\mathop{\\rm '+op+'}'+limits+" "+this.string.slice(this.i);
+      this.i = 0;
+    },
+    
+    /*
+     *  Record presence of \shoveleft and \shoveright
+     */
+    HandleShove: function (name,shove) {
+      var top = this.stack.Top();
+      if (top.type !== "multline" || top.data.length) {TEX.Error(name+" must come at the beginning of the line")}
+      top.data.shove = shove;
+    },
+    
+    /*
+     *  Handle \cfrac
+     */
+    CFrac: function (name) {
+      var lr  = this.trimSpaces(this.GetBrackets(name)),
+          num = this.GetArgument(name),
+          den = this.GetArgument(name);
+      var frac = MML.mfrac(TEX.Parse('\\strut\\textstyle{'+num+'}',this.stack.env).mml(),
+                           TEX.Parse('\\strut\\textstyle{'+den+'}',this.stack.env).mml());
+      lr = ({l:MML.ALIGN.LEFT, r:MML.ALIGN.RIGHT,"":""})[lr];
+      if (lr == null) {TEX.Error("Illegal alignment specified in "+name)}
+      if (lr) {frac.numalign = frac.denomalign = lr}
+      this.Push(frac);
+    },
+    
+    /*
+     *  Implement AMS generalized fraction
+     */
+    Genfrac: function (name,left,right,thick,style) {
+      if (left  == null) {left  = this.GetDelimiterArg(name)} else {left  = this.convertDelimiter(left)}
+      if (right == null) {right = this.GetDelimiterArg(name)} else {right = this.convertDelimiter(right)}
+      if (thick == null) {thick = this.GetArgument(name)}
+      if (style == null) {style = this.trimSpaces(this.GetArgument(name))}
+      var num = this.ParseArg(name);
+      var den = this.ParseArg(name);
+      var frac = MML.mfrac(num,den);
+      if (thick !== "") {frac.linethickness = thick}
+      if (left || right) {frac = MML.mfenced(frac).With({open: left, close: right})}
+      if (style !== "") {
+        var STYLE = (["D","T","S","SS"])[style];
+        if (STYLE == null) {TEX.Error("Bad math style for "+name)}
+        frac = MML.mstyle(frac);
+        if (STYLE === "D") {frac.displaystyle = true; frac.scriptlevel = 0}
+          else {frac.displaystyle = false; frac.scriptlevel = style - 1}
+      }
+
+      this.Push(frac);
+    },
+
+    /*
+     *  Implements multline environment (mostly handled through STACKITEM below)
+     */
+    Multline: function (begin,numbered) {
+      this.Push(begin);
+      return STACKITEM.multline().With({
+        arraydef: {
+          displaystyle: true,
+          rowspacing: ".5em",
+          width: TEX.config.MultLineWidth, columnwidth:"100%",
+          side: TEX.config.TagSide,
+          minlabelspacing: TEX.config.TagIndent
+        }
+      });
+    },
+
+    /*
+     *  Handle AMS aligned environments
+     */
+    AMSarray: function (begin,numbered,taggable,align,spacing) {
+      this.Push(begin);
+      align = align.replace(/[^clr]/g,'').split('').join(' ');
+      align = align.replace(/l/g,'left').replace(/r/g,'right').replace(/c/g,'center');
+      return STACKITEM.AMSarray(begin.name,numbered,taggable,this.stack).With({
+        arraydef: {
+          displaystyle: true,
+          rowspacing: ".5em",
+          columnalign: align,
+          columnspacing: (spacing||"1em"),
+          rowspacing: "3pt",
+          side: TEX.config.TagSide,
+          minlabelspacing: TEX.config.TagIndent
+        }
+      });
+    },
+    
+    AlignAt: function (begin,numbered,taggable) {
+      var n = this.GetArgument("\\begin{"+begin.name+"}");
+      if (n.match(/[^0-9]/)) {TEX.Error("Argument to \\begin{"+begin.name+"} must me a positive integer")}
+      align = ""; spacing = [];
+      while (n > 0) {align += "rl"; spacing.push("0em 0em"); n--}
+      spacing = spacing.join(" ");
+      if (taggable) {return this.AMSarray(begin,numbered,taggable,align,spacing)}
+      return this.Array(begin,null,null,align,spacing,".5em",'D');
+    },
+    
+    /*
+     *  Handle multiple integrals (make a mathop if followed by limits)
+     */
+    MultiIntegral: function (name,integral) {
+      var next = this.GetNext();
+      if (next === "\\") {
+        var i = this.i; next = this.GetArgument(name); this.i = i;
+        if (next === "\\limits") {
+          if (name === "\\idotsint") {integral = "\\!\\!\\mathop{\\,\\,"+integral+"}"}
+                           else {integral = "\\!\\!\\!\\mathop{\\,\\,\\,"+integral+"}"}
+        }
+      }
+      this.string = integral + " " + this.string.slice(this.i);
+      this.i = 0;
+    },
+    
+    xArrow: function (name,chr,l,r) {
+      var def = {width: "+"+(l+r)+"mu", lspace: l+"mu"};
+      var bot = this.GetBrackets(name),
+          top = this.ParseArg(name);
+      var arrow = MML.mo(MML.chars(String.fromCharCode(chr))).With({
+        stretchy: true, texClass: MML.TEXCLASS.REL
+      });
+      var mml = MML.munderover(arrow);
+      mml.SetData(mml.over,MML.mpadded(top).With(def).With({voffset:".15em"}));
+      if (bot) {
+        bot = TEX.Parse(bot,this.stack.env).mml()
+        mml.SetData(mml.under,MML.mpadded(bot).With(def).With({voffset:"-.24em"}));
+      }
+      this.Push(mml);
+    },
+    
+    /*
+     *  Get a delimiter or empty argument
+     */
+    GetDelimiterArg: function (name) {
+      var c = this.trimSpaces(this.GetArgument(name));
+      if (c == "") {return null}
+      if (!TEXDEF.delimiter[c]) {TEX.Error("Missing or unrecognized delimiter for "+name)}
+      return this.convertDelimiter(c);
+    }
+  });
+  
+  /*
+   *  Implement multline environment via a STACKITEM
+   */
+  STACKITEM.multline = STACKITEM.array.Subclass({
+    type: "multline",
+    EndEntry: function () {
+      var mtd = MML.mtd.apply(MML,this.data);
+      if (this.data.shove) {mtd.columnalign = this.data.shove}
+      this.row.push(mtd);
+      this.data = [];
+    },
+    EndRow: function () {
+      if (this.row.length != 1) {TEX.Error("multline rows must have exactly one column")}
+      this.table.push(this.row); this.row = [];
+    },
+    EndTable: function () {
+      this.SUPER(arguments).EndTable.call(this);
+      if (this.table.length) {
+        var m = this.table.length-1, i;
+        if (!this.table[0][0].columnalign) {this.table[0][0].columnalign = MML.ALIGN.LEFT}
+        if (!this.table[m][0].columnalign) {this.table[m][0].columnalign = MML.ALIGN.RIGHT}
+        var mtr = MML.mtr;
+        if (this.global.tag) {
+          this.table[0] = [this.global.tag].concat(this.table[0]);
+          delete this.global.tag; mtr = MML.mlabeledtr;
+        }
+        this.table[0] = mtr.apply(MML,this.table[0]);
+        for (i = 1, m = this.table.length; i < m; i++)
+          {this.table[i] = MML.mtr.apply(MML,this.table[i])}
+      }
+    }
+  });
+  
+  STACKITEM.AMSarray = STACKITEM.array.Subclass({
+    type: "AMSarray",
+    Init: function (name,numbered,taggable,stack) {
+      this.SUPER(arguments).Init.apply(this);
+      this.numbered = numbered;
+      this.save_notag = stack.global.notag;
+      stack.global.notag = (taggable ? null : name);
+    },
+    EndRow: function () {
+      var mtr = MML.mtr;
+      if (this.global.tag) {
+        this.row = [this.global.tag].concat(this.row);
+        mtr = MML.mlabeledtr;
+        delete this.global.tag;
+      }
+      this.table.push(mtr.apply(MML,this.row)); this.row = [];
+    },
+    EndTable: function () {
+      this.SUPER(arguments).EndTable.call(this);
+      this.global.notag = this.save_notag;
+    }
+  });
+  
+  //
+  //  Look for \tag on a formula and make an mtable to include it
+  //
+  STACKITEM.start.Augment({
+    oldCheckItem: STACKITEM.start.prototype.checkItem,
+    checkItem: function (item) {
+      if (item.type === "stop") {
+        var mml = this.mmlData();
+        if (this.global.tag) {
+          mml = MML.mtable(MML.mlabeledtr(this.global.tag,MML.mtd(mml)));
+          mml.side = TEX.config.TagSide;
+          mml.minlabelspacing = TEX.config.TagIndent;
+          delete this.global.tag;
+        }
+        return STACKITEM.mml(mml);
+      }
+      return this.SUPER(arguments).checkItem.call(this,item);
+    }
+  });
+  
+  MathJax.Hub.Startup.signal.Post("TeX AMSmath Ready");
+  
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSmath.js");

data/lib/orange-gollum/assets/js/MathJax/extensions/TeX/AMSsymbols.js

@@ -0,0 +1,385 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/TeX/AMSsymbols.js
+ *  
+ *  Implements macros for accessing the AMS symbol fonts.
+ *  
+ *  ---------------------------------------------------------------------
+ *  
+ *  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;
+  
+  MathJax.Hub.Insert(MathJax.InputJax.TeX.Definitions,{
+
+    mathchar0mi: {
+      // Lowercase Greek letters
+      digamma:                '03DD',
+      varkappa:               '03F0',
+      
+      // Uppercase Greek letters
+      varGamma:               ['0393',{mathvariant: MML.VARIANT.ITALIC}],
+      varDelta:               ['0394',{mathvariant: MML.VARIANT.ITALIC}],
+      varTheta:               ['0398',{mathvariant: MML.VARIANT.ITALIC}],
+      varLambda:              ['039B',{mathvariant: MML.VARIANT.ITALIC}],
+      varXi:                  ['039E',{mathvariant: MML.VARIANT.ITALIC}],
+      varPi:                  ['03A0',{mathvariant: MML.VARIANT.ITALIC}],
+      varSigma:               ['03A3',{mathvariant: MML.VARIANT.ITALIC}],
+      varUpsilon:             ['03A5',{mathvariant: MML.VARIANT.ITALIC}],
+      varPhi:                 ['03A6',{mathvariant: MML.VARIANT.ITALIC}],
+      varPsi:                 ['03A8',{mathvariant: MML.VARIANT.ITALIC}],
+      varOmega:               ['03A9',{mathvariant: MML.VARIANT.ITALIC}],
+
+      // Hebrew letters
+      beth:                   '2136',
+      gimel:                  '2137',
+      daleth:                 '2138',
+
+      // Miscellaneous symbols
+//    hbar:                   '0127',  // in MathJax_Main
+      backprime:              ['2035',{variantForm: true}],
+      hslash:                 ['210F',{variantForm: true}],
+      varnothing:             ['2205',{variantForm: true}],
+      blacktriangle:          '25B2',
+      triangledown:           '25BD',
+      blacktriangledown:      '25BC',
+      square:                 '25A1',
+      Box:                    '25A1',
+      blacksquare:            '25A0',
+      lozenge:                '25CA',
+      Diamond:                '25CA',
+      blacklozenge:           '29EB',
+      circledS:               ['24C8',{mathvariant: MML.VARIANT.NORMAL}],
+      bigstar:                '2605',
+//    angle:                  '2220',  // in MathJax_Main
+      sphericalangle:         '2222',
+      measuredangle:          '2221',
+      nexists:                '2204',
+      complement:             '2201',
+      mho:                    '2127',
+      eth:                    ['00F0',{mathvariant: MML.VARIANT.NORMAL}],
+      Finv:                   '2132',
+      diagup:                 '2571',
+      Game:                   '2141',
+      diagdown:               '2572',
+      Bbbk:                   ['006B',{mathvariant: MML.VARIANT.DOUBLESTRUCK}],
+      
+      yen:                    '00A5',
+      circledR:               '00AE',
+      checkmark:              '2713',
+      maltese:                '2720'
+    },
+
+    mathchar0mo: {
+      // Binary operators
+      dotplus:                '2214',
+      ltimes:                 '22C9',
+      smallsetminus:          ['2216',{variantForm: true}],
+      rtimes:                 '22CA',
+      Cap:                    '22D2',
+      doublecap:              '22D2',
+      leftthreetimes:         '22CB',
+      Cup:                    '22D3',
+      doublecup:              '22D3',
+      rightthreetimes:        '22CC',
+      barwedge:               '22BC',
+      curlywedge:             '22CF',
+      veebar:                 '22BB',
+      curlyvee:               '22CE',
+      doublebarwedge:         '2A5E',
+      boxminus:               '229F',
+      circleddash:            '229D',
+      boxtimes:               '22A0',
+      circledast:             '229B',
+      boxdot:                 '22A1',
+      circledcirc:            '229A',
+      boxplus:                '229E',
+      centerdot:              '22C5',
+      divideontimes:          '22C7',
+      intercal:               '22BA',
+
+      // Binary relations
+      leqq:                   '2266',
+      geqq:                   '2267',
+      leqslant:               '2A7D',
+      geqslant:               '2A7E',
+      eqslantless:            '2A95',
+      eqslantgtr:             '2A96',
+      lesssim:                '2272',
+      gtrsim:                 '2273',
+      lessapprox:             '2A85',
+      gtrapprox:              '2A86',
+      approxeq:               '224A',
+      lessdot:                '22D6',
+      gtrdot:                 '22D7',
+      lll:                    '22D8',
+      llless:                 '22D8',
+      ggg:                    '22D9',
+      gggtr:                  '22D9',
+      lessgtr:                '2276',
+      gtrless:                '2277',
+      lesseqgtr:              '22DA',
+      gtreqless:              '22DB',
+      lesseqqgtr:             '2A8B',
+      gtreqqless:             '2A8C',
+      doteqdot:               '2251',
+      Doteq:                  '2251',
+      eqcirc:                 '2256',
+      risingdotseq:           '2253',
+      circeq:                 '2257',
+      fallingdotseq:          '2252',
+      triangleq:              '225C',
+      backsim:                '223D',
+      thicksim:               ['223C',{variantForm: true}],
+      backsimeq:              '22CD',
+      thickapprox:            '2248',
+      subseteqq:              '2AC5',
+      supseteqq:              '2AC6',
+      Subset:                 '22D0',
+      Supset:                 '22D1',
+      sqsubset:               '228F',
+      sqsupset:               '2290',
+      preccurlyeq:            '227C',
+      succcurlyeq:            '227D',
+      curlyeqprec:            '22DE',
+      curlyeqsucc:            '22DF',
+      precsim:                '227E',
+      succsim:                '227F',
+      precapprox:             '2AB7',
+      succapprox:             '2AB8',
+      vartriangleleft:        '22B2',
+      lhd:                    '22B2',
+      vartriangleright:       '22B3',
+      rhd:                    '22B3',
+      trianglelefteq:         '22B4',
+      unlhd:                  '22B4',
+      trianglerighteq:        '22B5',
+      unrhd:                  '22B5',
+      vDash:                  '22A8',
+      Vdash:                  '22A9',
+      Vvdash:                 '22AA',
+      smallsmile:             '2323',
+      shortmid:               ['2223',{variantForm: true}],
+      smallfrown:             '2322',
+      shortparallel:          ['2225',{variantForm: true}],
+      bumpeq:                 '224F',
+      between:                '226C',
+      Bumpeq:                 '224E',
+      pitchfork:              '22D4',
+      varpropto:              '221D',
+      backepsilon:            '220D',
+      blacktriangleleft:      '25C0',
+      blacktriangleright:     '25B6',
+      therefore:              '2234',
+      because:                '2235',
+      eqsim:                  '2242',
+      vartriangle:            ['25B3',{variantForm: true}],
+      Join:                   '22C8',
+
+      // Negated relations
+      nless:                  '226E',
+      ngtr:                   '226F',
+      nleq:                   '2270',
+      ngeq:                   '2271',
+      nleqslant:              ['2A87',{variantForm: true}],
+      ngeqslant:              ['2A88',{variantForm: true}],
+      nleqq:                  ['2270',{variantForm: true}],
+      ngeqq:                  ['2271',{variantForm: true}],
+      lneq:                   '2A87',
+      gneq:                   '2A88',
+      lneqq:                  '2268',
+      gneqq:                  '2269',
+      lvertneqq:              ['2268',{variantForm: true}],
+      gvertneqq:              ['2269',{variantForm: true}],
+      lnsim:                  '22E6',
+      gnsim:                  '22E7',
+      lnapprox:               '2A89',
+      gnapprox:               '2A8A',
+      nprec:                  '2280',
+      nsucc:                  '2281',
+      npreceq:                ['22E0',{variantForm: true}],
+      nsucceq:                ['22E1',{variantForm: true}],
+      precneqq:               '2AB5',
+      succneqq:               '2AB6',
+      precnsim:               '22E8',
+      succnsim:               '22E9',
+      precnapprox:            '2AB9',
+      succnapprox:            '2ABA',
+      nsim:                   '2241',
+      ncong:                  '2246',
+      nshortmid:              ['2224',{variantForm: true}],
+      nshortparallel:         ['2226',{variantForm: true}],
+      nmid:                   '2224',
+      nparallel:              '2226',
+      nvdash:                 '22AC',
+      nvDash:                 '22AD',
+      nVdash:                 '22AE',
+      nVDash:                 '22AF',
+      ntriangleleft:          '22EA',
+      ntriangleright:         '22EB',
+      ntrianglelefteq:        '22EC',
+      ntrianglerighteq:       '22ED',
+      nsubseteq:              '2288',
+      nsupseteq:              '2289',
+      nsubseteqq:             ['2288',{variantForm: true}],
+      nsupseteqq:             ['2289',{variantForm: true}],
+      subsetneq:              '228A',
+      supsetneq:              '228B',
+      varsubsetneq:           ['228A',{variantForm: true}],
+      varsupsetneq:           ['228B',{variantForm: true}],
+      subsetneqq:             '2ACB',
+      supsetneqq:             '2ACC',
+      varsubsetneqq:          ['2ACB',{variantForm: true}],
+      varsupsetneqq:          ['2ACC',{variantForm: true}],
+
+
+      // Arrows
+      leftleftarrows:         '21C7',
+      rightrightarrows:       '21C9',
+      leftrightarrows:        '21C6',
+      rightleftarrows:        '21C4',
+      Lleftarrow:             '21DA',
+      Rrightarrow:            '21DB',
+      twoheadleftarrow:       '219E',
+      twoheadrightarrow:      '21A0',
+      leftarrowtail:          '21A2',
+      rightarrowtail:         '21A3',
+      looparrowleft:          '21AB',
+      looparrowright:         '21AC',
+      leftrightharpoons:      '21CB',
+      rightleftharpoons:      ['21CC',{variantForm: true}],
+      curvearrowleft:         '21B6',
+      curvearrowright:        '21B7',
+      circlearrowleft:        '21BA',
+      circlearrowright:       '21BB',
+      Lsh:                    '21B0',
+      Rsh:                    '21B1',
+      upuparrows:             '21C8',
+      downdownarrows:         '21CA',
+      upharpoonleft:          '21BF',
+      upharpoonright:         '21BE',
+      downharpoonleft:        '21C3',
+      restriction:            '21BE',
+      multimap:               '22B8',
+      downharpoonright:       '21C2',
+      leftrightsquigarrow:    '21AD',
+      rightsquigarrow:        '21DD',
+      leadsto:                '21DD',
+      dashrightarrow:         '21E2',
+      dashleftarrow:          '21E0',
+
+      // Negated arrows
+      nleftarrow:             '219A',
+      nrightarrow:            '219B',
+      nLeftarrow:             '21CD',
+      nRightarrow:            '21CF',
+      nleftrightarrow:        '21AE',
+      nLeftrightarrow:        '21CE'
+    },
+    
+    delimiter: {
+      // corners
+      "\\ulcorner":           '250C',
+      "\\urcorner":           '2510',
+      "\\llcorner":           '2514',
+      "\\lrcorner":           '2518'
+    },
+    
+    macros: {
+      implies:    ['Macro','\\;\\Longrightarrow\\;'],
+      impliedby:  ['Macro','\\;\\Longleftarrow\\;']
+    }
+    
+  });
+  
+  var REL = MML.mo.OPTYPES.REL;
+
+  MathJax.Hub.Insert(MML.mo.prototype,{
+    OPTABLE: {
+      infix: {
+        '\u2322': REL,  // smallfrown
+        '\u2323': REL,  // smallsmile
+        '\u25B3': REL,  // vartriangle
+        '\uE006': REL,  // nshortmid
+        '\uE007': REL,  // nshortparallel
+        '\uE00C': REL,  // lvertneqq
+        '\uE00D': REL,  // gvertneqq
+        '\uE00E': REL,  // ngeqq
+        '\uE00F': REL,  // ngeqslant
+        '\uE010': REL,  // nleqslant
+        '\uE011': REL,  // nleqq
+        '\uE016': REL,  // nsubseteqq
+        '\uE017': REL,  // varsubsetneqq
+        '\uE018': REL,  // nsupseteqq
+        '\uE019': REL,  // varsupsetneqq
+        '\uE01A': REL,  // varsubsetneq
+        '\uE01B': REL,  // varsupsetneq
+        '\uE04B': REL,  // npreceq
+        '\uE04F': REL   // nsucceq
+      }
+    }
+  });
+
+  if (MathJax.Hub.Browser.isMSIE) {
+    MathJax.InputJax.TeX.Definitions.mathchar0mi.digamma  = ['03DC',{variantForm: true}];
+    MathJax.InputJax.TeX.Definitions.mathchar0mi.varkappa = ['03F0',{variantForm: true}];
+  }
+});
+
+MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
+  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
+  var TEXDEF = MathJax.InputJax.TeX.Definitions;
+  var VARIANT = HTMLCSS.FONTDATA.VARIANT;
+  if (HTMLCSS.fontInUse === "TeX") {
+    VARIANT["-TeX-variant"] = {
+      fonts: ["MathJax_AMS","MathJax_Main","MathJax_Size1"],
+      remap: {0x2268: 0xE00C, 0x2269: 0xE00D, 0x2270: 0xE011, 0x2271: 0xE00E,
+              0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2224: 0xE006, 0x2226: 0xE007,
+              0x2288: 0xE016, 0x2289: 0xE018, 0x228A: 0xE01A, 0x228B: 0xE01B,
+              0x2ACB: 0xE017, 0x2ACC: 0xE019, 0x03DC: 0xE008, 0x03F0: 0xE009}
+    };
+    if (HTMLCSS.msieIE6) {
+      MathJax.Hub.Insert(VARIANT["-TeX-variant"].remap,{
+        0x2190:[0xE2C1,"-WinIE6"], 0x2192:[0xE2C0,"-WinIE6"],
+        0x2223:[0xE2C2,"-WinIE6"], 0x2225:[0xE2C3,"-WinIE6"],
+        0x223C:[0xE2C4,"-WinIE6"], 0x25B3:[0xE2D3,"-WinIE6"]
+      });
+    }
+  }
+  if (HTMLCSS.fontInUse === "STIX") {
+    TEXDEF.mathchar0mi.varnothing = '2205';
+    TEXDEF.mathchar0mi.hslash = '210F';
+    TEXDEF.mathchar0mi.blacktriangle = '25B4';
+    TEXDEF.mathchar0mi.blacktriangledown = '25BE';
+    TEXDEF.mathchar0mi.square = '25FB';
+    TEXDEF.mathchar0mi.blacksquare = '25FC';
+    TEXDEF.mathchar0mi.vartriangle = ['25B3',{mathsize:"71%"}];
+    TEXDEF.mathchar0mi.triangledown = ['25BD',{mathsize:"71%"}];
+    TEXDEF.mathchar0mo.blacktriangleleft = '25C2';
+    TEXDEF.mathchar0mo.blacktriangleright = '25B8';
+    TEXDEF.mathchar0mo.smallsetminus = '2216';
+    MathJax.Hub.Insert(VARIANT["-STIX-variant"],{
+      remap: {0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2270: 0xE011, 0x2271: 0xE00E,
+              0x22E0: 0xE04B, 0x22E1: 0xE04F, 0x2288: 0xE016, 0x2289: 0xE018}
+    });
+  }
+  
+  MathJax.Hub.Startup.signal.Post("TeX AMSsymbols Ready");
+  
+});
+
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSsymbols.js");