gollum 1.0.0

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

@@ -0,0 +1,140 @@
+/*************************************************************
+ *
+ *  MathJax/extensions/toMathML.js
+ *  
+ *  Implements a toMathML() method for the mml Element Jax that returns
+ *  a MathML string from a given math expression.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  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.Hub.Register.LoadHook("[MathJax]/jax/element/mml/jax.js",function () {
+  var MML = MathJax.ElementJax.mml;
+  
+  MML.mbase.Augment({
+
+    toMathML: function (space) {
+      var inferred = (this.inferred && this.parent.inferRow);
+      if (space == null) {space = ""}
+      var tag = this.type, attr = this.MathMLattributes();
+      if (tag === "mspace") {return space + "<"+tag+attr+" />"}
+      var data = []; var SPACE = (this.isToken ? "" : space+(inferred ? "" : "  "));
+      for (var i = 0, m = this.data.length; i < m; i++) {
+        if (this.data[i]) {data.push(this.data[i].toMathML(SPACE))}
+          else if (!this.isToken) {data.push(SPACE+"<mrow />")}
+      }
+      if (this.isToken) {return space + "<"+tag+attr+">"+data.join("")+"</"+tag+">"}
+      if (inferred) {return data.join("\n")}
+      if (data.length === 0 || (data.length === 1 && data[0] === ""))
+        {return space + "<"+tag+attr+" />"}
+      return space + "<"+tag+attr+">\n"+data.join("\n")+"\n"+ space +"</"+tag+">";
+    },
+
+    MathMLattributes: function () {
+      var attr = [], defaults = this.defaults;
+      var copy = this.copyAttributes,
+          skip = this.skipAttributes;
+
+      if (this.type === "mstyle") {defaults = MML.math.prototype.defaults}
+      for (var id in defaults) {if (!skip[id] && defaults.hasOwnProperty(id)) {
+        var force = (id === "open" || id === "close");
+        if (this[id] != null && (force || this[id] !== defaults[id])) {
+          var value = this[id]; delete this[id];
+          if (force || this.Get(id) !== value)
+            {attr.push(id+'="'+this.quoteHTML(value)+'"')}
+          this[id] = value;
+        }
+      }}
+      for (var i = 0, m = copy.length; i < m; i++) {
+        if (this[copy[i]] != null) {attr.push(copy[i]+'="'+this.quoteHTML(this[copy[i]])+'"')}
+      }
+      if (attr.length) {return " "+attr.join(" ")} else {return ""}
+    },
+    copyAttributes: [
+      "fontfamily","fontsize","fontweight","fontstyle",
+      "color","background",
+      "id","class","href","style"
+    ],
+    skipAttributes: {texClass: 1, useHeight: 1, texprimestyle: 1},
+    
+    quoteHTML: function (string) {
+      string = String(string).split("");
+      for (var i = 0, m = string.length; i < m; i++) {
+        var n = string[i].charCodeAt(0);
+        if (n < 0x20 || n > 0x7E) {
+          string[i] = "&#x"+n.toString(16).toUpperCase()+";";
+        } else {
+          var c = {'&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;'}[string[i]];
+          if (c) {string[i] = c}
+        }
+      }
+      return string.join("");
+    }
+  });
+  
+  MML.msubsup.Augment({
+    toMathML: function (space) {
+      var tag = this.type;
+      if (this.data[this.sup] == null) {tag = "msub"}
+      if (this.data[this.sub] == null) {tag = "msup"}
+      var attr = this.MathMLattributes();
+      delete this.data[0].inferred;
+      var data = [];
+      for (var i = 0, m = this.data.length; i < m; i++)
+        {if (this.data[i]) {data.push(this.data[i].toMathML(space+"  "))}}
+      return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">";
+    }
+  });
+  
+  MML.munderover.Augment({
+    toMathML: function (space) {
+      var tag = this.type;
+      if (this.data[this.under] == null) {tag = "mover"}
+      if (this.data[this.over] == null)  {tag = "munder"}
+      var attr = this.MathMLattributes();
+      delete this.data[0].inferred;
+      var data = [];
+      for (var i = 0, m = this.data.length; i < m; i++)
+        {if (this.data[i]) {data.push(this.data[i].toMathML(space+"  "))}}
+      return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">";
+    }
+  });
+  
+  MML.TeXAtom.Augment({
+    toMathML: function (space) {
+      // FIXME:  Handle spacing using mpadded?
+      return space+"<mrow>\n"+this.data[0].toMathML(space+"  ")+"\n"+space+"</mrow>";
+    }
+  });
+  
+  MML.chars.Augment({
+    toMathML: function (space) {return (space||"") + this.quoteHTML(this.toString())}
+  });
+  
+  MML.entity.Augment({
+    toMathML: function (space) {return (space||"") + "&"+this.data[0]+";<!-- "+this.toString()+" -->"}
+  });
+  
+  MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () {
+    MML.TeXmathchoice.Augment({
+      toMathML: function (space) {return this.Core().toMathML(space)}
+    });
+  });
+  
+});
+
+MathJax.Ajax.loadComplete("[MathJax]/extensions/toMathML.js");

data/lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/jax.js

@@ -0,0 +1,1474 @@
+/*************************************************************
+ *
+ *  MathJax/jax/element/mml/jax.js
+ *  
+ *  Implements the MML ElementJax that holds the internal represetation
+ *  of the mathematics on the page.  Various InputJax will produce this
+ *  format, and the OutputJax will display it in various formats.
+ *
+ *  ---------------------------------------------------------------------
+ *  
+ *  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.ElementJax.mml = MathJax.ElementJax.Subclass({
+  mimeType: "jax/mml"
+},{
+  name: "mml",
+  version: 1.0,
+  directory: MathJax.ElementJax.directory + "/mml",
+  extensionDir: MathJax.ElementJax.extensionDir + "/mml",
+  optableDir: MathJax.ElementJax.directory + "/mml/optable"
+});
+
+MathJax.ElementJax.mml.Augment({
+  Init: function () {
+    if (arguments.length === 1 && arguments[0].type === "math") {this.root = arguments[0]}
+      else {this.root = MathJax.ElementJax.mml.math.apply(this,arguments)}
+    if (this.root.mode) {
+      if (!this.root.display && this.root.mode === "display") {this.root.display = "block"}
+      delete this.root.mode;
+    }
+  }
+},{
+  INHERIT: "_inherit_",
+  AUTO: "_auto_",
+  SIZE: {
+    INFINITY: "infinity",
+    SMALL: "small",
+    NORMAL: "normal",
+    BIG: "big"
+  },
+  COLOR: {
+    TRANSPARENT: "transparent"
+  },
+  VARIANT: {
+    NORMAL: "normal",
+    BOLD: "bold",
+    ITALIC: "italic",
+    BOLDITALIC: "bold-italic",
+    DOUBLESTRUCK: "double-struck",
+    FRAKTUR: "fraktur",
+    BOLDFRAKTUR: "bold-fraktur",
+    SCRIPT: "script",
+    BOLDSCRIPT: "bold-script",
+    SANSSERIF: "sans-serif",
+    BOLDSANSSERIF: "bold-sans-serif",
+    SANSSERIFITALIC: "sans-serif-italic",
+    SANSSERIFBOLDITALIC: "sans-serif-bold-italic",
+    MONOSPACE: "monospace",
+    INITIAL: "inital",
+    TAILED: "tailed",
+    LOOPED: "looped",
+    STRETCHED: "stretched",
+    CALIGRAPHIC: "-tex-caligraphic",
+    OLDSTYLE: "-tex-oldstyle"
+  },
+  FORM: {
+    PREFIX: "prefix",
+    INFIX: "infix",
+    POSTFIX: "postfix"
+  },
+  LINEBREAK: {
+    AUTO: "auto",
+    NEWLINE: "newline",
+    NOBREAK: "nobreak",
+    GOODBREAK: "goodbreak",
+    BADBREAK: "badbreak"
+  },
+  LINEBREAKSTYLE: {
+    BEFORE: "before",
+    AFTER: "after",
+    DUPLICATE: "duplicate",
+    INFIXLINBREAKSTYLE: "infixlinebreakstyle"
+  },
+  INDENTSTYLE: {
+    LEFT: "left",
+    CENTER: "center",
+    RIGHT: "right",
+    AUTO: "auto",
+    ID: "id",
+    INDENTSTYLE: "indentstyle"
+  },
+  INDENTOFFSET: {
+    INDENTOFFSET: "indentoffset"
+  },
+  LINETHICKNESS: {
+    THIN: "thin",
+    MEDIUM: "medium",
+    THICK: "thick"
+  },
+  NOTATION: {
+    LONGDIV: "longdiv",
+    ACTUARIAL: "actuarial",
+    RADICAL: "radical",
+    BOX: "box",
+    ROUNDEDBOX: "roundedbox",
+    CIRCLE: "circle",
+    LEFT: "left",
+    RIGHT: "right",
+    TOP: "top",
+    BOTTOM: "bottom",
+    UPDIAGONALSTRIKE: "updiagonalstrike",
+    DOWNDIAGONALSTRIKE: "downdiagonalstrike",
+    VERTICALSTRIKE: "verticalstrike",
+    HORIZONTALSTRIKE: "horizontalstrike",
+    MADRUWB: "madruwb"
+  },
+  ALIGN: {
+    TOP: "top",
+    BOTTOM: "bottom",
+    CENTER: "center",
+    BASELINE: "baseline",
+    AXIS: "axis",
+    LEFT: "left",
+    RIGHT: "right"
+  },
+  LINES: {
+    NONE: "none",
+    SOLID: "solid",
+    DASHED: "dashed"
+  },
+  SIDE: {
+    LEFT: "left",
+    RIGHT: "right",
+    LEFTOVERLAP: "leftoverlap",
+    RIGHTOVERLAP: "rightoverlap"
+  },
+  WIDTH: {
+    AUTO: "auto",
+    FIT: "fit"
+  },
+  ACTIONTYPE: {
+    TOGGLE: "toggle",
+    STATUSLINE: "statusline",
+    TOOLTIP: "tooltip",
+    INPUT: "input"
+  },
+  LENGTH: {
+    VERYVERYTHINMATHSPACE: "veryverythinmathspace",
+    VERYTHINMATHSPACE: "verythinmathspace",
+    THINMATHSPACE: "thinmathspace",
+    MEDIUMMATHSPACE: "mediummathspace",
+    THICKMATHSPACE: "thickmathspace",
+    VERYTHICKMATHSPACE: "verythickmathspace",
+    VERYVERYTHICKMATHSPACE: "veryverythickmathspace",
+    NEGATIVEVERYVERYTHINMATHSPACE: "negativeveryverythinmathspace",
+    NEGATIVEVERYTHINMATHSPACE: "negativeverythinmathspace",
+    NEGATIVETHINMATHSPACE: "negativethinmathspace",
+    NEGATIVEMEDIUMMATHSPACE: "negativemediummathspace",
+    NEGATIVETHICKMATHSPACE: "negativethickmathspace",
+    NEGATIVEVERYTHICKMATHSPACE: "negativeverythickmathspace",
+    NEGATIVEVERYVERYTHICKMATHSPACE: "negativeveryverythickmathspace"
+  },
+  OVERFLOW: {
+    LINBREAK: "linebreak",
+    SCROLL: "scroll",
+    ELIDE: "elide",
+    TRUNCATE: "truncate",
+    SCALE: "scale"
+  },
+  UNIT: {
+    EM: "em",
+    EX: "ex",
+    PX: "px",
+    IN: "in",
+    CM: "cm",
+    MM: "mm",
+    PT: "pt",
+    PC: "pc"
+  },
+  TEXCLASS: {
+    ORD:   0,
+    OP:    1,
+    BIN:   2,
+    REL:   3,
+    OPEN:  4,
+    CLOSE: 5,
+    PUNCT: 6,
+    INNER: 7,
+    VCENTER: 8,
+    NONE:   -1
+  },
+  PLANE1: String.fromCharCode(0xD835)
+});
+
+(function (MML) {
+  var FALSE = false; var TRUE = true;
+  
+  MML.mbase = MathJax.Object.Subclass({
+    type: "base", isToken: FALSE,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT
+    },
+    noInherit: {},
+    
+    Init: function () {
+      this.data = [];
+      if (this.inferRow && !(arguments.length === 1 && arguments[0].inferred))
+        {this.Append(MML.mrow().With({inferred: TRUE}))}
+      this.Append.apply(this,arguments);
+    },
+    With: function (def) {
+      for (var id in def) {if (def.hasOwnProperty(id)) {this[id] = def[id]}}
+      return this;
+    },
+    Append: function () {
+      if (this.inferRow && this.data.length) {
+        this.data[0].Append.apply(this.data[0],arguments);
+      } else {
+        for (var i = 0, m = arguments.length; i < m; i++)
+          {this.SetData(this.data.length,arguments[i])}
+      }
+    },
+    SetData: function (i,item) {
+      if (item != null) {
+        if (!(item instanceof MML.mbase))
+          {item = (this.isToken ? MML.chars(item) : MML.mtext(item))}
+        item.parent = this;
+        item.setInherit(this.inheritFromMe ? this : this.inherit);
+      }
+      this.data[i] = item;
+    },
+    Parent: function () {
+      var parent = this.parent;
+      while (parent && parent.inferred) {parent = parent.parent}
+      return parent;
+    },
+    Get: function (name,nodefault) {
+      if (typeof(this[name]) !== "undefined") {return this[name]}
+      // FIXME: should cache these values and get from cache
+      // (clear cache when appended to a new object?)
+      var parent = this.Parent();
+      if (parent && parent["adjustChild_"+name] != null)
+        {return (parent["adjustChild_"+name])(parent.childPosition(this))}
+      var obj = this.inherit; var root = obj;
+      while (obj) {
+        if (typeof(obj[name]) !== "undefined") {
+          var noInherit = obj.noInherit[this.type];
+          if (!(noInherit && noInherit[name])) {return obj[name]}
+        }
+        root = obj; obj = obj.inherit;
+      }
+      if (!nodefault) {
+        if (this.defaults[name] === MML.AUTO) {return this.autoDefault(name)}
+        if (this.defaults[name] !== MML.INHERIT && this.defaults[name] != null)
+          {return this.defaults[name]}
+        if (root) {return root.defaults[name]}
+      }
+      return null;
+    },
+    hasValue: function (name) {return (this.Get(name,true) != null)},
+    getValues: function () {
+      var values = {};
+      for (var i = 0, m = arguments.length; i < m; i++)
+        {values[arguments[i]] = this.Get(arguments[i])}
+      return values;
+    },
+    adjustChild_scriptlevel:   function (i) {return this.Get("scriptlevel")},   // always inherit from parent
+    adjustChild_displaystyle:  function (i) {return this.Get("displaystyle")},  // always inherit from parent
+    adjustChild_texprimestyle: function (i) {return this.Get("texprimestyle")}, // always inherit from parent
+    childPosition: function (child) {
+      if (child.parent.inferred) {child = child.parent}
+      for (var i = 0, m = this.data.length; i < m; i++) {if (this.data[i] === child) {return i}}
+      return null;
+    },
+    setInherit: function (obj) {
+      if (obj !== this.inherit && this.inherit == null) {
+        this.inherit = obj;
+        for (var i = 0, m = this.data.length; i < m; i++) {
+          if (this.data[i] && this.data[i].setInherit) {this.data[i].setInherit(obj)}
+        }
+      }
+    },
+    setTeXclass: function (prev) {
+      this.getPrevClass(prev);
+      return (typeof(this.texClass) !== "undefined" ? this : prev);
+    },
+    getPrevClass: function (prev) {
+      if (prev) {
+        this.prevClass = prev.Get("texClass");
+        this.prevLevel = prev.Get("scriptlevel");
+      }
+    },
+    updateTeXclass: function (core) {
+      if (core) {
+        this.prevClass = core.prevClass; delete core.prevClass;
+        this.prevLevel = core.prevLevel; delete core.prevLevel;
+        this.texClass = core.Get("texClass");
+      }
+    },
+    texSpacing: function () {
+      var prev = (this.prevClass != null ? this.prevClass : MML.TEXCLASS.NONE);
+      var tex = (this.Get("texClass") || MML.TEXCLASS.ORD);
+      if (prev === MML.TEXCLASS.NONE || tex === MML.TEXCLASS.NONE) {return ""}
+      if (prev === MML.TEXCLASS.VCENTER) {prev = MML.TEXCLASS.ORD}
+      if (tex  === MML.TEXCLASS.VCENTER) {tex  = MML.TEXCLASS.ORD}
+      var space = this.TEXSPACE[prev][tex];
+      if (this.prevLevel > 0 && this.Get("scriptlevel") > 0 && space >= 0) {return ""}
+      return this.TEXSPACELENGTH[Math.abs(space)];
+    },
+    TEXSPACELENGTH:[
+      "",
+      MML.LENGTH.THINMATHSPACE,
+      MML.LENGTH.MEDIUMMATHSPACE,
+      MML.LENGTH.THICKMATHSPACE
+    ],
+    // See TeXBook Chapter 18 (p. 170)
+    TEXSPACE: [
+      [ 0,-1, 2, 3, 0, 0, 0, 1], // ORD
+      [-1,-1, 0, 3, 0, 0, 0, 1], // OP
+      [ 2, 2, 0, 0, 2, 0, 0, 2], // BIN
+      [ 3, 3, 0, 0, 3, 0, 0, 3], // REL
+      [ 0, 0, 0, 0, 0, 0, 0, 0], // OPEN
+      [ 0,-1, 2, 3, 0, 0, 0, 1], // CLOSE
+      [ 1, 1, 0, 1, 1, 1, 1, 1], // PUNCT
+      [ 1,-1, 2, 3, 1, 0, 1, 1]  // INNER
+    ],
+    autoDefault: function (name) {return ""},
+    isSpacelike: function () {return FALSE},
+    isEmbellished: function () {return FALSE},
+    Core: function () {return this},
+    CoreMO: function () {return this},
+    array: function () {if (this.inferred) {return this.data} else {return [this]}},
+    toString: function () {return this.type+"("+this.data.join(",")+")"}
+  },{
+    childrenSpacelike: function () {
+      for (var i = 0; i < this.data.length; i++) {
+        if (!this.data[i].isSpacelike()) {return FALSE}
+      }
+      return TRUE;
+    },
+    childEmbellished: function () {
+      if (this.data.length === 0) {return FALSE}
+      return this.data[0].isEmbellished();
+    },
+    childCore: function () {return this.data[0]},
+    childCoreMO: function () {return this.data[0].CoreMO()},
+    setChildTeXclass: function (prev) {
+      prev = this.data[0].setTeXclass(prev);
+      this.updateTeXclass(this.data[0]);
+      return prev;
+    },
+    setBaseTeXclasses: function (prev) {
+      this.getPrevClass(prev); this.texClass = null;
+      if (this.isEmbellished()) {
+        prev = this.data[0].setTeXclass(prev);
+        this.updateTeXclass(this.Core());
+      } else {this.data[0].setTeXclass(); prev = this}
+      for (var i = 1, m = this.data.length; i < m; i++)
+        {if (this.data[i]) {this.data[i].setTeXclass()}}
+      return prev;
+    },
+    setSeparateTeXclasses: function (prev) {
+      this.getPrevClass(prev);
+      for (var i = 0, m = this.data.length; i < m; i++)
+        {if (this.data[i]) {this.data[i].setTeXclass()}}
+      if (this.isEmbellished()) {this.updateTeXclass(this.Core())}
+      return this;
+    }
+  });
+  
+  MML.mi = MML.mbase.Subclass({
+    type: "mi", isToken: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    defaults: {
+      mathvariant: MML.AUTO,
+      mathsize: MML.INHERIT,
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT
+    },
+    autoDefault: function (name) {
+      if (name === "mathvariant") {
+        var mi = (this.data[0]||"").toString();
+        return (mi.length === 1 || (mi.length === 2 && mi.charCodeAt(0) === this.PLANE1) ?
+                  MML.VARIANT.ITALIC : MML.VARIANT.NORMAL);
+      }
+      return "";
+    } 
+  });
+  
+  MML.mn = MML.mbase.Subclass({
+    type: "mn", isToken: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    defaults: {
+      mathvariant: MML.INHERIT,
+      mathsize: MML.INHERIT,
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT
+    }
+  });
+  
+  MML.mo = MML.mbase.Subclass({
+    type: "mo", isToken: TRUE,
+    defaults: {
+      mathvariant: MML.INHERIT,
+      mathsize: MML.INHERIT,
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      form: MML.AUTO,
+      fence: MML.AUTO,
+      separator: MML.AUTO,
+      lspace: MML.AUTO,
+      rspace: MML.AUTO,
+      stretchy: MML.AUTO,
+      symmetric: MML.AUTO,
+      maxsize: MML.AUTO,
+      minsize: MML.AUTO,
+      largeop: MML.AUTO,
+      movablelimits: MML.AUTO,
+      accent: MML.AUTO,
+      linebreak: MML.AUTO,
+      lineleading: MML.INHERIT,
+      linebreakstyle: MML.AUTO,
+      linebreakmultchar: MML.INHERIT,
+      indentstyle: MML.INHERIT,
+      indentoffset: MML.INHERIT,
+      indenttarget: MML.INHERIT,
+      indentstylefirst: MML.INHERIT,
+      indentoffsetfirst: MML.INHERIT,
+      indentstylelast: MML.INHERIT,
+      indentoffsetlast: MML.INHERIT,
+      texClass: MML.AUTO
+    },
+    defaultDef: {
+      form: MML.FORM.INFIX,
+      fence: FALSE,
+      separator: FALSE,
+      lspace: MML.LENGTH.THICKMATHSPACE,
+      rspace: MML.LENGTH.THICKMATHSPACE,
+      stretchy: FALSE,
+      symmetric: TRUE,
+      maxsize: MML.SIZE.INFINITY,
+      minsize: '0em', //'1em',
+      largeop: FALSE,
+      movablelimits: FALSE,
+      accent: FALSE,
+      texClass: MML.TEXCLASS.REL // for MML, but TeX sets ORD explicitly
+    },
+    SPACE_ATTR: {lspace: 0x01, rspace: 0x02, form: 0x04},
+    useMMLspacing: 0x07,
+    autoDefault: function (name,nodefault) {
+      var def = this.def;
+      if (!def) {
+        if (name === "form") {this.useMMLspacing &= ~this.SPACE_ATTR.form; return this.getForm()}
+        var mo = this.data.join("");
+        var forms = [this.Get("form"),MML.FORM.INFIX,MML.FORM.POSTFIX,MML.FORM.PREFIX];
+        for (var i = 0, m = forms.length; i < m; i++) {
+          var data = this.OPTABLE[forms[i]][mo];
+          if (data) {def = this.makeDef(data); break}
+        }
+        if (!def) {def = this.CheckRange(mo)}
+        if (!def && nodefault) {def = {}} else {
+          if (!def) {def = MathJax.Hub.Insert({},this.defaultDef)}
+          def.form = forms[0];
+          this.def = def;
+        }
+      }
+      this.useMMLspacing &= ~(this.SPACE_ATTR[name] || 0);
+      if (def[name] != null) {return def[name]}
+      else if (!nodefault) {return this.defaultDef[name]}
+      return "";
+    },
+    CheckRange: function (mo) {
+      var n = mo.charCodeAt(0);
+      if (mo.charAt(0) === MML.PLANE1) {n = mo.charCodeAt(1) + 0x1D400 - 0xDC00}
+      for (var i = 0, m = this.RANGES.length; i < m && this.RANGES[i][0] <= n; i++) {
+        if (n <= this.RANGES[i][1]) {
+          if (this.RANGES[i][3]) {
+            var file = MML.optableDir+"/"+this.RANGES[i][3]+".js";
+            this.RANGES[i][3] = null;
+            MathJax.Hub.RestartAfter(MathJax.Ajax.Require(file));
+          }
+          var data = (["ORD","OP","BIN","REL","OPEN","CLOSE","PUNCT","INNER"])[this.RANGES[i][2]];
+          data = this.OPTABLE.infix[mo] = MML.mo.OPTYPES[data === "BIN" ? "BIN3" : data];
+          return this.makeDef(data);
+        }
+      }
+      return null;
+    },
+    makeDef: function (data) {
+      if (data[2] == null) {data[2] = this.defaultDef.texClass}
+      if (!data[3]) {data[3] = {}}
+      var def = MathJax.Hub.Insert({},data[3]);
+      def.lspace = this.SPACE[data[0]]; def.rspace = this.SPACE[data[1]];
+      def.texClass = data[2];
+      return def;
+    },
+    getForm: function () {
+      var i, core = this, parent = this.parent, Parent = this.Parent();
+      while (Parent && Parent.isEmbellished())
+        {core = parent; parent = Parent.parent; Parent = Parent.Parent()}
+      if (parent && parent.type === "mrow" && parent.NonSpaceLength() !== 1) {
+        if (parent.FirstNonSpace() === core) {return MML.FORM.PREFIX}
+        if (parent.LastNonSpace() === core) {return MML.FORM.POSTFIX}
+      }
+      return MML.FORM.INFIX;
+    },
+    isEmbellished: function () {return TRUE},
+    setTeXclass: function (prev) {
+      this.getValues("lspace","rspace"); // sets useMMLspacing
+      if (this.useMMLspacing) {this.texClass = MML.TEXCLASS.NONE; return this}
+      this.texClass = this.Get("texClass");
+      if (prev) {this.prevClass = prev.texClass || MML.TEXCLASS.ORD; this.prevLevel = prev.Get("scriptlevel")}
+        else {this.prevClass = MML.TEXCLASS.NONE}
+      if (this.texClass === MML.TEXCLASS.BIN &&
+            (this.prevClass === MML.TEXCLASS.NONE ||
+             this.prevClass === MML.TEXCLASS.BIN ||
+             this.prevClass === MML.TEXCLASS.OP ||
+             this.prevClass === MML.TEXCLASS.REL ||
+             this.prevClass === MML.TEXCLASS.OPEN ||
+             this.prevClass === MML.TEXCLASS.PUNCT)) {
+        this.texClass = MML.TEXCLASS.ORD;
+      } else if (this.prevClass === MML.TEXCLASS.BIN &&
+                   (this.texClass === MML.TEXCLASS.REL ||
+                    this.texClass === MML.TEXCLASS.CLOSE ||
+                    this.texClass === MML.TEXCLASS.PUNCT)) {
+        prev.texClass = this.prevClass = MML.TEXCLASS.ORD;
+      }
+      return this;
+    }
+  });
+  
+  MML.mtext = MML.mbase.Subclass({
+    type: "mtext", isToken: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    defaults: {
+      mathvariant: MML.INHERIT,
+      mathsize: MML.INHERIT,
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT
+    }
+  });
+
+  MML.mspace = MML.mbase.Subclass({
+    type: "mspace", isToken: TRUE,
+    isSpacelike: function () {return TRUE},
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      width: "0em",
+      height: "0ex",
+      depth: "0ex",
+      linebreak: MML.LINEBREAK.AUTO
+    }
+  });
+
+  MML.ms = MML.mbase.Subclass({
+    type: "ms", isToken: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    defaults: {
+      mathvariant: MML.INHERIT,
+      mathsize: MML.INHERIT,
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      lquote: '"',
+      rquote: '"'
+    }
+  });
+
+  MML.mglyph = MML.mbase.Subclass({
+    type: "mglyph", isToken: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      alt: "",
+      src: "",
+      width: MML.AUTO,
+      height: MML.AUTO,
+      valign: "0em"
+    }
+  });
+
+  MML.mrow = MML.mbase.Subclass({
+    type: "mrow",
+    isSpacelike: MML.mbase.childrenSpacelike,
+    inferred: FALSE,
+    isEmbellished: function () {
+      var isEmbellished = FALSE;
+      for (var i = 0, m = this.data.length; i < m; i++) {
+        if (this.data[i] == null) continue;
+        if (this.data[i].isEmbellished()) {
+          if (isEmbellished) {return FALSE}
+          isEmbellished = TRUE; this.core = i;
+        } else if (!this.data[i].isSpacelike()) {return FALSE}
+      }
+      return isEmbellished;
+    },
+    NonSpaceLength: function () {
+      var n = 0;
+      for (var i = 0, m = this.data.length; i < m; i++) {if (!this.data[i].isSpacelike()) {n++}}
+      return n;
+    },
+    FirstNonSpace: function () {
+      for (var i = 0, m = this.data.length; i < m; i++)
+        {if (!this.data[i].isSpacelike()) {return this.data[i]}}
+      return null;
+    },
+    LastNonSpace: function () {
+      for (var i = this.data.length-1; i >= 0; i--)
+        {if (!this.data[i].isSpacelike()) {return this.data[i]}}
+      return null;
+    },
+    Core: function () {
+      if (!(this.isEmbellished()) || typeof(this.core) === "undefined") {return this}
+      return this.data[this.core];
+    },
+    CoreMO: function () {
+      if (!(this.isEmbellished()) || typeof(this.core) === "undefined") {return this}
+      return this.data[this.core].CoreMO();
+    },
+    toString: function () {
+      if (this.inferred) {return '[' + this.data.join(',') + ']'}
+      return this.SUPER(arguments).toString.call(this);
+    },
+    setTeXclass: function (prev) {
+      for (var i = 0, m = this.data.length; i < m; i++)
+        {if (this.data[i]) {prev = this.data[i].setTeXclass(prev)}}
+      if (this.data[0]) {this.updateTeXclass(this.data[0])}
+      return prev;
+    }
+  });
+
+  MML.mfrac = MML.mbase.Subclass({
+    type: "mfrac", num: 0, den: 1,
+    texClass: MML.TEXCLASS.INNER,
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      linethickness: MML.LINETHICKNESS.MEDIUM,
+      numalign: MML.ALIGN.CENTER,
+      denomalign: MML.ALIGN.CENTER,
+      bevelled: FALSE
+    },
+    adjustChild_displaystyle: function (n) {return FALSE},
+    adjustChild_scriptlevel: function (n) {
+      var level = this.Get("scriptlevel");
+      if (!this.Get("displaystyle") || level > 0) {level++}
+      return level;
+    },
+    adjustChild_texprimestyle: function (n) {
+      if (n == this.den) {return true}
+      return this.Get("texprimestyle");
+    },
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.msqrt = MML.mbase.Subclass({
+    type: "msqrt",
+    inferRow: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    setTeXclass: MML.mbase.setSeparateTeXclasses,
+    adjustChild_texprimestyle: function (n) {return TRUE}
+  });
+
+  MML.mroot = MML.mbase.Subclass({
+    type: "mroot",
+    texClass: MML.TEXCLASS.ORD,
+    adjustChild_displaystyle: function (n) {
+      if (n === 1) {return FALSE}
+      return this.Get("displaystyle");
+    },
+    adjustChild_scriptlevel: function (n) {
+      var level = this.Get("scriptlevel");
+      if (n === 1) {level += 2}
+      return level;
+    },
+    adjustChild_texprimestyle: function (n) {
+      if (n === 0) {return TRUE};
+      return this.Get("texprimestyle");
+    },
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.mstyle = MML.mbase.Subclass({
+    type: "mstyle",
+    isSpacelike: MML.mbase.childrenSpacelike,
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    inferRow: TRUE,
+    defaults: {
+      scriptlevel: MML.INHERIT,
+      displaystyle: MML.INHERIT,
+      scriptsizemultiplier: Math.sqrt(1/2),
+      scriptminsize: "8pt",
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      infixlinebreakstyle: MML.LINEBREAKSTYLE.BEFORE,
+      decimalseparator: "."
+    },
+    adjustChild_scriptlevel: function (n) {
+      var level = this.scriptlevel;
+      if (level == null) {
+        level = this.Get("scriptlevel");
+      } else if (String(level).match(/^ *[-+]/)) {
+        delete this.scriptlevel;
+        var LEVEL = this.Get("scriptlevel");
+        this.scriptlevel = level;
+        level = LEVEL + parseInt(level);
+      }
+      return level;
+    },
+    inheritFromMe: TRUE,
+    noInherit: {
+      mpadded: {width: TRUE, height: TRUE, depth: TRUE, lspace: TRUE, voffset: TRUE},
+      mtable:  {width: TRUE, height: TRUE, depth: TRUE}
+    },
+    setTeXclass: MML.mbase.setChildTeXclass
+  });
+
+  MML.merror = MML.mbase.Subclass({
+    type: "merror",
+    inferRow: TRUE,
+    texClass: MML.TEXCLASS.ORD
+  });
+
+  MML.mpadded = MML.mbase.Subclass({
+    type: "mpadded",
+    inferRow: TRUE,
+    isSpacelike: MML.mbase.childrenSpacelike,
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      width: "",
+      height: "",
+      depth: "",
+      lspace: 0,
+      voffset: 0
+    },
+    setTeXclass: MML.mbase.setChildTeXclass
+  });
+
+  MML.mphantom = MML.mbase.Subclass({
+    type: "mphantom",
+    texClass: MML.TEXCLASS.ORD,
+    inferRow: TRUE,
+    isSpacelike: MML.mbase.childrenSpacelike,
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    setTeXclass: MML.mbase.setChildTeXclass
+  });
+
+  MML.mfenced = MML.mbase.Subclass({
+    type: "mfenced",
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      open: '(',
+      close: ')',
+      separators: ','
+    },
+    texClass: MML.TEXCLASS.OPEN,
+    setTeXclass: function (prev) {
+      this.getPrevClass(prev);
+      var values = this.getValues("open","close","separators");
+      values.open = values.open.replace(/[ \t\n\r]/g,"");
+      values.close = values.close.replace(/[ \t\n\r]/g,"");
+      values.separators = values.separators.replace(/[ \t\n\r]/g,"");
+      // create a fake node for the open item
+      if (values.open !== "") {
+        this.SetData("open",MML.mo(values.open).With({stretchy:true, texClass:MML.TEXCLASS.OPEN}));
+        prev = this.data.open.setTeXclass(prev);
+      }
+      // get the separators
+      if (values.separators !== "") {
+        while (values.separators.length < this.data.length)
+          {values.separators += values.separators.charAt(values.separators.length-1)}
+      }
+      // handle the first item, if any
+      if (this.data[0]) {prev = this.data[0].setTeXclass(prev)}
+      // add fake nodes for separators and handle the following item
+      for (var i = 1, m = this.data.length; i < m; i++) {
+        if (this.data[i]) {
+          if (values.separators !== "") {
+            this.SetData("sep"+i,MML.mo(values.separators.charAt(i-1)));
+            prev = this.data["sep"+i].setTeXclass(prev);
+          }
+          prev = this.data[i].setTeXclass(prev);
+        }
+      }
+      // create fake node for the close item
+      if (values.close !== "") {
+        this.SetData("close",MML.mo(values.close).With({stretchy:true, texClass:MML.TEXCLASS.CLOSE}));
+        prev = this.data.close.setTeXclass(prev);
+      }
+      // get the data from the open item
+      this.updateTeXclass(this.data.open);
+      return prev;
+    }
+  });
+
+  MML.menclose = MML.mbase.Subclass({
+    type: "menclose",
+    inferRow: TRUE,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      notation: MML.NOTATION.LONGDIV,
+      texClass: MML.TEXCLASS.ORD
+    },
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.msubsup = MML.mbase.Subclass({
+    type: "msubsup", base: 0, sub: 1, sup: 2,
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      subscriptshift: "",
+      superscriptshift: "",
+      texClass: MML.AUTO
+    },
+    autoDefault: function (name) {
+      if (name === "texClass")
+        {return (this.isEmbellished() ? this.CoreMO().Get(name) : MML.TEXCLASS.ORD)}
+      return 0;
+    },
+    adjustChild_displaystyle: function (n) {
+      if (n > 0) {return FALSE}
+      return this.Get("displaystyle");
+    },
+    adjustChild_scriptlevel: function (n) {
+      var level = this.Get("scriptlevel");
+      if (n > 0) {level++}
+      return level;
+    },
+    adjustChild_texprimestyle: function (n) {
+      if (n === this.sub) {return TRUE}
+      return this.Get("texprimestyle");
+    },
+    setTeXclass: MML.mbase.setBaseTeXclasses
+  });
+  
+  MML.msub = MML.msubsup.Subclass({type: "msub"});
+  MML.msup = MML.msubsup.Subclass({type: "msup", sub:2, sup:1});
+  
+  MML.munderover = MML.mbase.Subclass({
+    type: "munderover",
+    base: 0, under: 1, over: 2, sub: 1, sup: 2,
+    ACCENTS: ["", "accentunder", "accent"],
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      accent: MML.AUTO,
+      accentunder: MML.AUTO,
+      align: MML.ALIGN.CENTER,
+      texClass: MML.AUTO,
+      subscriptshift: "",  // when converted to msubsup by moveablelimits
+      superscriptshift: "" // when converted to msubsup by moveablelimits
+    },
+    autoDefault: function (name) {
+      if (name === "texClass")
+        {return (this.isEmbellished() ? this.CoreMO().Get(name) : MML.TEXCLASS.ORD)}
+      if (name === "accent" && this.data[this.over]) {return this.data[this.over].CoreMO().Get("accent")}
+      if (name === "accentunder" && this.data[this.under]) {return this.data[this.under].CoreMO().Get("accent")}
+      return FALSE;
+    },
+    adjustChild_displaystyle: function (n) {
+      if (n > 0) {return FALSE}
+      return this.Get("displaystyle");
+    },
+    adjustChild_scriptlevel: function (n) {
+      var level = this.Get("scriptlevel");
+      if (n == this.under && !this.Get("accentunder")) {level++}
+      if (n == this.over  && !this.Get("accent")) {level++}
+      return level;
+    },
+    adjustChild_texprimestyle: function (n) {
+      if (n === this.base && this.data[this.over]) {return TRUE}
+      return this.Get("texprimestyle");
+    },
+    setTeXclass: MML.mbase.setBaseTeXclasses
+  });
+  
+  MML.munder = MML.munderover.Subclass({type: "munder"});
+  MML.mover = MML.munderover.Subclass({
+    type: "mover", over: 1, under: 2, sup: 1, sub: 2,
+    ACCENTS: ["", "accent", "accentunder"]
+  });
+
+  MML.mmultiscripts = MML.mbase.Subclass({
+    type: "mmultiscripts",
+    isEmbellished: MML.mbase.childEmbellished,
+    Core: MML.mbase.childCore,
+    CoreMO: MML.mbase.childCoreMO,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      subscriptshift: MML.AUTO,
+      superscriptshift: MML.AUTO,
+      texClass: MML.AUTO
+    },
+    autoDefault: function (name) {
+      if (name === "texClass")
+        {return (this.isEmbellished() ? this.CoreMO().Get(name) : MML.TEXCLASS.ORD)}
+      // compute this from size of children
+      return 0;
+    },
+    adjustChild_displaystyle: function (n) {
+      if (n > 0) {return FALSE}
+      return this.Get("displaystyle");
+    },
+    adjustChild_scriptlevel: function (n) {
+      var level = this.Get("scriptlevel");
+      if (n > 0) {level++}
+      return level;
+    },
+    adjustChild_texprimestyle: function (n) {return (n === this.base && this.data[this.over])},
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.mtable = MML.mbase.Subclass({
+    type: "mtable",
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      align: MML.ALIGN.AXIS,
+      rowalign: MML.ALIGN.BASELINE,
+      columnalign: MML.ALIGN.CENTER,
+      groupalign: "{left}",
+      alignmentscope: TRUE,
+      columnwidth: MML.WIDTH.AUTO,
+      width: MML.WIDTH.AUTO,
+      rowspacing: "1ex",
+      columnspacing: ".8em",
+      rowlines: MML.LINES.NONE,
+      columnlines: MML.LINES.NONE,
+      frame: MML.LINES.NONE,
+      framespacing: "0.4em 0.5ex",
+      equalrows: FALSE,
+      equalcolumns: FALSE,
+      displaystyle: FALSE,
+      side: MML.SIDE.RIGHT,
+      minlabelspacing: "0.8em",
+      texClass: MML.TEXCLASS.ORD,
+      useHeight: 1
+    },
+    inheritFromMe: TRUE,
+    noInherit: {
+      mtable: {
+        align: TRUE, rowalign: TRUE, columnalign: TRUE, groupalign: TRUE,
+        alignmentscope: TRUE, columnwidth: TRUE, width: TRUE, rowspacing: TRUE,
+        columnspacing: TRUE, rowlines: TRUE, columnlines: TRUE, frame: TRUE,
+        framespacing: TRUE, equalrows: TRUE, equalcolumns: TRUE,
+        side: TRUE, minlabelspacing: TRUE, texClass: TRUE, useHeight: 1
+      }
+    },
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.mtr = MML.mbase.Subclass({
+    type: "mtr",
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      rowalign: MML.INHERIT,
+      columnalign: MML.INHERIT,
+      groupalign: MML.INHERIT
+    },
+    inheritFromMe: TRUE,
+    noInherit: {
+      mrow: {rowalign: TRUE, columnalign: TRUE, groupalign: TRUE},
+      mtable: {rowalign: TRUE, columnalign: TRUE, groupalign: TRUE}
+    },
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.mtd = MML.mbase.Subclass({
+    type: "mtd",
+    inferRow: TRUE,
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      rowspan: 1,
+      columnspan: 1,
+      rowalign: MML.INHERIT,
+      columnalign: MML.INHERIT,
+      groupalign: MML.INHERIT
+    },
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+
+  MML.maligngroup = MML.mbase.Subclass({
+    type: "malign",
+    isSpacelike: function () {return TRUE},
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      groupalign: MML.INHERIT
+    },
+    inheritFromMe: TRUE,
+    noInherit: {
+      mrow: {groupalign: TRUE},
+      mtable: {groupalign: TRUE}
+    }
+  });
+
+  MML.malignmark = MML.mbase.Subclass({
+    type: "malignmark",
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      edge: MML.SIDE.LEFT
+    },
+    isSpacelike: function () {return TRUE}
+  });
+
+  MML.mlabeledtr = MML.mtr.Subclass({
+    type: "mlabeledtr"
+  });
+  
+  MML.maction = MML.mbase.Subclass({
+    type: "maction",
+    defaults: {
+      mathbackground: MML.INHERIT,
+      mathcolor: MML.INHERIT,
+      actiontype: MML.ACTIONTYPE.TOGGLE,
+      selection: 1
+    },
+    // FIXME: should base class on selection
+    setTeXclass: MML.mbase.setSeparateTeXclasses
+  });
+  
+  MML.semantics = MML.mbase.Subclass({
+    type: "semantics",
+    defaults: {
+      definitionURL: null,
+      encoding: null
+    },
+    isEmbellished: MML.mbase.childEmbellished,
+    setTeXclass: MML.mbase.setChildTeXclass
+  });
+  MML.annotation = MML.mbase.Subclass({
+    type: "annotation", isToken: TRUE,
+    defaults: {
+      definitionURL: null,
+      encoding: null,
+      cd: "mathmlkeys",
+      name: "",
+      src: null
+    }
+  });
+  MML["annotation-xml"] = MML.mbase.Subclass({
+    type: "annotation-xml",
+    defaults: {
+      definitionURL: null,
+      encoding: null,
+      cd: "mathmlkeys",
+      name: "",
+      src: null
+    }
+  });
+
+  MML.math = MML.mstyle.Subclass({
+    type: "math",
+    defaults: {
+      mathvariant: MML.VARIANT.NORMAL,
+      mathsize: MML.SIZE.NORMAL,
+      mathcolor: "", // should be "black", but allow it to inherit from surrounding text
+      mathbackground: MML.COLOR.TRANSPARENT,
+      scriptlevel: 0,
+      displaystyle: MML.AUTO,
+      display: "inline",
+      maxwidth: "",
+      overflow: MML.OVERFLOW.LINEBREAK,
+      altimg: "",
+      'altimg-width': "",
+      'altimg-height': "",
+      'altimg-valign': "",
+      alttext: "",
+      cdgroup: "",
+      scriptsizemultiplier: Math.sqrt(1/2),
+      scriptminsize: "8px",    // should be 8pt, but that's too big
+      infixlinebreakstyle: MML.LINEBREAKSTYLE.BEFORE,
+      decimalseparator: ".",
+      texprimestyle: FALSE     // is it in TeX's C' style?
+    },
+    autoDefault: function (name) {
+      if (name === "displaystyle") {return this.Get("display") === "block"}
+      return "";
+    },
+    setTeXclass: MML.mbase.setChildTeXclass
+  });
+  
+  MML.chars = MML.mbase.Subclass({
+    type: "chars",
+    Append: function () {this.data.push.apply(this.data,arguments)},
+    value: function () {return this.data.join("")},
+    toString: function () {return this.data.join("")}
+  });
+  
+  MML.entity = MML.mbase.Subclass({
+    type: "entity",
+    Append: function () {this.data.push.apply(this.data,arguments)},
+    value: function () {
+      if (this.data[0].substr(0,2) === "#x") {return parseInt(this.data[0].substr(2),16)}
+      else if (this.data[0].substr(0,1) === "#") {return parseInt(this.data[0].substr(1))}
+      else {return 0}  // FIXME: look up named entities from table
+    },
+    toString: function () {
+      var n = this.value();
+      if (n <= 0xFFFF) {return String.fromCharCode(n)}
+      return this.PLANE1 + String.fromCharCode(n-0x1D400+0xDC00);
+    }
+  });
+  
+  MML.TeXAtom = MML.mbase.Subclass({
+    type: "texatom",
+    inferRow: TRUE,
+    texClass: MML.TEXCLASS.ORD,
+    setTeXclass: function (prev) {
+      this.getPrevClass(prev);
+      this.data[0].setTeXclass();
+      return this;
+    }
+  });
+
+  var TEXCLASS = MML.TEXCLASS;
+  
+  var MO = {
+    ORD:        [0,0,TEXCLASS.ORD],
+    ORD11:      [1,1,TEXCLASS.ORD],
+    ORD21:      [2,1,TEXCLASS.ORD],
+    ORD02:      [0,2,TEXCLASS.ORD],
+    ORD55:      [5,5,TEXCLASS.ORD],
+    OP:         [1,2,TEXCLASS.OP,{largeop: true, movablelimits: true, symmetric: true}],
+    OPFIXED:    [1,2,TEXCLASS.OP,{largeop: true, movablelimits: true}],
+    INTEGRAL:   [0,1,TEXCLASS.OP,{largeop: true, symmetric: true}],
+    INTEGRAL2:  [1,2,TEXCLASS.OP,{largeop: true, symmetric: true}],
+    BIN3:       [3,3,TEXCLASS.BIN],
+    BIN4:       [4,4,TEXCLASS.BIN],
+    BIN01:      [0,1,TEXCLASS.BIN],
+    TALLBIN:    [4,4,TEXCLASS.BIN,{stretchy: true}],
+    BINOP:      [4,4,TEXCLASS.BIN,{largeop: true, movablelimits: true}],
+    REL:        [5,5,TEXCLASS.REL],
+    REL1:       [1,1,TEXCLASS.REL,{stretchy: true}],
+    REL4:       [4,4,TEXCLASS.REL],
+    WIDEREL:    [5,5,TEXCLASS.REL,{stretchy: true}],
+    RELACCENT:  [5,5,TEXCLASS.REL,{accent: true, stretchy: true}],
+    OPEN:       [0,0,TEXCLASS.OPEN,{fence: true, stretchy: true, symmetric: true}],
+    CLOSE:      [0,0,TEXCLASS.CLOSE,{fence: true, stretchy: true, symmetric: true}],
+    INNER:      [0,0,TEXCLASS.INNER],
+    PUNCT:      [0,3,TEXCLASS.PUNCT],
+    ACCENT:     [0,0,TEXCLASS.ORD,{accent: true}],
+    WIDEACCENT: [0,0,TEXCLASS.ORD,{accent: true, stretchy: true}]
+  };
+
+  MML.mo.Augment({
+    SPACE: [
+      '0em',
+      '0.1111em',
+      '0.1667em',
+      '0.2222em',
+      '0.2667em',
+      '0.3333em'
+    ],
+    RANGES: [
+      [0x20,0x7F,TEXCLASS.REL,"BasicLatin"],
+      [0xA0,0xFF,TEXCLASS.ORD,"Latin1Supplement"],
+      [0x100,0x17F,TEXCLASS.ORD],
+      [0x180,0x24F,TEXCLASS.ORD],
+      [0x2B0,0x2FF,TEXCLASS.ORD,"SpacingModLetters"],
+      [0x300,0x36F,TEXCLASS.ORD,"CombDiacritMarks"],
+      [0x370,0x3FF,TEXCLASS.ORD,"GreekAndCoptic"],
+      [0x1E00,0x1EFF,TEXCLASS.ORD],
+      [0x2000,0x206F,TEXCLASS.PUNCT,"GeneralPunctuation"],
+      [0x2070,0x209F,TEXCLASS.ORD],
+      [0x20A0,0x20CF,TEXCLASS.ORD],
+      [0x20D0,0x20FF,TEXCLASS.ORD,"CombDiactForSymbols"],
+      [0x2100,0x214F,TEXCLASS.ORD,"LetterlikeSymbols"],
+      [0x2150,0x218F,TEXCLASS.ORD],
+      [0x2190,0x21FF,TEXCLASS.REL,"Arrows"],
+      [0x2200,0x22FF,TEXCLASS.BIN,"MathOperators"],
+      [0x2300,0x23FF,TEXCLASS.ORD,"MiscTechnical"],
+      [0x2460,0x24FF,TEXCLASS.ORD],
+      [0x25A0,0x25FF,TEXCLASS.ORD,"GeometricShapes"],
+      [0x2700,0x27BF,TEXCLASS.ORD,"Dingbats"],
+      [0x27C0,0x27EF,TEXCLASS.ORD,"MiscMathSymbolsA"],
+      [0x2900,0x297F,TEXCLASS.REL,"SupplementalArrowsB"],
+      [0x2980,0x29FF,TEXCLASS.ORD,"MiscMathSymbolsB"],
+      [0x2A00,0x2AFF,TEXCLASS.BIN,"SuppMathOperators"],
+      [0x2B00,0x2BFF,TEXCLASS.ORD],
+      [0x1D400,0x1D7FF,TEXCLASS.ORD]
+    ],
+    OPTABLE: {
+      prefix: {
+        '\u2111': MO.ORD11,    // black-letter capital i
+        '\u2113': MO.ORD11,    // script small l
+        '\u211C': MO.ORD11,    // black-letter capital r
+        '\u2200': MO.ORD21,    // for all
+        '\u2202': MO.ORD21,    // partial differential
+        '\u2203': MO.ORD21,    // there exists
+        '\u2207': MO.ORD21,    // nabla
+        '\u220F': MO.OP,       // n-ary product
+        '\u2210': MO.OP,       // n-ary coproduct
+        '\u2211': MO.OP,       // n-ary summation
+        '\u2212': MO.BIN01,    // minus sign
+        '\u2213': MO.BIN01,    // minus-or-plus sign
+        '\u221A': [1,1,TEXCLASS.ORD,{stretchy: true}], // square root
+        '\u2220': MO.ORD,      // angle
+        '\u222B': MO.INTEGRAL, // integral
+        '\u222E': MO.INTEGRAL, // contour integral
+        '\u22C0': MO.OP,       // n-ary logical and
+        '\u22C1': MO.OP,       // n-ary logical or
+        '\u22C2': MO.OP,       // n-ary intersection
+        '\u22C3': MO.OP,       // n-ary union
+        '\u2308': MO.OPEN,     // left ceiling
+        '\u230A': MO.OPEN,     // left floor
+        '\u27E8': MO.OPEN,     // mathematical left angle bracket
+        '\u2A00': MO.OP,       // n-ary circled dot operator
+        '\u2A01': MO.OP,       // n-ary circled plus operator
+        '\u2A02': MO.OP,       // n-ary circled times operator
+        '\u2A04': MO.OP,       // n-ary union operator with plus
+        '\u2A06': MO.OP,       // n-ary square union operator
+        '\u00AC': MO.ORD21,    // not sign
+        '\u00B1': MO.BIN01,    // plus-minus sign
+        '(': MO.OPEN,          // left parenthesis
+        '+': MO.BIN01,         // plus sign
+        '-': MO.BIN01,         // hyphen-minus
+        '[': MO.OPEN,          // left square bracket
+        '{': MO.OPEN,          // left curly bracket
+        '|': MO.OPEN           // vertical line
+      },
+      postfix: {
+        '!': [1,0,TEXCLASS.CLOSE], // exclamation mark
+        '&': MO.ORD,           // ampersand
+        '\u2032': MO.ORD02,    // prime
+        '\u203E': MO.WIDEACCENT, // overline
+        '\u2309': MO.CLOSE,    // right ceiling
+        '\u230B': MO.CLOSE,    // right floor
+        '\u23DE': MO.WIDEACCENT, // top curly bracket
+        '\u23DF': MO.WIDEACCENT, // bottom curly bracket
+        '\u266D': MO.ORD02,    // music flat sign
+        '\u266E': MO.ORD02,    // music natural sign
+        '\u266F': MO.ORD02,    // music sharp sign
+        '\u27E9': MO.CLOSE,    // mathematical right angle bracket
+        '\u02C6': MO.WIDEACCENT, // modifier letter circumflex accent
+        '\u02C7': MO.WIDEACCENT, // caron
+        '\u02D8': MO.ACCENT,   // breve
+        '\u02D9': MO.ACCENT,   // dot above
+        '\u02DC': MO.WIDEACCENT, // small tilde
+        '\u0302': MO.ACCENT,   // combining circumflex accent
+        '\u00A8': MO.ACCENT,   // diaeresis
+        '\u00AF': MO.WIDEACCENT, // macron
+        ')': MO.CLOSE,         // right parenthesis
+        ']': MO.CLOSE,         // right square bracket
+        '^': MO.WIDEACCENT,    // circumflex accent
+        '_': MO.WIDEACCENT,    // low line
+        '`': MO.ACCENT,        // grave accent
+        '|': MO.CLOSE,         // vertical line
+        '}': MO.CLOSE,         // right curly bracket
+        '~': MO.WIDEACCENT     // tilde
+      },
+      infix: {
+        '%': [3,3,TEXCLASS.ORD], // percent sign
+        '\u2022': MO.BIN4,     // bullet
+        '\u2026': MO.INNER,    // horizontal ellipsis
+        '\u2044': MO.TALLBIN,  // fraction slash
+        '\u2061': MO.ORD,      // function application
+        '\u2062': MO.ORD,      // invisible times
+        '\u2063': [0,0,TEXCLASS.ORD,{separator: true}], // invisible separator
+        '\u2064': MO.ORD,      // invisible plus
+        '\u2190': MO.RELACCENT, // leftwards arrow
+        '\u2191': MO.WIDEREL,  // upwards arrow
+        '\u2192': MO.RELACCENT, // rightwards arrow
+        '\u2193': MO.WIDEREL,  // downwards arrow
+        '\u2194': MO.RELACCENT, // left right arrow
+        '\u2195': MO.WIDEREL,  // up down arrow
+        '\u2196': MO.WIDEREL,  // north west arrow
+        '\u2197': MO.WIDEREL,  // north east arrow
+        '\u2198': MO.WIDEREL,  // south east arrow
+        '\u2199': MO.WIDEREL,  // south west arrow
+        '\u21A6': MO.WIDEREL,  // rightwards arrow from bar
+        '\u21A9': MO.WIDEREL,  // leftwards arrow with hook
+        '\u21AA': MO.WIDEREL,  // rightwards arrow with hook
+        '\u21BC': MO.RELACCENT, // leftwards harpoon with barb upwards
+        '\u21BD': MO.WIDEREL,  // leftwards harpoon with barb downwards
+        '\u21C0': MO.RELACCENT, // rightwards harpoon with barb upwards
+        '\u21C1': MO.WIDEREL,  // rightwards harpoon with barb downwards
+        '\u21CC': MO.WIDEREL,  // rightwards harpoon over leftwards harpoon
+        '\u21D0': MO.WIDEREL,  // leftwards double arrow
+        '\u21D1': MO.WIDEREL,  // upwards double arrow
+        '\u21D2': MO.WIDEREL,  // rightwards double arrow
+        '\u21D3': MO.WIDEREL,  // downwards double arrow
+        '\u21D4': MO.WIDEREL,  // left right double arrow
+        '\u21D5': MO.WIDEREL,  // up down double arrow
+        '\u2208': MO.REL,      // element of
+        '\u2209': MO.REL,      // not an element of
+        '\u220B': MO.REL,      // contains as member
+        '\u2212': MO.BIN4,     // minus sign
+        '\u2213': MO.BIN4,     // minus-or-plus sign
+        '\u2215': MO.TALLBIN,  // division slash
+        '\u2216': MO.BIN4,     // set minus
+        '\u2217': MO.BIN4,     // asterisk operator
+        '\u2218': MO.BIN4,     // ring operator
+        '\u2219': MO.BIN4,     // bullet operator
+        '\u221D': MO.REL,      // proportional to
+        '\u2223': MO.REL,      // divides
+        '\u2225': MO.REL,      // parallel to
+        '\u2227': MO.BIN4,     // logical and
+        '\u2228': MO.BIN4,     // logical or
+        '\u2229': MO.BIN4,     // intersection
+        '\u222A': MO.BIN4,     // union
+        '\u223C': MO.REL,      // tilde operator
+        '\u2240': MO.BIN4,     // wreath product
+        '\u2243': MO.REL,      // asymptotically equal to
+        '\u2245': MO.REL,      // approximately equal to
+        '\u2248': MO.REL,      // almost equal to
+        '\u224D': MO.REL,      // equivalent to
+        '\u2250': MO.REL,      // approaches the limit
+        '\u2260': MO.REL,      // not equal to
+        '\u2261': MO.REL,      // identical to
+        '\u2264': MO.REL,      // less-than or equal to
+        '\u2265': MO.REL,      // greater-than or equal to
+        '\u226A': MO.REL,      // much less-than
+        '\u226B': MO.REL,      // much greater-than
+        '\u227A': MO.REL,      // precedes
+        '\u227B': MO.REL,      // succeeds
+        '\u2282': MO.REL,      // subset of
+        '\u2283': MO.REL,      // superset of
+        '\u2286': MO.REL,      // subset of or equal to
+        '\u2287': MO.REL,      // superset of or equal to
+        '\u228E': MO.BIN4,     // multiset union
+        '\u2291': MO.REL,      // square image of or equal to
+        '\u2292': MO.REL,      // square original of or equal to
+        '\u2293': MO.BIN4,     // square cap
+        '\u2294': MO.BIN4,     // square cup
+        '\u2295': MO.BIN4,     // circled plus
+        '\u2296': MO.BIN4,     // circled minus
+        '\u2297': MO.BIN4,     // circled times
+        '\u2298': MO.BIN4,     // circled division slash
+        '\u2299': MO.BIN4,     // circled dot operator
+        '\u22A2': MO.REL,      // right tack
+        '\u22A3': MO.REL,      // left tack
+        '\u22A4': MO.ORD55,    // down tack
+        '\u22A5': MO.REL,      // up tack
+        '\u22A8': MO.REL,      // true
+        '\u22C4': MO.BIN4,     // diamond operator
+        '\u22C5': MO.BIN4,     // dot operator
+        '\u22C6': MO.BIN4,     // star operator
+        '\u22C8': MO.REL,      // bowtie
+        '\u22EE': MO.ORD55,    // vertical ellipsis
+        '\u22EF': MO.INNER,    // midline horizontal ellipsis
+        '\u22F1': [5,5,TEXCLASS.INNER], // down right diagonal ellipsis
+        '\u2500': [0,0,TEXCLASS.ORD,{stretchy: true}], // box drawings light horizontal
+        '\u25B3': MO.BIN4,     // white up-pointing triangle
+        '\u25B5': MO.BIN4,     // white up-pointing small triangle
+        '\u25B9': MO.BIN4,     // white right-pointing small triangle
+        '\u25BD': MO.BIN4,     // white down-pointing triangle
+        '\u25BF': MO.BIN4,     // white down-pointing small triangle
+        '\u25C3': MO.BIN4,     // white left-pointing small triangle
+        '\u2758': [4,4,TEXCLASS.REL,{fence: true, stretchy: true, symmetric: true}], // light vertical bar
+        '\u27F5': MO.REL1,     // long leftwards arrow
+        '\u27F6': MO.REL1,     // long rightwards arrow
+        '\u27F7': MO.REL1,     // long left right arrow
+        '\u27F8': MO.REL1,     // long leftwards double arrow
+        '\u27F9': MO.REL1,     // long rightwards double arrow
+        '\u27FA': MO.REL1,     // long left right double arrow
+        '\u2A2F': MO.BIN4,     // vector or cross product
+        '\u2A3F': MO.BIN4,     // amalgamation or coproduct
+        '\u2AAF': MO.REL,      // precedes above single-line equals sign
+        '\u2AB0': MO.REL,      // succeeds above single-line equals sign
+        '\u00B1': MO.BIN4,     // plus-minus sign
+        '\u00B7': MO.BIN4,     // middle dot
+        '\u00D7': MO.BIN4,     // multiplication sign
+        '\u00F7': MO.BIN4,     // division sign
+        '*': MO.BIN3,          // asterisk
+        '+': MO.BIN4,          // plus sign
+        ',': [0,3,TEXCLASS.PUNCT,{separator: true}], // comma
+        '-': MO.BIN4,          // hyphen-minus
+        '.': [3,3,TEXCLASS.ORD], // full stop
+        '/': MO.ORD11,         // solidus
+        ':': [1,2,TEXCLASS.REL], // colon
+        ';': [0,3,TEXCLASS.PUNCT,{separator: true}], // semicolon
+        '<': MO.REL,           // less-than sign
+        '=': MO.REL,           // equals sign
+        '>': MO.REL,           // greater-than sign
+        '?': [1,1,TEXCLASS.CLOSE], // question mark
+        '\\': MO.ORD,          // reverse solidus
+        '_': MO.ORD11,         // low line
+        '|': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}], // vertical line
+        '#': MO.ORD,           // #
+        '$': MO.ORD,           // $
+        '\u002E': [0,3,TEXCLASS.PUNCT,{separator: true}], // \ldotp
+        '\u02B9': MO.ORD,      // prime
+        '\u02C9': MO.ACCENT,   // \bar
+        '\u02CA': MO.ACCENT,   // \acute
+        '\u02CB': MO.ACCENT,   // \grave
+        '\u0300': MO.ACCENT,   // \grave
+        '\u0301': MO.ACCENT,   // \acute
+        '\u0303': MO.WIDEACCENT, // \tilde
+        '\u0304': MO.ACCENT,   // \bar
+        '\u0306': MO.ACCENT,   // \breve
+        '\u0307': MO.ACCENT,   // \dot
+        '\u0308': MO.ACCENT,   // \ddot
+        '\u030C': MO.ACCENT,   // \check
+        '\u0332': MO.WIDEACCENT, // horizontal line
+        '\u0338': MO.REL4,     // \not
+        '\u2015': [0,0,TEXCLASS.ORD,{stretchy: true}], // horizontal line
+        '\u2017': [0,0,TEXCLASS.ORD,{stretchy: true}], // horizontal line
+        '\u2020': MO.BIN3,     // \dagger
+        '\u2021': MO.BIN3,     // \ddagger
+        '\u20D7': MO.ACCENT,   // \vec
+        '\u2118': MO.ORD,      // \wp
+        '\u2205': MO.ORD,      // \emptyset
+        '\u221E': MO.ORD,      // \infty
+        '\u2305': MO.BIN3,     // barwedge
+        '\u2306': MO.BIN3,     // doublebarwedge
+        '\u2322': MO.REL4,     // \frown
+        '\u2323': MO.REL4,     // \smile
+        '\u2329': MO.OPEN,     // langle
+        '\u232A': MO.CLOSE,    // rangle
+        '\u23AA': MO.ORD,      // \bracevert
+        '\u23AF': [0,0,TEXCLASS.ORD,{stretchy: true}], // \underline
+        '\u23B0': MO.OPEN,     // \lmoustache
+        '\u23B1': MO.CLOSE,    // \rmoustache
+        '\u25EF': MO.BIN3,     // \bigcirc
+        '\u2660': MO.ORD,      // \spadesuit
+        '\u2661': MO.ORD,      // \heartsuit
+        '\u2662': MO.ORD,      // \diamondsuit
+        '\u2663': MO.ORD,      // \clubsuit
+        '\u27EE': MO.OPEN,     // \lgroup
+        '\u27EF': MO.CLOSE,    // \rgroup
+        '\u27FC': MO.REL4,     // \longmapsto
+        '\u3008': MO.OPEN,     // langle
+        '\u3009': MO.CLOSE,    // rangle
+        '\uFE37': MO.WIDEACCENT, // horizontal brace down
+        '\uFE38': MO.WIDEACCENT  // horizontal brace up
+      }
+    }
+  },{
+    OPTYPES: MO
+  });
+  
+})(MathJax.ElementJax.mml);
+
+MathJax.ElementJax.mml.loadComplete("jax.js");