aboutsummaryrefslogtreecommitdiff
path: root/js/mathjax/jax
diff options
context:
space:
mode:
Diffstat (limited to 'js/mathjax/jax')
-rw-r--r--js/mathjax/jax/element/mml/jax.js1815
-rw-r--r--js/mathjax/jax/element/mml/optable/Arrows.js124
-rw-r--r--js/mathjax/jax/element/mml/optable/BasicLatin.js67
-rw-r--r--js/mathjax/jax/element/mml/optable/CombDiacritMarks.js37
-rw-r--r--js/mathjax/jax/element/mml/optable/CombDiactForSymbols.js38
-rw-r--r--js/mathjax/jax/element/mml/optable/Dingbats.js40
-rw-r--r--js/mathjax/jax/element/mml/optable/GeneralPunctuation.js44
-rw-r--r--js/mathjax/jax/element/mml/optable/GeometricShapes.js68
-rw-r--r--js/mathjax/jax/element/mml/optable/GreekAndCoptic.js37
-rw-r--r--js/mathjax/jax/element/mml/optable/Latin1Supplement.js39
-rw-r--r--js/mathjax/jax/element/mml/optable/LetterlikeSymbols.js38
-rw-r--r--js/mathjax/jax/element/mml/optable/MathOperators.js230
-rw-r--r--js/mathjax/jax/element/mml/optable/MiscMathSymbolsA.js44
-rw-r--r--js/mathjax/jax/element/mml/optable/MiscMathSymbolsB.js170
-rw-r--r--js/mathjax/jax/element/mml/optable/MiscSymbolsAndArrows.js38
-rw-r--r--js/mathjax/jax/element/mml/optable/MiscTechnical.js42
-rw-r--r--js/mathjax/jax/element/mml/optable/SpacingModLetters.js40
-rw-r--r--js/mathjax/jax/element/mml/optable/SuppMathOperators.js291
-rw-r--r--js/mathjax/jax/element/mml/optable/SupplementalArrowsA.js42
-rw-r--r--js/mathjax/jax/element/mml/optable/SupplementalArrowsB.js164
-rw-r--r--js/mathjax/jax/input/AsciiMath/config.js48
-rw-r--r--js/mathjax/jax/input/AsciiMath/jax.js1543
-rw-r--r--js/mathjax/jax/input/MathML/config.js43
-rw-r--r--js/mathjax/jax/input/MathML/entities/a.js92
-rw-r--r--js/mathjax/jax/input/MathML/entities/b.js118
-rw-r--r--js/mathjax/jax/input/MathML/entities/c.js116
-rw-r--r--js/mathjax/jax/input/MathML/entities/d.js114
-rw-r--r--js/mathjax/jax/input/MathML/entities/e.js94
-rw-r--r--js/mathjax/jax/input/MathML/entities/f.js62
-rw-r--r--js/mathjax/jax/input/MathML/entities/fr.js81
-rw-r--r--js/mathjax/jax/input/MathML/entities/g.js85
-rw-r--r--js/mathjax/jax/input/MathML/entities/h.js54
-rw-r--r--js/mathjax/jax/input/MathML/entities/i.js88
-rw-r--r--js/mathjax/jax/input/MathML/entities/j.js37
-rw-r--r--js/mathjax/jax/input/MathML/entities/k.js39
-rw-r--r--js/mathjax/jax/input/MathML/entities/l.js181
-rw-r--r--js/mathjax/jax/input/MathML/entities/m.js63
-rw-r--r--js/mathjax/jax/input/MathML/entities/n.js222
-rw-r--r--js/mathjax/jax/input/MathML/entities/o.js92
-rw-r--r--js/mathjax/jax/input/MathML/entities/opf.js81
-rw-r--r--js/mathjax/jax/input/MathML/entities/p.js86
-rw-r--r--js/mathjax/jax/input/MathML/entities/q.js37
-rw-r--r--js/mathjax/jax/input/MathML/entities/r.js140
-rw-r--r--js/mathjax/jax/input/MathML/entities/s.js172
-rw-r--r--js/mathjax/jax/input/MathML/entities/scr.js81
-rw-r--r--js/mathjax/jax/input/MathML/entities/t.js88
-rw-r--r--js/mathjax/jax/input/MathML/entities/u.js94
-rw-r--r--js/mathjax/jax/input/MathML/entities/v.js75
-rw-r--r--js/mathjax/jax/input/MathML/entities/w.js37
-rw-r--r--js/mathjax/jax/input/MathML/entities/x.js49
-rw-r--r--js/mathjax/jax/input/MathML/entities/y.js43
-rw-r--r--js/mathjax/jax/input/MathML/entities/z.js44
-rw-r--r--js/mathjax/jax/input/MathML/jax.js783
-rw-r--r--js/mathjax/jax/input/TeX/config.js56
-rw-r--r--js/mathjax/jax/input/TeX/jax.js2373
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/annotation-xml.js62
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/maction.js180
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/menclose.js332
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/mglyph.js96
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/mmultiscripts.js298
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/ms.js75
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/mtable.js604
-rw-r--r--js/mathjax/jax/output/CommonHTML/autoload/multiline.js799
-rw-r--r--js/mathjax/jax/output/CommonHTML/config.js66
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/AMS-Regular.js291
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Caligraphic-Bold.js101
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Bold.js127
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js127
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Main-Bold.js210
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Math-BoldItalic.js210
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Bold.js154
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Italic.js154
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Regular.js154
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Script-Regular.js90
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/Typewriter-Regular.js157
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata-extra.js242
-rw-r--r--js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata.js1786
-rw-r--r--js/mathjax/jax/output/CommonHTML/jax.js2845
-rw-r--r--js/mathjax/jax/output/NativeMML/config.js54
-rw-r--r--js/mathjax/jax/output/NativeMML/jax.js1433
-rw-r--r--js/mathjax/jax/output/PlainSource/config.js51
-rw-r--r--js/mathjax/jax/output/PlainSource/jax.js186
-rw-r--r--js/mathjax/jax/output/PreviewHTML/config.js56
-rw-r--r--js/mathjax/jax/output/PreviewHTML/jax.js1098
84 files changed, 22857 insertions, 0 deletions
diff --git a/js/mathjax/jax/element/mml/jax.js b/js/mathjax/jax/element/mml/jax.js
new file mode 100644
index 0000000..e70bbbb
--- /dev/null
+++ b/js/mathjax/jax/element/mml/jax.js
@@ -0,0 +1,1815 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * 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-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.ElementJax.mml = MathJax.ElementJax({
+ mimeType: "jax/mml"
+},{
+ id: "mml",
+ version: "2.7.9",
+ 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.attr && this.root.attr.mode) {
+ if (!this.root.display && this.root.attr.mode === "display") {
+ this.root.display = "block";
+ this.root.attrNames.push("display");
+ }
+ delete this.root.attr.mode;
+ for (var i = 0, m = this.root.attrNames.length; i < m; i++) {
+ if (this.root.attrNames[i] === "mode") {this.root.attrNames.splice(i,1); break}
+ }
+ }
+ }
+},{
+ 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: "initial",
+ 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"
+ },
+ INDENTALIGN: {
+ LEFT: "left",
+ CENTER: "center",
+ RIGHT: "right",
+ AUTO: "auto",
+ ID: "id",
+ INDENTALIGN: "indentalign"
+ },
+ INDENTSHIFT: {
+ INDENTSHIFT: "indentshift"
+ },
+ 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",
+ UPDIAGONALARROW: "updiagonalarrow",
+ VERTICALSTRIKE: "verticalstrike",
+ HORIZONTALSTRIKE: "horizontalstrike",
+ PHASORANGLE: "phasorangle",
+ 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
+ },
+ TEXCLASSNAMES: ["ORD", "OP", "BIN", "REL", "OPEN", "CLOSE", "PUNCT", "INNER", "VCENTER"],
+ skipAttributes: {
+ texClass:true, useHeight:true, texprimestyle:true
+ },
+ copyAttributes: {
+ displaystyle:1, scriptlevel:1, open:1, close:1, form:1,
+ actiontype: 1,
+ fontfamily:true, fontsize:true, fontweight:true, fontstyle:true,
+ color:true, background:true,
+ id:true, "class":1, href:true, style:true
+ },
+ copyAttributeNames: [
+ "displaystyle", "scriptlevel", "open", "close", "form", // force these to be copied
+ "actiontype",
+ "fontfamily", "fontsize", "fontweight", "fontstyle",
+ "color", "background",
+ "id", "class", "href", "style"
+ ],
+ nocopyAttributes: {
+ fontfamily: true, fontsize: true, fontweight: true, fontstyle: true,
+ color: true, background: true,
+ id: true, 'class': true, href: true, style: true,
+ xmlns: true
+ },
+ Error: function (message,def) {
+ var mml = this.merror(message),
+ dir = MathJax.Localization.fontDirection(),
+ font = MathJax.Localization.fontFamily();
+ if (def) {mml = mml.With(def)}
+ if (dir || font) {
+ mml = this.mstyle(mml);
+ if (dir) {mml.dir = dir}
+ if (font) {mml.style.fontFamily = "font-family: "+font}
+ }
+ return mml;
+ }
+});
+
+(function (MML) {
+
+ MML.mbase = MathJax.Object.Subclass({
+ type: "base", isToken: false,
+ defaults: {
+ mathbackground: MML.INHERIT,
+ mathcolor: MML.INHERIT,
+ dir: MML.INHERIT
+ },
+ noInherit: {},
+ noInheritAttribute: {
+ texClass: true
+ },
+ getRemoved: {},
+ linebreakContainer: false,
+
+ Init: function () {
+ this.data = [];
+ if (this.inferRow && !(arguments.length === 1 && arguments[0].inferred))
+ {this.Append(MML.mrow().With({inferred: true, notParent: 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 || this.isChars ? 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.notParent) {parent = parent.parent}
+ return parent;
+ },
+ Get: function (name,nodefault,noself) {
+ if (!noself) {
+ if (this[name] != null) {return this[name]}
+ if (this.attr && this.attr[name] != null) {return this.attr[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])(this.childPosition(),nodefault);
+ }
+ var obj = this.inherit; var root = obj;
+ while (obj) {
+ var value = obj[name]; if (value == null && obj.attr) {value = obj.attr[name]}
+ if (obj.removedStyles && obj.getRemoved[name] && value == null) value = obj.removedStyles[obj.getRemoved[name]];
+ if (value != null && obj.noInheritAttribute && !obj.noInheritAttribute[name]) {
+ var noInherit = obj.noInherit[this.type];
+ if (!(noInherit && noInherit[name])) {return value}
+ }
+ 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,nodef) {return this.Get("scriptlevel",nodef)}, // always inherit from parent
+ adjustChild_displaystyle: function (i,nodef) {return this.Get("displaystyle",nodef)}, // always inherit from parent
+ adjustChild_texprimestyle: function (i,nodef) {return this.Get("texprimestyle",nodef)}, // always inherit from parent
+ hasMMLspacing: function () {return false},
+ childPosition: function () {
+ var child = this, parent = child.parent;
+ while (parent.notParent) {child = parent; parent = child.parent}
+ for (var i = 0, m = parent.data.length; i < m; i++) {if (parent.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},
+ childIndex: function(child) {
+ if (child == null) return;
+ for (var i = 0, m = this.data.length; i < m; i++) if (child === this.data[i]) return i;
+ },
+ CoreIndex: function () {
+ return (this.inferRow ? this.data[0]||this : this).childIndex(this.Core());
+ },
+ hasNewline: function () {
+ if (this.isEmbellished()) {return this.CoreMO().hasNewline()}
+ if (this.isToken || this.linebreakContainer) {return false}
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i] && this.data[i].hasNewline()) {return true}
+ }
+ return false;
+ },
+ array: function () {if (this.inferred) {return this.data} else {return [this]}},
+ toString: function () {return this.type+"("+this.data.join(",")+")"},
+ getAnnotation: function () {return null}
+ },{
+ childrenSpacelike: function () {
+ for (var i = 0, m = this.data.length; i < m; i++)
+ {if (!this.data[i].isSpacelike()) {return false}}
+ return true;
+ },
+ childEmbellished: function () {
+ return (this.data[0] && this.data[0].isEmbellished());
+ },
+ childCore: function () {return (this.inferRow && this.data[0] ? this.data[0].Core() : this.data[0])},
+ childCoreMO: function () {return (this.data[0] ? this.data[0].CoreMO() : null)},
+ setChildTeXclass: function (prev) {
+ if (this.data[0]) {
+ prev = this.data[0].setTeXclass(prev);
+ this.updateTeXclass(this.data[0]);
+ }
+ return prev;
+ },
+ setBaseTeXclasses: function (prev) {
+ this.getPrevClass(prev); this.texClass = null;
+ if (this.data[0]) {
+ if (this.isEmbellished() || this.data[0].isa(MML.mi)) {
+ prev = this.data[0].setTeXclass(prev);
+ this.updateTeXclass(this.Core());
+ } else {this.data[0].setTeXclass(); prev = this}
+ } else {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,
+ dir: MML.INHERIT
+ },
+ autoDefault: function (name) {
+ if (name === "mathvariant") {
+ var mi = (this.data[0]||"").toString();
+ return (mi.length === 1 ||
+ (mi.length === 2 && mi.charCodeAt(0) >= 0xD800 && mi.charCodeAt(0) < 0xDC00) ?
+ MML.VARIANT.ITALIC : MML.VARIANT.NORMAL);
+ }
+ return "";
+ },
+ setTeXclass: function (prev) {
+ this.getPrevClass(prev);
+ var name = this.data.join("");
+ if (name.length > 1 && name.match(/^[a-z][a-z0-9]*$/i) &&
+ this.texClass === MML.TEXCLASS.ORD) {
+ this.texClass = MML.TEXCLASS.OP;
+ this.autoOP = true;
+ }
+ return this;
+ }
+ });
+
+ 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,
+ dir: MML.INHERIT
+ }
+ });
+
+ MML.mo = MML.mbase.Subclass({
+ type: "mo", isToken: true,
+ defaults: {
+ mathvariant: MML.INHERIT,
+ mathsize: MML.INHERIT,
+ mathbackground: MML.INHERIT,
+ mathcolor: MML.INHERIT,
+ dir: 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.LINEBREAK.AUTO,
+ lineleading: MML.INHERIT,
+ linebreakstyle: MML.AUTO,
+ linebreakmultchar: MML.INHERIT,
+ indentalign: MML.INHERIT,
+ indentshift: MML.INHERIT,
+ indenttarget: MML.INHERIT,
+ indentalignfirst: MML.INHERIT,
+ indentshiftfirst: MML.INHERIT,
+ indentalignlast: MML.INHERIT,
+ indentshiftlast: 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: false,
+ maxsize: MML.SIZE.INFINITY,
+ minsize: '0em', //'1em',
+ largeop: false,
+ movablelimits: false,
+ accent: false,
+ linebreak: MML.LINEBREAK.AUTO,
+ lineleading: "1ex",
+ linebreakstyle: "before",
+ indentalign: MML.INDENTALIGN.AUTO,
+ indentshift: "0",
+ indenttarget: "",
+ indentalignfirst: MML.INDENTALIGN.INDENTALIGN,
+ indentshiftfirst: MML.INDENTSHIFT.INDENTSHIFT,
+ indentalignlast: MML.INDENTALIGN.INDENTALIGN,
+ indentshiftlast: MML.INDENTSHIFT.INDENTSHIFT,
+ texClass: MML.TEXCLASS.REL // for MML, but TeX sets ORD explicitly
+ },
+ SPACE_ATTR: {lspace: 0x01, rspace: 0x02},
+ useMMLspacing: 0x03,
+ hasMMLspacing: function () {
+ if (this.useMMLspacing) return true;
+ return this.form && (this.OPTABLE[this.form]||{})[this.data.join('')];
+ },
+ autoDefault: function (name,nodefault) {
+ var def = this.def;
+ if (!def) {
+ if (name === "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)}
+ if (this.parent) {this.def = def} else {def = MathJax.Hub.Insert({},def)}
+ def.form = forms[0];
+ }
+ }
+ 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 (n >= 0xD800 && n < 0xDC00) {n = (((n-0xD800)<<10)+(mo.charCodeAt(1)-0xDC00))+0x10000}
+ 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 = MML.TEXCLASSNAMES[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];
+ if (def.texClass === MML.TEXCLASS.REL &&
+ (this.movablelimits || this.data.join("").match(/^[a-z]+$/i)))
+ {def.texClass = MML.TEXCLASS.OP} // mark named operators as OP
+ return def;
+ },
+ getForm: function () {
+ var 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},
+ hasNewline: function () {return (this.Get("linebreak") === MML.LINEBREAK.NEWLINE)},
+ CoreParent: function () {
+ var parent = this;
+ while (parent && parent.isEmbellished() &&
+ parent.CoreMO() === this && !parent.isa(MML.math)) {parent = parent.Parent()}
+ return parent;
+ },
+ CoreText: function (parent) {
+ if (!parent) {return ""}
+ if (parent.isEmbellished()) {return parent.CoreMO().data.join("")}
+ while ((((parent.isa(MML.mrow) || parent.isa(MML.TeXAtom) ||
+ parent.isa(MML.mstyle) || parent.isa(MML.mphantom)) &&
+ parent.data.length === 1) || parent.isa(MML.munderover)) &&
+ parent.data[0]) {parent = parent.data[0]}
+ if (!parent.isToken) {return ""} else {return parent.data.join("")}
+ },
+ remapChars: {
+ '*':"\u2217",
+ '"':"\u2033",
+ "\u00B0":"\u2218",
+ "\u00B2":"2",
+ "\u00B3":"3",
+ "\u00B4":"\u2032",
+ "\u00B9":"1"
+ },
+ remap: function (text,map) {
+ text = text.replace(/-/g,"\u2212");
+ if (map) {
+ text = text.replace(/'/g,"\u2032").replace(/`/g,"\u2035");
+ if (text.length === 1) {text = map[text]||text}
+ }
+ return text;
+ },
+ setTeXclass: function (prev) {
+ var values = this.getValues("form","lspace","rspace","fence"); // sets useMMLspacing
+ if (this.hasMMLspacing()) {this.texClass = MML.TEXCLASS.NONE; return this}
+ if (values.fence && !this.texClass) {
+ if (values.form === MML.FORM.PREFIX) {this.texClass = MML.TEXCLASS.OPEN}
+ if (values.form === MML.FORM.POSTFIX) {this.texClass = MML.TEXCLASS.CLOSE}
+ }
+ this.texClass = this.Get("texClass");
+ if (this.data.join("") === "\u2061") {
+ // force previous node to be texClass OP, and skip this node
+ if (prev) {prev.texClass = MML.TEXCLASS.OP; prev.fnOP = true}
+ this.texClass = this.prevClass = MML.TEXCLASS.NONE;
+ return prev;
+ }
+ return this.adjustTeXclass(prev);
+ },
+ adjustTeXclass: function (prev) {
+ if (this.texClass === MML.TEXCLASS.NONE) {return prev}
+ if (prev) {
+ if (prev.autoOP && (this.texClass === MML.TEXCLASS.BIN ||
+ this.texClass === MML.TEXCLASS.REL))
+ {prev.texClass = MML.TEXCLASS.ORD}
+ 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;
+ } else if (this.texClass === MML.TEXCLASS.BIN) {
+ //
+ // Check if node is the last one in its container since the rule
+ // above only takes effect if there is a node that follows.
+ //
+ var child = this, parent = this.parent;
+ while (parent && parent.parent && parent.isEmbellished() &&
+ (parent.data.length === 1 ||
+ (parent.type !== "mrow" && parent.Core() === child))) // handles msubsup and munderover
+ {child = parent; parent = parent.parent}
+ if (parent.data[parent.data.length-1] === child) this.texClass = MML.TEXCLASS.ORD;
+ }
+ return this;
+ }
+ });
+
+ MML.mtext = MML.mbase.Subclass({
+ type: "mtext", isToken: true,
+ isSpacelike: function () {return true},
+ texClass: MML.TEXCLASS.ORD,
+ defaults: {
+ mathvariant: MML.INHERIT,
+ mathsize: MML.INHERIT,
+ mathbackground: MML.INHERIT,
+ mathcolor: MML.INHERIT,
+ dir: 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
+ },
+ hasDimAttr: function () {
+ return (this.hasValue("width") || this.hasValue("height") ||
+ this.hasValue("depth"));
+ },
+ hasNewline: function () {
+ // The MathML spec says that the linebreak attribute should be ignored
+ // if any dimensional attribute is set.
+ return (!this.hasDimAttr() &&
+ this.Get("linebreak") === MML.LINEBREAK.NEWLINE);
+ }
+ });
+
+ 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,
+ dir: 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, notParent: 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] && !this.data[i].isSpacelike()) {n++}}
+ return n;
+ },
+ FirstNonSpace: function () {
+ for (var i = 0, m = this.data.length; i < m; i++)
+ {if (this.data[i] && !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[0] && !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) {
+ var i, m = this.data.length;
+ if ((this.open || this.close) && (!prev || !prev.fnOP)) {
+ //
+ // <mrow> came from \left...\right
+ // so treat as subexpression (tex class INNER)
+ //
+ this.getPrevClass(prev); prev = null;
+ for (i = 0; i < m; i++)
+ {if (this.data[i]) {prev = this.data[i].setTeXclass(prev)}}
+ if (!this.hasOwnProperty("texClass")) this.texClass = MML.TEXCLASS.INNER;
+ return this;
+ } else {
+ //
+ // Normal <mrow>, so treat as
+ // thorugh mrow is not there
+ //
+ for (i = 0; i < m; i++)
+ {if (this.data[i]) {prev = this.data[i].setTeXclass(prev)}}
+ if (this.data[0]) {this.updateTeXclass(this.data[0])}
+ return prev;
+ }
+ },
+ getAnnotation: function (name) {
+ if (this.data.length != 1) return null;
+ return this.data[0].getAnnotation(name);
+ }
+ });
+
+ MML.mfrac = MML.mbase.Subclass({
+ type: "mfrac", num: 0, den: 1,
+ linebreakContainer: true,
+ 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,
+ linebreakContainer: true,
+ texClass: MML.TEXCLASS.ORD,
+ setTeXclass: MML.mbase.setSeparateTeXclasses,
+ adjustChild_texprimestyle: function (n) {return true}
+ });
+
+ MML.mroot = MML.mbase.Subclass({
+ type: "mroot",
+ linebreakContainer: true,
+ 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,
+ dir: 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(/^ *[-+]/)) {
+ var LEVEL = this.Get("scriptlevel",null,true);
+ 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, align: true}
+ },
+ getRemoved: {fontfamily:"fontFamily", fontweight:"fontWeight", fontstyle:"fontStyle", fontsize:"fontSize"},
+ setTeXclass: MML.mbase.setChildTeXclass
+ });
+
+ MML.merror = MML.mbase.Subclass({
+ type: "merror",
+ inferRow: true,
+ linebreakContainer: 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: ','
+ },
+ addFakeNodes: function () {
+ 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({
+ fence:true, form:MML.FORM.PREFIX, texClass:MML.TEXCLASS.OPEN
+ }));
+ }
+ //
+ // Create fake nodes for the separators
+ //
+ if (values.separators !== "") {
+ while (values.separators.length < this.data.length)
+ {values.separators += values.separators.charAt(values.separators.length-1)}
+ for (var i = 1, m = this.data.length; i < m; i++) {
+ if (this.data[i])
+ {this.SetData("sep"+i,MML.mo(values.separators.charAt(i-1)).With({separator:true}))}
+ }
+ }
+ //
+ // Create fake node for the close item
+ //
+ if (values.close !== "") {
+ this.SetData("close",MML.mo(values.close).With({
+ fence:true, form:MML.FORM.POSTFIX, texClass:MML.TEXCLASS.CLOSE
+ }));
+ }
+ },
+ texClass: MML.TEXCLASS.OPEN,
+ setTeXclass: function (prev) {
+ this.addFakeNodes();
+ this.getPrevClass(prev);
+ if (this.data.open) {prev = this.data.open.setTeXclass(prev)}
+ if (this.data[0]) {prev = this.data[0].setTeXclass(prev)}
+ for (var i = 1, m = this.data.length; i < m; i++) {
+ if (this.data["sep"+i]) {prev = this.data["sep"+i].setTeXclass(prev)}
+ if (this.data[i]) {prev = this.data[i].setTeXclass(prev)}
+ }
+ if (this.data.close) {prev = this.data.close.setTeXclass(prev)}
+ this.updateTeXclass(this.data.open);
+ this.texClass = MML.TEXCLASS.INNER;
+ return prev;
+ }
+ });
+
+ MML.menclose = MML.mbase.Subclass({
+ type: "menclose",
+ inferRow: true,
+ linebreakContainer: 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.mmultiscripts = MML.msubsup.Subclass({
+ type: "mmultiscripts",
+ adjustChild_texprimestyle: function (n) {
+ if (n % 2 === 1) {return true}
+ return this.Get("texprimestyle");
+ }
+ });
+ MML.mprescripts = MML.mbase.Subclass({type: "mprescripts"});
+ MML.none = MML.mbase.Subclass({type: "none"});
+
+ MML.munderover = MML.mbase.Subclass({
+ type: "munderover",
+ base: 0, under: 1, over: 2, sub: 1, sup: 2,
+ ACCENTS: ["", "accentunder", "accent"],
+ linebreakContainer: true,
+ 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");
+ var force = (this.data[this.base] && !this.Get("displaystyle") &&
+ this.data[this.base].CoreMO().Get("movablelimits"));
+ if (n == this.under && (force || !this.Get("accentunder"))) {level++}
+ if (n == this.over && (force || !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.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
+ },
+ adjustChild_displaystyle: function () {
+ return (this.displaystyle != null ? this.displaystyle : this.defaults.displaystyle);
+ },
+ inheritFromMe: true,
+ noInherit: {
+ mover: {align: true},
+ munder: {align: true},
+ munderover: {align: true},
+ 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, displaystyle: true,
+ side: true, minlabelspacing: true, texClass: true, useHeight: 1
+ }
+ },
+ linebreakContainer: true,
+ Append: function () {
+ for (var i = 0, m = arguments.length; i < m; i++) {
+ if (!((arguments[i] instanceof MML.mtr) ||
+ (arguments[i] instanceof MML.mlabeledtr))) {arguments[i] = MML.mtr(arguments[i])}
+ }
+ this.SUPER(arguments).Append.apply(this,arguments);
+ },
+ 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}
+ },
+ linebreakContainer: true,
+ Append: function () {
+ for (var i = 0, m = arguments.length; i < m; i++) {
+ if (!(arguments[i] instanceof MML.mtd)) {arguments[i] = MML.mtd(arguments[i])}
+ }
+ this.SUPER(arguments).Append.apply(this,arguments);
+ },
+ setTeXclass: MML.mbase.setSeparateTeXclasses
+ });
+
+ MML.mtd = MML.mbase.Subclass({
+ type: "mtd",
+ inferRow: true,
+ linebreakContainer: true,
+ isEmbellished: MML.mbase.childEmbellished,
+ Core: MML.mbase.childCore,
+ CoreMO: MML.mbase.childCoreMO,
+ 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: "maligngroup",
+ 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
+ },
+ selected: function () {return this.data[this.Get("selection")-1] || MML.NULL},
+ isEmbellished: function () {return this.selected().isEmbellished()},
+ isSpacelike: function () {return this.selected().isSpacelike()},
+ Core: function () {return this.selected().Core()},
+ CoreMO: function () {return this.selected().CoreMO()},
+ setTeXclass: function (prev) {
+ if (this.Get("actiontype") === MML.ACTIONTYPE.TOOLTIP && this.data[1]) {
+ // Make sure tooltip has proper spacing when typeset (see issue #412)
+ this.data[1].setTeXclass();
+ }
+ var selected = this.selected();
+ prev = selected.setTeXclass(prev);
+ this.updateTeXclass(selected);
+ return prev;
+ }
+ });
+
+ MML.semantics = MML.mbase.Subclass({
+ type: "semantics", notParent: true,
+ isEmbellished: MML.mbase.childEmbellished,
+ Core: MML.mbase.childCore,
+ CoreMO: MML.mbase.childCoreMO,
+ defaults: {
+ definitionURL: null,
+ encoding: null
+ },
+ setTeXclass: MML.mbase.setChildTeXclass,
+ getAnnotation: function (name) {
+ var encodingList = MathJax.Hub.config.MathMenu.semanticsAnnotations[name];
+ if (encodingList) {
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ var encoding = this.data[i].Get("encoding");
+ if (encoding) {
+ for (var j = 0, n = encodingList.length; j < n; j++) {
+ if (encodingList[j] === encoding) return this.data[i];
+ }
+ }
+ }
+ }
+ return null;
+ }
+ });
+ MML.annotation = MML.mbase.Subclass({
+ type: "annotation", isChars: true,
+ linebreakContainer: true,
+ defaults: {
+ definitionURL: null,
+ encoding: null,
+ cd: "mathmlkeys",
+ name: "",
+ src: null
+ }
+ });
+ MML["annotation-xml"] = MML.mbase.Subclass({
+ type: "annotation-xml",
+ linebreakContainer: true,
+ 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,
+ dir: "ltr",
+ 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,
+ lineleading: "1ex",
+ indentshift: "auto", // use user configuration
+ indentalign: MML.INDENTALIGN.AUTO,
+ indentalignfirst: MML.INDENTALIGN.INDENTALIGN,
+ indentshiftfirst: MML.INDENTSHIFT.INDENTSHIFT,
+ indentalignlast: MML.INDENTALIGN.INDENTALIGN,
+ indentshiftlast: MML.INDENTSHIFT.INDENTSHIFT,
+ decimalseparator: ".",
+ texprimestyle: false // is it in TeX's C' style?
+ },
+ autoDefault: function (name) {
+ if (name === "displaystyle") {return this.Get("display") === "block"}
+ return "";
+ },
+ linebreakContainer: true,
+ setTeXclass: MML.mbase.setChildTeXclass,
+ getAnnotation: function (name) {
+ if (this.data.length != 1) return null;
+ return this.data[0].getAnnotation(name);
+ }
+ });
+
+ 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)}
+ n -= 0x10000;
+ return String.fromCharCode((n>>10)+0xD800)
+ + String.fromCharCode((n&0x3FF)+0xDC00);
+ }
+ });
+
+ MML.xml = MML.mbase.Subclass({
+ type: "xml",
+ Init: function () {
+ this.div = document.createElement("div");
+ return this.SUPER(arguments).Init.apply(this,arguments);
+ },
+ Append: function () {
+ for (var i = 0, m = arguments.length; i < m; i++) {
+ var node = this.Import(arguments[i]);
+ this.data.push(node);
+ this.div.appendChild(node);
+ }
+ },
+ Import: function (node) {
+ if (document.importNode) {return document.importNode(node,true)}
+ //
+ // IE < 9 doesn't have importNode, so fake it.
+ //
+ var nNode, i, m;
+ if (node.nodeType === 1) { // ELEMENT_NODE
+ nNode = document.createElement(node.nodeName);
+ for (i = 0, m = node.attributes.length; i < m; i++) {
+ var attribute = node.attributes[i];
+ if (attribute.specified && attribute.nodeValue != null && attribute.nodeValue != '')
+ {nNode.setAttribute(attribute.nodeName,attribute.nodeValue)}
+ if (attribute.nodeName === "style") {nNode.style.cssText = attribute.nodeValue}
+ }
+ if (node.className) {nNode.className = node.className}
+ } else if (node.nodeType === 3 || node.nodeType === 4) { // TEXT_NODE or CDATA_SECTION_NODE
+ nNode = document.createTextNode(node.nodeValue);
+ } else if (node.nodeType === 8) { // COMMENT_NODE
+ nNode = document.createComment(node.nodeValue);
+ } else {
+ return document.createTextNode('');
+ }
+ for (i = 0, m = node.childNodes.length; i < m; i++)
+ {nNode.appendChild(this.Import(node.childNodes[i]))}
+ return nNode;
+ },
+ value: function () {return this.div},
+ toString: function () {return this.div.innerHTML}
+ });
+
+ MML.TeXAtom = MML.mbase.Subclass({
+ type: "texatom",
+ linebreakContainer: true,
+ inferRow: true, notParent: true,
+ texClass: MML.TEXCLASS.ORD,
+ Core: MML.mbase.childCore,
+ CoreMO: MML.mbase.childCoreMO,
+ isEmbellished: MML.mbase.childEmbellished,
+ setTeXclass: function (prev) {
+ this.data[0].setTeXclass();
+ return this.adjustTeXclass(prev);
+ },
+ adjustTeXclass: MML.mo.prototype.adjustTeXclass
+ });
+
+ MML.NULL = MML.mbase().With({type:"null"});
+
+ 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],
+ BIN5: [5,5,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],
+ RELSTRETCH: [5,5,TEXCLASS.REL,{stretchy: true}],
+ RELACCENT: [5,5,TEXCLASS.REL,{accent: true}],
+ WIDEREL: [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],
+ [0x2500,0x259F,TEXCLASS.ORD],
+ [0x25A0,0x25FF,TEXCLASS.ORD,"GeometricShapes"],
+ [0x2700,0x27BF,TEXCLASS.ORD,"Dingbats"],
+ [0x27C0,0x27EF,TEXCLASS.ORD,"MiscMathSymbolsA"],
+ [0x27F0,0x27FF,TEXCLASS.REL,"SupplementalArrowsA"],
+ [0x2900,0x297F,TEXCLASS.REL,"SupplementalArrowsB"],
+ [0x2980,0x29FF,TEXCLASS.ORD,"MiscMathSymbolsB"],
+ [0x2A00,0x2AFF,TEXCLASS.BIN,"SuppMathOperators"],
+ [0x2B00,0x2BFF,TEXCLASS.ORD,"MiscSymbolsAndArrows"],
+ [0x1D400,0x1D7FF,TEXCLASS.ORD]
+ ],
+ OPTABLE: {
+ prefix: {
+ '\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
+ '\u27EE': MO.OPEN, // mathematical left flattened parenthesis
+ '\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
+ '\u27EF': MO.CLOSE, // mathematical right flattened parenthesis
+ '\u02C6': MO.WIDEACCENT, // modifier letter circumflex accent
+ '\u02C7': MO.WIDEACCENT, // caron
+ '\u02C9': MO.WIDEACCENT, // modifier letter macron
+ '\u02CA': MO.ACCENT, // modifier letter acute accent
+ '\u02CB': MO.ACCENT, // modifier letter grave accent
+ '\u02D8': MO.ACCENT, // breve
+ '\u02D9': MO.ACCENT, // dot above
+ '\u02DC': MO.WIDEACCENT, // small tilde
+ '\u0302': MO.WIDEACCENT, // 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: {
+ '': MO.ORD, // empty <mo>
+ '%': [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,{linebreakstyle:"after", separator: true}], // invisible separator
+ '\u2064': MO.ORD, // invisible plus
+ '\u2190': MO.WIDEREL, // leftwards arrow
+ '\u2191': MO.RELSTRETCH, // upwards arrow
+ '\u2192': MO.WIDEREL, // rightwards arrow
+ '\u2193': MO.RELSTRETCH, // downwards arrow
+ '\u2194': MO.WIDEREL, // left right arrow
+ '\u2195': MO.RELSTRETCH, // up down arrow
+ '\u2196': MO.RELSTRETCH, // north west arrow
+ '\u2197': MO.RELSTRETCH, // north east arrow
+ '\u2198': MO.RELSTRETCH, // south east arrow
+ '\u2199': MO.RELSTRETCH, // 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.WIDEREL, // leftwards harpoon with barb upwards
+ '\u21BD': MO.WIDEREL, // leftwards harpoon with barb downwards
+ '\u21C0': MO.WIDEREL, // 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.RELSTRETCH, // upwards double arrow
+ '\u21D2': MO.WIDEREL, // rightwards double arrow
+ '\u21D3': MO.RELSTRETCH, // downwards double arrow
+ '\u21D4': MO.WIDEREL, // left right double arrow
+ '\u21D5': MO.RELSTRETCH, // 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
+ '\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': MO.REL, // light vertical bar
+ '\u27F5': MO.WIDEREL, // long leftwards arrow
+ '\u27F6': MO.WIDEREL, // long rightwards arrow
+ '\u27F7': MO.WIDEREL, // long left right arrow
+ '\u27F8': MO.WIDEREL, // long leftwards double arrow
+ '\u27F9': MO.WIDEREL, // long rightwards double arrow
+ '\u27FA': MO.WIDEREL, // long left right double arrow
+ '\u27FC': MO.WIDEREL, // long rightwards arrow from bar
+ '\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,{linebreakstyle:"after", 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,{linebreakstyle:"after", 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, // circumflex accent
+ '_': 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
+ '\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
+ '\u2111': MO.ORD, // \Im
+ '\u2113': MO.ORD, // \ell
+ '\u2118': MO.ORD, // \wp
+ '\u211C': MO.ORD, // \Re
+ '\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
+ '\u2500': MO.ORD, // horizontal line
+ '\u25EF': MO.BIN3, // \bigcirc
+ '\u2660': MO.ORD, // \spadesuit
+ '\u2661': MO.ORD, // \heartsuit
+ '\u2662': MO.ORD, // \diamondsuit
+ '\u2663': MO.ORD, // \clubsuit
+ '\u3008': MO.OPEN, // langle
+ '\u3009': MO.CLOSE, // rangle
+ '\uFE37': MO.WIDEACCENT, // horizontal brace down
+ '\uFE38': MO.WIDEACCENT // horizontal brace up
+ }
+ }
+ },{
+ OPTYPES: MO
+ });
+
+ //
+ // These are not in the W3C table, but FF works this way,
+ // and it makes sense, so add it here
+ //
+ var OPTABLE = MML.mo.prototype.OPTABLE;
+ OPTABLE.infix["^"] = MO.WIDEREL;
+ OPTABLE.infix["_"] = MO.WIDEREL;
+ OPTABLE.prefix["\u2223"] = MO.OPEN;
+ OPTABLE.prefix["\u2225"] = MO.OPEN;
+ OPTABLE.postfix["\u2223"] = MO.CLOSE;
+ OPTABLE.postfix["\u2225"] = MO.CLOSE;
+
+})(MathJax.ElementJax.mml);
+
+MathJax.ElementJax.mml.loadComplete("jax.js");
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/Arrows.js b/js/mathjax/jax/element/mml/optable/Arrows.js
new file mode 100644
index 0000000..fd3bcf8
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/Arrows.js
@@ -0,0 +1,124 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/Arrows.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u219A': MO.RELACCENT, // leftwards arrow with stroke
+ '\u219B': MO.RELACCENT, // rightwards arrow with stroke
+ '\u219C': MO.WIDEREL, // leftwards wave arrow
+ '\u219D': MO.WIDEREL, // rightwards wave arrow
+ '\u219E': MO.WIDEREL, // leftwards two headed arrow
+ '\u219F': MO.WIDEREL, // upwards two headed arrow
+ '\u21A0': MO.WIDEREL, // rightwards two headed arrow
+ '\u21A1': MO.RELSTRETCH, // downwards two headed arrow
+ '\u21A2': MO.WIDEREL, // leftwards arrow with tail
+ '\u21A3': MO.WIDEREL, // rightwards arrow with tail
+ '\u21A4': MO.WIDEREL, // leftwards arrow from bar
+ '\u21A5': MO.RELSTRETCH, // upwards arrow from bar
+ '\u21A7': MO.RELSTRETCH, // downwards arrow from bar
+ '\u21A8': MO.RELSTRETCH, // up down arrow with base
+ '\u21AB': MO.WIDEREL, // leftwards arrow with loop
+ '\u21AC': MO.WIDEREL, // rightwards arrow with loop
+ '\u21AD': MO.WIDEREL, // left right wave arrow
+ '\u21AE': MO.RELACCENT, // left right arrow with stroke
+ '\u21AF': MO.RELSTRETCH, // downwards zigzag arrow
+ '\u21B0': MO.RELSTRETCH, // upwards arrow with tip leftwards
+ '\u21B1': MO.RELSTRETCH, // upwards arrow with tip rightwards
+ '\u21B2': MO.RELSTRETCH, // downwards arrow with tip leftwards
+ '\u21B3': MO.RELSTRETCH, // downwards arrow with tip rightwards
+ '\u21B4': MO.RELSTRETCH, // rightwards arrow with corner downwards
+ '\u21B5': MO.RELSTRETCH, // downwards arrow with corner leftwards
+ '\u21B6': MO.RELACCENT, // anticlockwise top semicircle arrow
+ '\u21B7': MO.RELACCENT, // clockwise top semicircle arrow
+ '\u21B8': MO.REL, // north west arrow to long bar
+ '\u21B9': MO.WIDEREL, // leftwards arrow to bar over rightwards arrow to bar
+ '\u21BA': MO.REL, // anticlockwise open circle arrow
+ '\u21BB': MO.REL, // clockwise open circle arrow
+ '\u21BE': MO.RELSTRETCH, // upwards harpoon with barb rightwards
+ '\u21BF': MO.RELSTRETCH, // upwards harpoon with barb leftwards
+ '\u21C2': MO.RELSTRETCH, // downwards harpoon with barb rightwards
+ '\u21C3': MO.RELSTRETCH, // downwards harpoon with barb leftwards
+ '\u21C4': MO.WIDEREL, // rightwards arrow over leftwards arrow
+ '\u21C5': MO.RELSTRETCH, // upwards arrow leftwards of downwards arrow
+ '\u21C6': MO.WIDEREL, // leftwards arrow over rightwards arrow
+ '\u21C7': MO.WIDEREL, // leftwards paired arrows
+ '\u21C8': MO.RELSTRETCH, // upwards paired arrows
+ '\u21C9': MO.WIDEREL, // rightwards paired arrows
+ '\u21CA': MO.RELSTRETCH, // downwards paired arrows
+ '\u21CB': MO.WIDEREL, // leftwards harpoon over rightwards harpoon
+ '\u21CD': MO.RELACCENT, // leftwards double arrow with stroke
+ '\u21CE': MO.RELACCENT, // left right double arrow with stroke
+ '\u21CF': MO.RELACCENT, // rightwards double arrow with stroke
+ '\u21D6': MO.RELSTRETCH, // north west double arrow
+ '\u21D7': MO.RELSTRETCH, // north east double arrow
+ '\u21D8': MO.RELSTRETCH, // south east double arrow
+ '\u21D9': MO.RELSTRETCH, // south west double arrow
+ '\u21DA': MO.WIDEREL, // leftwards triple arrow
+ '\u21DB': MO.WIDEREL, // rightwards triple arrow
+ '\u21DC': MO.WIDEREL, // leftwards squiggle arrow
+ '\u21DD': MO.WIDEREL, // rightwards squiggle arrow
+ '\u21DE': MO.REL, // upwards arrow with double stroke
+ '\u21DF': MO.REL, // downwards arrow with double stroke
+ '\u21E0': MO.WIDEREL, // leftwards dashed arrow
+ '\u21E1': MO.RELSTRETCH, // upwards dashed arrow
+ '\u21E2': MO.WIDEREL, // rightwards dashed arrow
+ '\u21E3': MO.RELSTRETCH, // downwards dashed arrow
+ '\u21E4': MO.WIDEREL, // leftwards arrow to bar
+ '\u21E5': MO.WIDEREL, // rightwards arrow to bar
+ '\u21E6': MO.WIDEREL, // leftwards white arrow
+ '\u21E7': MO.RELSTRETCH, // upwards white arrow
+ '\u21E8': MO.WIDEREL, // rightwards white arrow
+ '\u21E9': MO.RELSTRETCH, // downwards white arrow
+ '\u21EA': MO.RELSTRETCH, // upwards white arrow from bar
+ '\u21EB': MO.RELSTRETCH, // upwards white arrow on pedestal
+ '\u21EC': MO.RELSTRETCH, // upwards white arrow on pedestal with horizontal bar
+ '\u21ED': MO.RELSTRETCH, // upwards white arrow on pedestal with vertical bar
+ '\u21EE': MO.RELSTRETCH, // upwards white double arrow
+ '\u21EF': MO.RELSTRETCH, // upwards white double arrow on pedestal
+ '\u21F0': MO.WIDEREL, // rightwards white arrow from wall
+ '\u21F1': MO.REL, // north west arrow to corner
+ '\u21F2': MO.REL, // south east arrow to corner
+ '\u21F3': MO.RELSTRETCH, // up down white arrow
+ '\u21F4': MO.RELACCENT, // right arrow with small circle
+ '\u21F5': MO.RELSTRETCH, // downwards arrow leftwards of upwards arrow
+ '\u21F6': MO.WIDEREL, // three rightwards arrows
+ '\u21F7': MO.RELACCENT, // leftwards arrow with vertical stroke
+ '\u21F8': MO.RELACCENT, // rightwards arrow with vertical stroke
+ '\u21F9': MO.RELACCENT, // left right arrow with vertical stroke
+ '\u21FA': MO.RELACCENT, // leftwards arrow with double vertical stroke
+ '\u21FB': MO.RELACCENT, // rightwards arrow with double vertical stroke
+ '\u21FC': MO.RELACCENT, // left right arrow with double vertical stroke
+ '\u21FD': MO.WIDEREL, // leftwards open-headed arrow
+ '\u21FE': MO.WIDEREL, // rightwards open-headed arrow
+ '\u21FF': MO.WIDEREL // left right open-headed arrow
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/Arrows.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/BasicLatin.js b/js/mathjax/jax/element/mml/optable/BasicLatin.js
new file mode 100644
index 0000000..c36b4ed
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/BasicLatin.js
@@ -0,0 +1,67 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
+ '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ },
+ postfix: {
+ '!!': [1,0,TEXCLASS.BIN], // multiple character operator: !!
+ '\'': MO.ACCENT, // apostrophe
+ '++': [0,0,TEXCLASS.BIN], // multiple character operator: ++
+ '--': [0,0,TEXCLASS.BIN], // multiple character operator: --
+ '..': [0,0,TEXCLASS.BIN], // multiple character operator: ..
+ '...': MO.ORD, // multiple character operator: ...
+ '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
+ '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ },
+ infix: {
+ '!=': MO.BIN4, // multiple character operator: !=
+ '&&': MO.BIN4, // multiple character operator: &&
+ '**': [1,1,TEXCLASS.BIN], // multiple character operator: **
+ '*=': MO.BIN4, // multiple character operator: *=
+ '+=': MO.BIN4, // multiple character operator: +=
+ '-=': MO.BIN4, // multiple character operator: -=
+ '->': MO.BIN5, // multiple character operator: ->
+ '//': [1,1,TEXCLASS.BIN], // multiple character operator: //
+ '/=': MO.BIN4, // multiple character operator: /=
+ ':=': MO.BIN4, // multiple character operator: :=
+ '<=': MO.BIN5, // multiple character operator: <=
+ '<>': [1,1,TEXCLASS.BIN], // multiple character operator: <>
+ '==': MO.BIN4, // multiple character operator: ==
+ '>=': MO.BIN5, // multiple character operator: >=
+ '@': MO.ORD11, // commercial at
+ '||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
+ '|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/CombDiacritMarks.js b/js/mathjax/jax/element/mml/optable/CombDiacritMarks.js
new file mode 100644
index 0000000..b275086
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/CombDiacritMarks.js
@@ -0,0 +1,37 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u0311': MO.ACCENT // combining inverted breve
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiacritMarks.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/CombDiactForSymbols.js b/js/mathjax/jax/element/mml/optable/CombDiactForSymbols.js
new file mode 100644
index 0000000..0ac97ab
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/CombDiactForSymbols.js
@@ -0,0 +1,38 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/CombDiactForSymbols.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u20DB': MO.ACCENT, // combining three dots above
+ '\u20DC': MO.ACCENT // combining four dots above
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiactForSymbols.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/Dingbats.js b/js/mathjax/jax/element/mml/optable/Dingbats.js
new file mode 100644
index 0000000..24d5275
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/Dingbats.js
@@ -0,0 +1,40 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/Dingbats.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2772': MO.OPEN // light left tortoise shell bracket ornament
+ },
+ postfix: {
+ '\u2773': MO.CLOSE // light right tortoise shell bracket ornament
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/Dingbats.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/GeneralPunctuation.js b/js/mathjax/jax/element/mml/optable/GeneralPunctuation.js
new file mode 100644
index 0000000..a1019ca
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/GeneralPunctuation.js
@@ -0,0 +1,44 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
+ '\u2018': [0,0,TEXCLASS.OPEN,{fence: true}], // left single quotation mark
+ '\u201C': [0,0,TEXCLASS.OPEN,{fence: true}] // left double quotation mark
+ },
+ postfix: {
+ '\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
+ '\u2019': [0,0,TEXCLASS.CLOSE,{fence: true}], // right single quotation mark
+ '\u201D': [0,0,TEXCLASS.CLOSE,{fence: true}] // right double quotation mark
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/GeneralPunctuation.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/GeometricShapes.js b/js/mathjax/jax/element/mml/optable/GeometricShapes.js
new file mode 100644
index 0000000..2414595
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/GeometricShapes.js
@@ -0,0 +1,68 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u25A0': MO.BIN3, // black square
+ '\u25A1': MO.BIN3, // white square
+ '\u25AA': MO.BIN3, // black small square
+ '\u25AB': MO.BIN3, // white small square
+ '\u25AD': MO.BIN3, // white rectangle
+ '\u25AE': MO.BIN3, // black vertical rectangle
+ '\u25AF': MO.BIN3, // white vertical rectangle
+ '\u25B0': MO.BIN3, // black parallelogram
+ '\u25B1': MO.BIN3, // white parallelogram
+ '\u25B2': MO.BIN4, // black up-pointing triangle
+ '\u25B4': MO.BIN4, // black up-pointing small triangle
+ '\u25B6': MO.BIN4, // black right-pointing triangle
+ '\u25B7': MO.BIN4, // white right-pointing triangle
+ '\u25B8': MO.BIN4, // black right-pointing small triangle
+ '\u25BC': MO.BIN4, // black down-pointing triangle
+ '\u25BE': MO.BIN4, // black down-pointing small triangle
+ '\u25C0': MO.BIN4, // black left-pointing triangle
+ '\u25C1': MO.BIN4, // white left-pointing triangle
+ '\u25C2': MO.BIN4, // black left-pointing small triangle
+ '\u25C4': MO.BIN4, // black left-pointing pointer
+ '\u25C5': MO.BIN4, // white left-pointing pointer
+ '\u25C6': MO.BIN4, // black diamond
+ '\u25C7': MO.BIN4, // white diamond
+ '\u25C8': MO.BIN4, // white diamond containing black small diamond
+ '\u25C9': MO.BIN4, // fisheye
+ '\u25CC': MO.BIN4, // dotted circle
+ '\u25CD': MO.BIN4, // circle with vertical fill
+ '\u25CE': MO.BIN4, // bullseye
+ '\u25CF': MO.BIN4, // black circle
+ '\u25D6': MO.BIN4, // left half black circle
+ '\u25D7': MO.BIN4, // right half black circle
+ '\u25E6': MO.BIN4 // white bullet
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/GeometricShapes.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/GreekAndCoptic.js b/js/mathjax/jax/element/mml/optable/GreekAndCoptic.js
new file mode 100644
index 0000000..fbc9850
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/GreekAndCoptic.js
@@ -0,0 +1,37 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u03F6': MO.REL // greek reversed lunate epsilon symbol
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/GreekAndCoptic.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/Latin1Supplement.js b/js/mathjax/jax/element/mml/optable/Latin1Supplement.js
new file mode 100644
index 0000000..5c34ba0
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/Latin1Supplement.js
@@ -0,0 +1,39 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/Latin1Supplement.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u00B0': MO.ORD, // degree sign
+ '\u00B4': MO.ACCENT, // acute accent
+ '\u00B8': MO.ACCENT // cedilla
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/Latin1Supplement.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/LetterlikeSymbols.js b/js/mathjax/jax/element/mml/optable/LetterlikeSymbols.js
new file mode 100644
index 0000000..a6a0ed7
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/LetterlikeSymbols.js
@@ -0,0 +1,38 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2145': MO.ORD21, // double-struck italic capital d
+ '\u2146': [2,0,TEXCLASS.ORD] // double-struck italic small d
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/LetterlikeSymbols.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/MathOperators.js b/js/mathjax/jax/element/mml/optable/MathOperators.js
new file mode 100644
index 0000000..dd879b0
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/MathOperators.js
@@ -0,0 +1,230 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MathOperators.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2204': MO.ORD21, // there does not exist
+ '\u221B': MO.ORD11, // cube root
+ '\u221C': MO.ORD11, // fourth root
+ '\u2221': MO.ORD, // measured angle
+ '\u2222': MO.ORD, // spherical angle
+ '\u222C': MO.INTEGRAL, // double integral
+ '\u222D': MO.INTEGRAL, // triple integral
+ '\u222F': MO.INTEGRAL, // surface integral
+ '\u2230': MO.INTEGRAL, // volume integral
+ '\u2231': MO.INTEGRAL, // clockwise integral
+ '\u2232': MO.INTEGRAL, // clockwise contour integral
+ '\u2233': MO.INTEGRAL // anticlockwise contour integral
+ },
+ infix: {
+ '\u2201': [1,2,TEXCLASS.ORD], // complement
+ '\u2206': MO.BIN3, // increment
+ '\u220A': MO.REL, // small element of
+ '\u220C': MO.REL, // does not contain as member
+ '\u220D': MO.REL, // small contains as member
+ '\u220E': MO.BIN3, // end of proof
+ '\u2214': MO.BIN4, // dot plus
+ '\u221F': MO.REL, // right angle
+ '\u2224': MO.REL, // does not divide
+ '\u2226': MO.REL, // not parallel to
+ '\u2234': MO.REL, // therefore
+ '\u2235': MO.REL, // because
+ '\u2236': MO.REL, // ratio
+ '\u2237': MO.REL, // proportion
+ '\u2238': MO.BIN4, // dot minus
+ '\u2239': MO.REL, // excess
+ '\u223A': MO.BIN4, // geometric proportion
+ '\u223B': MO.REL, // homothetic
+ '\u223D': MO.REL, // reversed tilde
+ '\u223D\u0331': MO.BIN3, // reversed tilde with underline
+ '\u223E': MO.REL, // inverted lazy s
+ '\u223F': MO.BIN3, // sine wave
+ '\u2241': MO.REL, // not tilde
+ '\u2242': MO.REL, // minus tilde
+ '\u2242\u0338': MO.REL, // minus tilde with slash
+ '\u2244': MO.REL, // not asymptotically equal to
+ '\u2246': MO.REL, // approximately but not actually equal to
+ '\u2247': MO.REL, // neither approximately nor actually equal to
+ '\u2249': MO.REL, // not almost equal to
+ '\u224A': MO.REL, // almost equal or equal to
+ '\u224B': MO.REL, // triple tilde
+ '\u224C': MO.REL, // all equal to
+ '\u224E': MO.REL, // geometrically equivalent to
+ '\u224E\u0338': MO.REL, // geometrically equivalent to with slash
+ '\u224F': MO.REL, // difference between
+ '\u224F\u0338': MO.REL, // difference between with slash
+ '\u2251': MO.REL, // geometrically equal to
+ '\u2252': MO.REL, // approximately equal to or the image of
+ '\u2253': MO.REL, // image of or approximately equal to
+ '\u2254': MO.REL, // colon equals
+ '\u2255': MO.REL, // equals colon
+ '\u2256': MO.REL, // ring in equal to
+ '\u2257': MO.REL, // ring equal to
+ '\u2258': MO.REL, // corresponds to
+ '\u2259': MO.REL, // estimates
+ '\u225A': MO.REL, // equiangular to
+ '\u225C': MO.REL, // delta equal to
+ '\u225D': MO.REL, // equal to by definition
+ '\u225E': MO.REL, // measured by
+ '\u225F': MO.REL, // questioned equal to
+ '\u2262': MO.REL, // not identical to
+ '\u2263': MO.REL, // strictly equivalent to
+ '\u2266': MO.REL, // less-than over equal to
+ '\u2266\u0338': MO.REL, // less-than over equal to with slash
+ '\u2267': MO.REL, // greater-than over equal to
+ '\u2268': MO.REL, // less-than but not equal to
+ '\u2269': MO.REL, // greater-than but not equal to
+ '\u226A\u0338': MO.REL, // much less than with slash
+ '\u226B\u0338': MO.REL, // much greater than with slash
+ '\u226C': MO.REL, // between
+ '\u226D': MO.REL, // not equivalent to
+ '\u226E': MO.REL, // not less-than
+ '\u226F': MO.REL, // not greater-than
+ '\u2270': MO.REL, // neither less-than nor equal to
+ '\u2271': MO.REL, // neither greater-than nor equal to
+ '\u2272': MO.REL, // less-than or equivalent to
+ '\u2273': MO.REL, // greater-than or equivalent to
+ '\u2274': MO.REL, // neither less-than nor equivalent to
+ '\u2275': MO.REL, // neither greater-than nor equivalent to
+ '\u2276': MO.REL, // less-than or greater-than
+ '\u2277': MO.REL, // greater-than or less-than
+ '\u2278': MO.REL, // neither less-than nor greater-than
+ '\u2279': MO.REL, // neither greater-than nor less-than
+ '\u227C': MO.REL, // precedes or equal to
+ '\u227D': MO.REL, // succeeds or equal to
+ '\u227E': MO.REL, // precedes or equivalent to
+ '\u227F': MO.REL, // succeeds or equivalent to
+ '\u227F\u0338': MO.REL, // succeeds or equivalent to with slash
+ '\u2280': MO.REL, // does not precede
+ '\u2281': MO.REL, // does not succeed
+ '\u2282\u20D2': MO.REL, // subset of with vertical line
+ '\u2283\u20D2': MO.REL, // superset of with vertical line
+ '\u2284': MO.REL, // not a subset of
+ '\u2285': MO.REL, // not a superset of
+ '\u2288': MO.REL, // neither a subset of nor equal to
+ '\u2289': MO.REL, // neither a superset of nor equal to
+ '\u228A': MO.REL, // subset of with not equal to
+ '\u228B': MO.REL, // superset of with not equal to
+ '\u228C': MO.BIN4, // multiset
+ '\u228D': MO.BIN4, // multiset multiplication
+ '\u228F': MO.REL, // square image of
+ '\u228F\u0338': MO.REL, // square image of with slash
+ '\u2290': MO.REL, // square original of
+ '\u2290\u0338': MO.REL, // square original of with slash
+ '\u229A': MO.BIN4, // circled ring operator
+ '\u229B': MO.BIN4, // circled asterisk operator
+ '\u229C': MO.BIN4, // circled equals
+ '\u229D': MO.BIN4, // circled dash
+ '\u229E': MO.BIN4, // squared plus
+ '\u229F': MO.BIN4, // squared minus
+ '\u22A0': MO.BIN4, // squared times
+ '\u22A1': MO.BIN4, // squared dot operator
+ '\u22A6': MO.REL, // assertion
+ '\u22A7': MO.REL, // models
+ '\u22A9': MO.REL, // forces
+ '\u22AA': MO.REL, // triple vertical bar right turnstile
+ '\u22AB': MO.REL, // double vertical bar double right turnstile
+ '\u22AC': MO.REL, // does not prove
+ '\u22AD': MO.REL, // not true
+ '\u22AE': MO.REL, // does not force
+ '\u22AF': MO.REL, // negated double vertical bar double right turnstile
+ '\u22B0': MO.REL, // precedes under relation
+ '\u22B1': MO.REL, // succeeds under relation
+ '\u22B2': MO.REL, // normal subgroup of
+ '\u22B3': MO.REL, // contains as normal subgroup
+ '\u22B4': MO.REL, // normal subgroup of or equal to
+ '\u22B5': MO.REL, // contains as normal subgroup or equal to
+ '\u22B6': MO.REL, // original of
+ '\u22B7': MO.REL, // image of
+ '\u22B8': MO.REL, // multimap
+ '\u22B9': MO.REL, // hermitian conjugate matrix
+ '\u22BA': MO.BIN4, // intercalate
+ '\u22BB': MO.BIN4, // xor
+ '\u22BC': MO.BIN4, // nand
+ '\u22BD': MO.BIN4, // nor
+ '\u22BE': MO.BIN3, // right angle with arc
+ '\u22BF': MO.BIN3, // right triangle
+ '\u22C7': MO.BIN4, // division times
+ '\u22C9': MO.BIN4, // left normal factor semidirect product
+ '\u22CA': MO.BIN4, // right normal factor semidirect product
+ '\u22CB': MO.BIN4, // left semidirect product
+ '\u22CC': MO.BIN4, // right semidirect product
+ '\u22CD': MO.REL, // reversed tilde equals
+ '\u22CE': MO.BIN4, // curly logical or
+ '\u22CF': MO.BIN4, // curly logical and
+ '\u22D0': MO.REL, // double subset
+ '\u22D1': MO.REL, // double superset
+ '\u22D2': MO.BIN4, // double intersection
+ '\u22D3': MO.BIN4, // double union
+ '\u22D4': MO.REL, // pitchfork
+ '\u22D5': MO.REL, // equal and parallel to
+ '\u22D6': MO.REL, // less-than with dot
+ '\u22D7': MO.REL, // greater-than with dot
+ '\u22D8': MO.REL, // very much less-than
+ '\u22D9': MO.REL, // very much greater-than
+ '\u22DA': MO.REL, // less-than equal to or greater-than
+ '\u22DB': MO.REL, // greater-than equal to or less-than
+ '\u22DC': MO.REL, // equal to or less-than
+ '\u22DD': MO.REL, // equal to or greater-than
+ '\u22DE': MO.REL, // equal to or precedes
+ '\u22DF': MO.REL, // equal to or succeeds
+ '\u22E0': MO.REL, // does not precede or equal
+ '\u22E1': MO.REL, // does not succeed or equal
+ '\u22E2': MO.REL, // not square image of or equal to
+ '\u22E3': MO.REL, // not square original of or equal to
+ '\u22E4': MO.REL, // square image of or not equal to
+ '\u22E5': MO.REL, // square original of or not equal to
+ '\u22E6': MO.REL, // less-than but not equivalent to
+ '\u22E7': MO.REL, // greater-than but not equivalent to
+ '\u22E8': MO.REL, // precedes but not equivalent to
+ '\u22E9': MO.REL, // succeeds but not equivalent to
+ '\u22EA': MO.REL, // not normal subgroup of
+ '\u22EB': MO.REL, // does not contain as normal subgroup
+ '\u22EC': MO.REL, // not normal subgroup of or equal to
+ '\u22ED': MO.REL, // does not contain as normal subgroup or equal
+ '\u22F0': MO.REL, // up right diagonal ellipsis
+ '\u22F2': MO.REL, // element of with long horizontal stroke
+ '\u22F3': MO.REL, // element of with vertical bar at end of horizontal stroke
+ '\u22F4': MO.REL, // small element of with vertical bar at end of horizontal stroke
+ '\u22F5': MO.REL, // element of with dot above
+ '\u22F6': MO.REL, // element of with overbar
+ '\u22F7': MO.REL, // small element of with overbar
+ '\u22F8': MO.REL, // element of with underbar
+ '\u22F9': MO.REL, // element of with two horizontal strokes
+ '\u22FA': MO.REL, // contains with long horizontal stroke
+ '\u22FB': MO.REL, // contains with vertical bar at end of horizontal stroke
+ '\u22FC': MO.REL, // small contains with vertical bar at end of horizontal stroke
+ '\u22FD': MO.REL, // contains with overbar
+ '\u22FE': MO.REL, // small contains with overbar
+ '\u22FF': MO.REL // z notation bag membership
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MathOperators.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/MiscMathSymbolsA.js b/js/mathjax/jax/element/mml/optable/MiscMathSymbolsA.js
new file mode 100644
index 0000000..eba7ee1
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/MiscMathSymbolsA.js
@@ -0,0 +1,44 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u27E6': MO.OPEN, // mathematical left white square bracket
+ '\u27EA': MO.OPEN, // mathematical left double angle bracket
+ '\u27EC': MO.OPEN // mathematical left white tortoise shell bracket
+ },
+ postfix: {
+ '\u27E7': MO.CLOSE, // mathematical right white square bracket
+ '\u27EB': MO.CLOSE, // mathematical right double angle bracket
+ '\u27ED': MO.CLOSE // mathematical right white tortoise shell bracket
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsA.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/MiscMathSymbolsB.js b/js/mathjax/jax/element/mml/optable/MiscMathSymbolsB.js
new file mode 100644
index 0000000..975012d
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/MiscMathSymbolsB.js
@@ -0,0 +1,170 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsB.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2980': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // triple vertical bar delimiter
+ '\u2983': MO.OPEN, // left white curly bracket
+ '\u2985': MO.OPEN, // left white parenthesis
+ '\u2987': MO.OPEN, // z notation left image bracket
+ '\u2989': MO.OPEN, // z notation left binding bracket
+ '\u298B': MO.OPEN, // left square bracket with underbar
+ '\u298D': MO.OPEN, // left square bracket with tick in top corner
+ '\u298F': MO.OPEN, // left square bracket with tick in bottom corner
+ '\u2991': MO.OPEN, // left angle bracket with dot
+ '\u2993': MO.OPEN, // left arc less-than bracket
+ '\u2995': MO.OPEN, // double left arc greater-than bracket
+ '\u2997': MO.OPEN, // left black tortoise shell bracket
+ '\u29FC': MO.OPEN // left-pointing curved angle bracket
+ },
+ postfix: {
+ '\u2980': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // triple vertical bar delimiter
+ '\u2984': MO.CLOSE, // right white curly bracket
+ '\u2986': MO.CLOSE, // right white parenthesis
+ '\u2988': MO.CLOSE, // z notation right image bracket
+ '\u298A': MO.CLOSE, // z notation right binding bracket
+ '\u298C': MO.CLOSE, // right square bracket with underbar
+ '\u298E': MO.CLOSE, // right square bracket with tick in bottom corner
+ '\u2990': MO.CLOSE, // right square bracket with tick in top corner
+ '\u2992': MO.CLOSE, // right angle bracket with dot
+ '\u2994': MO.CLOSE, // right arc greater-than bracket
+ '\u2996': MO.CLOSE, // double right arc less-than bracket
+ '\u2998': MO.CLOSE, // right black tortoise shell bracket
+ '\u29FD': MO.CLOSE // right-pointing curved angle bracket
+ },
+ infix: {
+ '\u2981': MO.BIN3, // z notation spot
+ '\u2982': MO.BIN3, // z notation type colon
+ '\u2999': MO.BIN3, // dotted fence
+ '\u299A': MO.BIN3, // vertical zigzag line
+ '\u299B': MO.BIN3, // measured angle opening left
+ '\u299C': MO.BIN3, // right angle variant with square
+ '\u299D': MO.BIN3, // measured right angle with dot
+ '\u299E': MO.BIN3, // angle with s inside
+ '\u299F': MO.BIN3, // acute angle
+ '\u29A0': MO.BIN3, // spherical angle opening left
+ '\u29A1': MO.BIN3, // spherical angle opening up
+ '\u29A2': MO.BIN3, // turned angle
+ '\u29A3': MO.BIN3, // reversed angle
+ '\u29A4': MO.BIN3, // angle with underbar
+ '\u29A5': MO.BIN3, // reversed angle with underbar
+ '\u29A6': MO.BIN3, // oblique angle opening up
+ '\u29A7': MO.BIN3, // oblique angle opening down
+ '\u29A8': MO.BIN3, // measured angle with open arm ending in arrow pointing up and right
+ '\u29A9': MO.BIN3, // measured angle with open arm ending in arrow pointing up and left
+ '\u29AA': MO.BIN3, // measured angle with open arm ending in arrow pointing down and right
+ '\u29AB': MO.BIN3, // measured angle with open arm ending in arrow pointing down and left
+ '\u29AC': MO.BIN3, // measured angle with open arm ending in arrow pointing right and up
+ '\u29AD': MO.BIN3, // measured angle with open arm ending in arrow pointing left and up
+ '\u29AE': MO.BIN3, // measured angle with open arm ending in arrow pointing right and down
+ '\u29AF': MO.BIN3, // measured angle with open arm ending in arrow pointing left and down
+ '\u29B0': MO.BIN3, // reversed empty set
+ '\u29B1': MO.BIN3, // empty set with overbar
+ '\u29B2': MO.BIN3, // empty set with small circle above
+ '\u29B3': MO.BIN3, // empty set with right arrow above
+ '\u29B4': MO.BIN3, // empty set with left arrow above
+ '\u29B5': MO.BIN3, // circle with horizontal bar
+ '\u29B6': MO.BIN4, // circled vertical bar
+ '\u29B7': MO.BIN4, // circled parallel
+ '\u29B8': MO.BIN4, // circled reverse solidus
+ '\u29B9': MO.BIN4, // circled perpendicular
+ '\u29BA': MO.BIN4, // circle divided by horizontal bar and top half divided by vertical bar
+ '\u29BB': MO.BIN4, // circle with superimposed x
+ '\u29BC': MO.BIN4, // circled anticlockwise-rotated division sign
+ '\u29BD': MO.BIN4, // up arrow through circle
+ '\u29BE': MO.BIN4, // circled white bullet
+ '\u29BF': MO.BIN4, // circled bullet
+ '\u29C0': MO.REL, // circled less-than
+ '\u29C1': MO.REL, // circled greater-than
+ '\u29C2': MO.BIN3, // circle with small circle to the right
+ '\u29C3': MO.BIN3, // circle with two horizontal strokes to the right
+ '\u29C4': MO.BIN4, // squared rising diagonal slash
+ '\u29C5': MO.BIN4, // squared falling diagonal slash
+ '\u29C6': MO.BIN4, // squared asterisk
+ '\u29C7': MO.BIN4, // squared small circle
+ '\u29C8': MO.BIN4, // squared square
+ '\u29C9': MO.BIN3, // two joined squares
+ '\u29CA': MO.BIN3, // triangle with dot above
+ '\u29CB': MO.BIN3, // triangle with underbar
+ '\u29CC': MO.BIN3, // s in triangle
+ '\u29CD': MO.BIN3, // triangle with serifs at bottom
+ '\u29CE': MO.REL, // right triangle above left triangle
+ '\u29CF': MO.REL, // left triangle beside vertical bar
+ '\u29CF\u0338': MO.REL, // left triangle beside vertical bar with slash
+ '\u29D0': MO.REL, // vertical bar beside right triangle
+ '\u29D0\u0338': MO.REL, // vertical bar beside right triangle with slash
+ '\u29D1': MO.REL, // bowtie with left half black
+ '\u29D2': MO.REL, // bowtie with right half black
+ '\u29D3': MO.REL, // black bowtie
+ '\u29D4': MO.REL, // times with left half black
+ '\u29D5': MO.REL, // times with right half black
+ '\u29D6': MO.BIN4, // white hourglass
+ '\u29D7': MO.BIN4, // black hourglass
+ '\u29D8': MO.BIN3, // left wiggly fence
+ '\u29D9': MO.BIN3, // right wiggly fence
+ '\u29DB': MO.BIN3, // right double wiggly fence
+ '\u29DC': MO.BIN3, // incomplete infinity
+ '\u29DD': MO.BIN3, // tie over infinity
+ '\u29DE': MO.REL, // infinity negated with vertical bar
+ '\u29DF': MO.BIN3, // double-ended multimap
+ '\u29E0': MO.BIN3, // square with contoured outline
+ '\u29E1': MO.REL, // increases as
+ '\u29E2': MO.BIN4, // shuffle product
+ '\u29E3': MO.REL, // equals sign and slanted parallel
+ '\u29E4': MO.REL, // equals sign and slanted parallel with tilde above
+ '\u29E5': MO.REL, // identical to and slanted parallel
+ '\u29E6': MO.REL, // gleich stark
+ '\u29E7': MO.BIN3, // thermodynamic
+ '\u29E8': MO.BIN3, // down-pointing triangle with left half black
+ '\u29E9': MO.BIN3, // down-pointing triangle with right half black
+ '\u29EA': MO.BIN3, // black diamond with down arrow
+ '\u29EB': MO.BIN3, // black lozenge
+ '\u29EC': MO.BIN3, // white circle with down arrow
+ '\u29ED': MO.BIN3, // black circle with down arrow
+ '\u29EE': MO.BIN3, // error-barred white square
+ '\u29EF': MO.BIN3, // error-barred black square
+ '\u29F0': MO.BIN3, // error-barred white diamond
+ '\u29F1': MO.BIN3, // error-barred black diamond
+ '\u29F2': MO.BIN3, // error-barred white circle
+ '\u29F3': MO.BIN3, // error-barred black circle
+ '\u29F4': MO.REL, // rule-delayed
+ '\u29F5': MO.BIN4, // reverse solidus operator
+ '\u29F6': MO.BIN4, // solidus with overbar
+ '\u29F7': MO.BIN4, // reverse solidus with horizontal stroke
+ '\u29F8': MO.BIN3, // big solidus
+ '\u29F9': MO.BIN3, // big reverse solidus
+ '\u29FA': MO.BIN3, // double plus
+ '\u29FB': MO.BIN3, // triple plus
+ '\u29FE': MO.BIN4, // tiny
+ '\u29FF': MO.BIN4 // miny
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsB.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/MiscSymbolsAndArrows.js b/js/mathjax/jax/element/mml/optable/MiscSymbolsAndArrows.js
new file mode 100644
index 0000000..d869d1d
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/MiscSymbolsAndArrows.js
@@ -0,0 +1,38 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MiscSymbolsAndArrows.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u2B45': MO.RELSTRETCH, // leftwards quadruple arrow
+ '\u2B46': MO.RELSTRETCH // rightwards quadruple arrow
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscSymbolsAndArrows.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/MiscTechnical.js b/js/mathjax/jax/element/mml/optable/MiscTechnical.js
new file mode 100644
index 0000000..da38d70
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/MiscTechnical.js
@@ -0,0 +1,42 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u23B4': MO.WIDEACCENT, // top square bracket
+ '\u23B5': MO.WIDEACCENT, // bottom square bracket
+ '\u23DC': MO.WIDEACCENT, // top parenthesis
+ '\u23DD': MO.WIDEACCENT, // bottom parenthesis
+ '\u23E0': MO.WIDEACCENT, // top tortoise shell bracket
+ '\u23E1': MO.WIDEACCENT // bottom tortoise shell bracket
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscTechnical.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/SpacingModLetters.js b/js/mathjax/jax/element/mml/optable/SpacingModLetters.js
new file mode 100644
index 0000000..a6eaa41
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/SpacingModLetters.js
@@ -0,0 +1,40 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u02CD': MO.WIDEACCENT, // modifier letter low macron
+ '\u02DA': MO.ACCENT, // ring above
+ '\u02DD': MO.ACCENT, // double acute accent
+ '\u02F7': MO.WIDEACCENT // modifier letter low tilde
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SpacingModLetters.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/SuppMathOperators.js b/js/mathjax/jax/element/mml/optable/SuppMathOperators.js
new file mode 100644
index 0000000..e281b1c
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/SuppMathOperators.js
@@ -0,0 +1,291 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SuppMathOperators.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2A03': MO.OP, // n-ary union operator with dot
+ '\u2A05': MO.OP, // n-ary square intersection operator
+ '\u2A07': MO.OP, // two logical and operator
+ '\u2A08': MO.OP, // two logical or operator
+ '\u2A09': MO.OP, // n-ary times operator
+ '\u2A0A': MO.OP, // modulo two sum
+ '\u2A0B': MO.INTEGRAL2, // summation with integral
+ '\u2A0C': MO.INTEGRAL, // quadruple integral operator
+ '\u2A0D': MO.INTEGRAL2, // finite part integral
+ '\u2A0E': MO.INTEGRAL2, // integral with double stroke
+ '\u2A0F': MO.INTEGRAL2, // integral average with slash
+ '\u2A10': MO.OP, // circulation function
+ '\u2A11': MO.OP, // anticlockwise integration
+ '\u2A12': MO.OP, // line integration with rectangular path around pole
+ '\u2A13': MO.OP, // line integration with semicircular path around pole
+ '\u2A14': MO.OP, // line integration not including the pole
+ '\u2A15': MO.INTEGRAL2, // integral around a point operator
+ '\u2A16': MO.INTEGRAL2, // quaternion integral operator
+ '\u2A17': MO.INTEGRAL2, // integral with leftwards arrow with hook
+ '\u2A18': MO.INTEGRAL2, // integral with times sign
+ '\u2A19': MO.INTEGRAL2, // integral with intersection
+ '\u2A1A': MO.INTEGRAL2, // integral with union
+ '\u2A1B': MO.INTEGRAL2, // integral with overbar
+ '\u2A1C': MO.INTEGRAL2, // integral with underbar
+ '\u2AFC': MO.OP, // large triple vertical bar operator
+ '\u2AFF': MO.OP // n-ary white vertical bar
+ },
+ infix: {
+ '\u2A1D': MO.BIN3, // join
+ '\u2A1E': MO.BIN3, // large left triangle operator
+ '\u2A1F': MO.BIN3, // z notation schema composition
+ '\u2A20': MO.BIN3, // z notation schema piping
+ '\u2A21': MO.BIN3, // z notation schema projection
+ '\u2A22': MO.BIN4, // plus sign with small circle above
+ '\u2A23': MO.BIN4, // plus sign with circumflex accent above
+ '\u2A24': MO.BIN4, // plus sign with tilde above
+ '\u2A25': MO.BIN4, // plus sign with dot below
+ '\u2A26': MO.BIN4, // plus sign with tilde below
+ '\u2A27': MO.BIN4, // plus sign with subscript two
+ '\u2A28': MO.BIN4, // plus sign with black triangle
+ '\u2A29': MO.BIN4, // minus sign with comma above
+ '\u2A2A': MO.BIN4, // minus sign with dot below
+ '\u2A2B': MO.BIN4, // minus sign with falling dots
+ '\u2A2C': MO.BIN4, // minus sign with rising dots
+ '\u2A2D': MO.BIN4, // plus sign in left half circle
+ '\u2A2E': MO.BIN4, // plus sign in right half circle
+ '\u2A30': MO.BIN4, // multiplication sign with dot above
+ '\u2A31': MO.BIN4, // multiplication sign with underbar
+ '\u2A32': MO.BIN4, // semidirect product with bottom closed
+ '\u2A33': MO.BIN4, // smash product
+ '\u2A34': MO.BIN4, // multiplication sign in left half circle
+ '\u2A35': MO.BIN4, // multiplication sign in right half circle
+ '\u2A36': MO.BIN4, // circled multiplication sign with circumflex accent
+ '\u2A37': MO.BIN4, // multiplication sign in double circle
+ '\u2A38': MO.BIN4, // circled division sign
+ '\u2A39': MO.BIN4, // plus sign in triangle
+ '\u2A3A': MO.BIN4, // minus sign in triangle
+ '\u2A3B': MO.BIN4, // multiplication sign in triangle
+ '\u2A3C': MO.BIN4, // interior product
+ '\u2A3D': MO.BIN4, // righthand interior product
+ '\u2A3E': MO.BIN4, // z notation relational composition
+ '\u2A40': MO.BIN4, // intersection with dot
+ '\u2A41': MO.BIN4, // union with minus sign
+ '\u2A42': MO.BIN4, // union with overbar
+ '\u2A43': MO.BIN4, // intersection with overbar
+ '\u2A44': MO.BIN4, // intersection with logical and
+ '\u2A45': MO.BIN4, // union with logical or
+ '\u2A46': MO.BIN4, // union above intersection
+ '\u2A47': MO.BIN4, // intersection above union
+ '\u2A48': MO.BIN4, // union above bar above intersection
+ '\u2A49': MO.BIN4, // intersection above bar above union
+ '\u2A4A': MO.BIN4, // union beside and joined with union
+ '\u2A4B': MO.BIN4, // intersection beside and joined with intersection
+ '\u2A4C': MO.BIN4, // closed union with serifs
+ '\u2A4D': MO.BIN4, // closed intersection with serifs
+ '\u2A4E': MO.BIN4, // double square intersection
+ '\u2A4F': MO.BIN4, // double square union
+ '\u2A50': MO.BIN4, // closed union with serifs and smash product
+ '\u2A51': MO.BIN4, // logical and with dot above
+ '\u2A52': MO.BIN4, // logical or with dot above
+ '\u2A53': MO.BIN4, // double logical and
+ '\u2A54': MO.BIN4, // double logical or
+ '\u2A55': MO.BIN4, // two intersecting logical and
+ '\u2A56': MO.BIN4, // two intersecting logical or
+ '\u2A57': MO.BIN4, // sloping large or
+ '\u2A58': MO.BIN4, // sloping large and
+ '\u2A59': MO.REL, // logical or overlapping logical and
+ '\u2A5A': MO.BIN4, // logical and with middle stem
+ '\u2A5B': MO.BIN4, // logical or with middle stem
+ '\u2A5C': MO.BIN4, // logical and with horizontal dash
+ '\u2A5D': MO.BIN4, // logical or with horizontal dash
+ '\u2A5E': MO.BIN4, // logical and with double overbar
+ '\u2A5F': MO.BIN4, // logical and with underbar
+ '\u2A60': MO.BIN4, // logical and with double underbar
+ '\u2A61': MO.BIN4, // small vee with underbar
+ '\u2A62': MO.BIN4, // logical or with double overbar
+ '\u2A63': MO.BIN4, // logical or with double underbar
+ '\u2A64': MO.BIN4, // z notation domain antirestriction
+ '\u2A65': MO.BIN4, // z notation range antirestriction
+ '\u2A66': MO.REL, // equals sign with dot below
+ '\u2A67': MO.REL, // identical with dot above
+ '\u2A68': MO.REL, // triple horizontal bar with double vertical stroke
+ '\u2A69': MO.REL, // triple horizontal bar with triple vertical stroke
+ '\u2A6A': MO.REL, // tilde operator with dot above
+ '\u2A6B': MO.REL, // tilde operator with rising dots
+ '\u2A6C': MO.REL, // similar minus similar
+ '\u2A6D': MO.REL, // congruent with dot above
+ '\u2A6E': MO.REL, // equals with asterisk
+ '\u2A6F': MO.REL, // almost equal to with circumflex accent
+ '\u2A70': MO.REL, // approximately equal or equal to
+ '\u2A71': MO.BIN4, // equals sign above plus sign
+ '\u2A72': MO.BIN4, // plus sign above equals sign
+ '\u2A73': MO.REL, // equals sign above tilde operator
+ '\u2A74': MO.REL, // double colon equal
+ '\u2A75': MO.REL, // two consecutive equals signs
+ '\u2A76': MO.REL, // three consecutive equals signs
+ '\u2A77': MO.REL, // equals sign with two dots above and two dots below
+ '\u2A78': MO.REL, // equivalent with four dots above
+ '\u2A79': MO.REL, // less-than with circle inside
+ '\u2A7A': MO.REL, // greater-than with circle inside
+ '\u2A7B': MO.REL, // less-than with question mark above
+ '\u2A7C': MO.REL, // greater-than with question mark above
+ '\u2A7D': MO.REL, // less-than or slanted equal to
+ '\u2A7D\u0338': MO.REL, // less-than or slanted equal to with slash
+ '\u2A7E': MO.REL, // greater-than or slanted equal to
+ '\u2A7E\u0338': MO.REL, // greater-than or slanted equal to with slash
+ '\u2A7F': MO.REL, // less-than or slanted equal to with dot inside
+ '\u2A80': MO.REL, // greater-than or slanted equal to with dot inside
+ '\u2A81': MO.REL, // less-than or slanted equal to with dot above
+ '\u2A82': MO.REL, // greater-than or slanted equal to with dot above
+ '\u2A83': MO.REL, // less-than or slanted equal to with dot above right
+ '\u2A84': MO.REL, // greater-than or slanted equal to with dot above left
+ '\u2A85': MO.REL, // less-than or approximate
+ '\u2A86': MO.REL, // greater-than or approximate
+ '\u2A87': MO.REL, // less-than and single-line not equal to
+ '\u2A88': MO.REL, // greater-than and single-line not equal to
+ '\u2A89': MO.REL, // less-than and not approximate
+ '\u2A8A': MO.REL, // greater-than and not approximate
+ '\u2A8B': MO.REL, // less-than above double-line equal above greater-than
+ '\u2A8C': MO.REL, // greater-than above double-line equal above less-than
+ '\u2A8D': MO.REL, // less-than above similar or equal
+ '\u2A8E': MO.REL, // greater-than above similar or equal
+ '\u2A8F': MO.REL, // less-than above similar above greater-than
+ '\u2A90': MO.REL, // greater-than above similar above less-than
+ '\u2A91': MO.REL, // less-than above greater-than above double-line equal
+ '\u2A92': MO.REL, // greater-than above less-than above double-line equal
+ '\u2A93': MO.REL, // less-than above slanted equal above greater-than above slanted equal
+ '\u2A94': MO.REL, // greater-than above slanted equal above less-than above slanted equal
+ '\u2A95': MO.REL, // slanted equal to or less-than
+ '\u2A96': MO.REL, // slanted equal to or greater-than
+ '\u2A97': MO.REL, // slanted equal to or less-than with dot inside
+ '\u2A98': MO.REL, // slanted equal to or greater-than with dot inside
+ '\u2A99': MO.REL, // double-line equal to or less-than
+ '\u2A9A': MO.REL, // double-line equal to or greater-than
+ '\u2A9B': MO.REL, // double-line slanted equal to or less-than
+ '\u2A9C': MO.REL, // double-line slanted equal to or greater-than
+ '\u2A9D': MO.REL, // similar or less-than
+ '\u2A9E': MO.REL, // similar or greater-than
+ '\u2A9F': MO.REL, // similar above less-than above equals sign
+ '\u2AA0': MO.REL, // similar above greater-than above equals sign
+ '\u2AA1': MO.REL, // double nested less-than
+ '\u2AA1\u0338': MO.REL, // double nested less-than with slash
+ '\u2AA2': MO.REL, // double nested greater-than
+ '\u2AA2\u0338': MO.REL, // double nested greater-than with slash
+ '\u2AA3': MO.REL, // double nested less-than with underbar
+ '\u2AA4': MO.REL, // greater-than overlapping less-than
+ '\u2AA5': MO.REL, // greater-than beside less-than
+ '\u2AA6': MO.REL, // less-than closed by curve
+ '\u2AA7': MO.REL, // greater-than closed by curve
+ '\u2AA8': MO.REL, // less-than closed by curve above slanted equal
+ '\u2AA9': MO.REL, // greater-than closed by curve above slanted equal
+ '\u2AAA': MO.REL, // smaller than
+ '\u2AAB': MO.REL, // larger than
+ '\u2AAC': MO.REL, // smaller than or equal to
+ '\u2AAD': MO.REL, // larger than or equal to
+ '\u2AAE': MO.REL, // equals sign with bumpy above
+ '\u2AAF\u0338': MO.REL, // precedes above single-line equals sign with slash
+ '\u2AB0\u0338': MO.REL, // succeeds above single-line equals sign with slash
+ '\u2AB1': MO.REL, // precedes above single-line not equal to
+ '\u2AB2': MO.REL, // succeeds above single-line not equal to
+ '\u2AB3': MO.REL, // precedes above equals sign
+ '\u2AB4': MO.REL, // succeeds above equals sign
+ '\u2AB5': MO.REL, // precedes above not equal to
+ '\u2AB6': MO.REL, // succeeds above not equal to
+ '\u2AB7': MO.REL, // precedes above almost equal to
+ '\u2AB8': MO.REL, // succeeds above almost equal to
+ '\u2AB9': MO.REL, // precedes above not almost equal to
+ '\u2ABA': MO.REL, // succeeds above not almost equal to
+ '\u2ABB': MO.REL, // double precedes
+ '\u2ABC': MO.REL, // double succeeds
+ '\u2ABD': MO.REL, // subset with dot
+ '\u2ABE': MO.REL, // superset with dot
+ '\u2ABF': MO.REL, // subset with plus sign below
+ '\u2AC0': MO.REL, // superset with plus sign below
+ '\u2AC1': MO.REL, // subset with multiplication sign below
+ '\u2AC2': MO.REL, // superset with multiplication sign below
+ '\u2AC3': MO.REL, // subset of or equal to with dot above
+ '\u2AC4': MO.REL, // superset of or equal to with dot above
+ '\u2AC5': MO.REL, // subset of above equals sign
+ '\u2AC6': MO.REL, // superset of above equals sign
+ '\u2AC7': MO.REL, // subset of above tilde operator
+ '\u2AC8': MO.REL, // superset of above tilde operator
+ '\u2AC9': MO.REL, // subset of above almost equal to
+ '\u2ACA': MO.REL, // superset of above almost equal to
+ '\u2ACB': MO.REL, // subset of above not equal to
+ '\u2ACC': MO.REL, // superset of above not equal to
+ '\u2ACD': MO.REL, // square left open box operator
+ '\u2ACE': MO.REL, // square right open box operator
+ '\u2ACF': MO.REL, // closed subset
+ '\u2AD0': MO.REL, // closed superset
+ '\u2AD1': MO.REL, // closed subset or equal to
+ '\u2AD2': MO.REL, // closed superset or equal to
+ '\u2AD3': MO.REL, // subset above superset
+ '\u2AD4': MO.REL, // superset above subset
+ '\u2AD5': MO.REL, // subset above subset
+ '\u2AD6': MO.REL, // superset above superset
+ '\u2AD7': MO.REL, // superset beside subset
+ '\u2AD8': MO.REL, // superset beside and joined by dash with subset
+ '\u2AD9': MO.REL, // element of opening downwards
+ '\u2ADA': MO.REL, // pitchfork with tee top
+ '\u2ADB': MO.REL, // transversal intersection
+ '\u2ADC': MO.REL, // forking
+ '\u2ADD': MO.REL, // nonforking
+ '\u2ADE': MO.REL, // short left tack
+ '\u2ADF': MO.REL, // short down tack
+ '\u2AE0': MO.REL, // short up tack
+ '\u2AE1': MO.REL, // perpendicular with s
+ '\u2AE2': MO.REL, // vertical bar triple right turnstile
+ '\u2AE3': MO.REL, // double vertical bar left turnstile
+ '\u2AE4': MO.REL, // vertical bar double left turnstile
+ '\u2AE5': MO.REL, // double vertical bar double left turnstile
+ '\u2AE6': MO.REL, // long dash from left member of double vertical
+ '\u2AE7': MO.REL, // short down tack with overbar
+ '\u2AE8': MO.REL, // short up tack with underbar
+ '\u2AE9': MO.REL, // short up tack above short down tack
+ '\u2AEA': MO.REL, // double down tack
+ '\u2AEB': MO.REL, // double up tack
+ '\u2AEC': MO.REL, // double stroke not sign
+ '\u2AED': MO.REL, // reversed double stroke not sign
+ '\u2AEE': MO.REL, // does not divide with reversed negation slash
+ '\u2AEF': MO.REL, // vertical line with circle above
+ '\u2AF0': MO.REL, // vertical line with circle below
+ '\u2AF1': MO.REL, // down tack with circle below
+ '\u2AF2': MO.REL, // parallel with horizontal stroke
+ '\u2AF3': MO.REL, // parallel with tilde operator
+ '\u2AF4': MO.BIN4, // triple vertical bar binary relation
+ '\u2AF5': MO.BIN4, // triple vertical bar with horizontal stroke
+ '\u2AF6': MO.BIN4, // triple colon operator
+ '\u2AF7': MO.REL, // triple nested less-than
+ '\u2AF8': MO.REL, // triple nested greater-than
+ '\u2AF9': MO.REL, // double-line slanted less-than or equal to
+ '\u2AFA': MO.REL, // double-line slanted greater-than or equal to
+ '\u2AFB': MO.BIN4, // triple solidus binary relation
+ '\u2AFD': MO.BIN4, // double solidus operator
+ '\u2AFE': MO.BIN3 // white vertical bar
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SuppMathOperators.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/SupplementalArrowsA.js b/js/mathjax/jax/element/mml/optable/SupplementalArrowsA.js
new file mode 100644
index 0000000..081def5
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/SupplementalArrowsA.js
@@ -0,0 +1,42 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsA.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u27F0': MO.RELSTRETCH, // upwards quadruple arrow
+ '\u27F1': MO.RELSTRETCH, // downwards quadruple arrow
+ '\u27FB': MO.WIDEREL, // long leftwards arrow from bar
+ '\u27FD': MO.WIDEREL, // long leftwards double arrow from bar
+ '\u27FE': MO.WIDEREL, // long rightwards double arrow from bar
+ '\u27FF': MO.WIDEREL // long rightwards squiggle arrow
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsA.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/element/mml/optable/SupplementalArrowsB.js b/js/mathjax/jax/element/mml/optable/SupplementalArrowsB.js
new file mode 100644
index 0000000..2c6b99e
--- /dev/null
+++ b/js/mathjax/jax/element/mml/optable/SupplementalArrowsB.js
@@ -0,0 +1,164 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u2900': MO.RELACCENT, // rightwards two-headed arrow with vertical stroke
+ '\u2901': MO.RELACCENT, // rightwards two-headed arrow with double vertical stroke
+ '\u2902': MO.RELACCENT, // leftwards double arrow with vertical stroke
+ '\u2903': MO.RELACCENT, // rightwards double arrow with vertical stroke
+ '\u2904': MO.RELACCENT, // left right double arrow with vertical stroke
+ '\u2905': MO.RELACCENT, // rightwards two-headed arrow from bar
+ '\u2906': MO.RELACCENT, // leftwards double arrow from bar
+ '\u2907': MO.RELACCENT, // rightwards double arrow from bar
+ '\u2908': MO.REL, // downwards arrow with horizontal stroke
+ '\u2909': MO.REL, // upwards arrow with horizontal stroke
+ '\u290A': MO.RELSTRETCH, // upwards triple arrow
+ '\u290B': MO.RELSTRETCH, // downwards triple arrow
+ '\u290C': MO.WIDEREL, // leftwards double dash arrow
+ '\u290D': MO.WIDEREL, // rightwards double dash arrow
+ '\u290E': MO.WIDEREL, // leftwards triple dash arrow
+ '\u290F': MO.WIDEREL, // rightwards triple dash arrow
+ '\u2910': MO.WIDEREL, // rightwards two-headed triple dash arrow
+ '\u2911': MO.RELACCENT, // rightwards arrow with dotted stem
+ '\u2912': MO.RELSTRETCH, // upwards arrow to bar
+ '\u2913': MO.RELSTRETCH, // downwards arrow to bar
+ '\u2914': MO.RELACCENT, // rightwards arrow with tail with vertical stroke
+ '\u2915': MO.RELACCENT, // rightwards arrow with tail with double vertical stroke
+ '\u2916': MO.RELACCENT, // rightwards two-headed arrow with tail
+ '\u2917': MO.RELACCENT, // rightwards two-headed arrow with tail with vertical stroke
+ '\u2918': MO.RELACCENT, // rightwards two-headed arrow with tail with double vertical stroke
+ '\u2919': MO.RELACCENT, // leftwards arrow-tail
+ '\u291A': MO.RELACCENT, // rightwards arrow-tail
+ '\u291B': MO.RELACCENT, // leftwards double arrow-tail
+ '\u291C': MO.RELACCENT, // rightwards double arrow-tail
+ '\u291D': MO.RELACCENT, // leftwards arrow to black diamond
+ '\u291E': MO.RELACCENT, // rightwards arrow to black diamond
+ '\u291F': MO.RELACCENT, // leftwards arrow from bar to black diamond
+ '\u2920': MO.RELACCENT, // rightwards arrow from bar to black diamond
+ '\u2921': MO.RELSTRETCH, // north west and south east arrow
+ '\u2922': MO.RELSTRETCH, // north east and south west arrow
+ '\u2923': MO.REL, // north west arrow with hook
+ '\u2924': MO.REL, // north east arrow with hook
+ '\u2925': MO.REL, // south east arrow with hook
+ '\u2926': MO.REL, // south west arrow with hook
+ '\u2927': MO.REL, // north west arrow and north east arrow
+ '\u2928': MO.REL, // north east arrow and south east arrow
+ '\u2929': MO.REL, // south east arrow and south west arrow
+ '\u292A': MO.REL, // south west arrow and north west arrow
+ '\u292B': MO.REL, // rising diagonal crossing falling diagonal
+ '\u292C': MO.REL, // falling diagonal crossing rising diagonal
+ '\u292D': MO.REL, // south east arrow crossing north east arrow
+ '\u292E': MO.REL, // north east arrow crossing south east arrow
+ '\u292F': MO.REL, // falling diagonal crossing north east arrow
+ '\u2930': MO.REL, // rising diagonal crossing south east arrow
+ '\u2931': MO.REL, // north east arrow crossing north west arrow
+ '\u2932': MO.REL, // north west arrow crossing north east arrow
+ '\u2933': MO.RELACCENT, // wave arrow pointing directly right
+ '\u2934': MO.REL, // arrow pointing rightwards then curving upwards
+ '\u2935': MO.REL, // arrow pointing rightwards then curving downwards
+ '\u2936': MO.REL, // arrow pointing downwards then curving leftwards
+ '\u2937': MO.REL, // arrow pointing downwards then curving rightwards
+ '\u2938': MO.REL, // right-side arc clockwise arrow
+ '\u2939': MO.REL, // left-side arc anticlockwise arrow
+ '\u293A': MO.RELACCENT, // top arc anticlockwise arrow
+ '\u293B': MO.RELACCENT, // bottom arc anticlockwise arrow
+ '\u293C': MO.RELACCENT, // top arc clockwise arrow with minus
+ '\u293D': MO.RELACCENT, // top arc anticlockwise arrow with plus
+ '\u293E': MO.REL, // lower right semicircular clockwise arrow
+ '\u293F': MO.REL, // lower left semicircular anticlockwise arrow
+ '\u2940': MO.REL, // anticlockwise closed circle arrow
+ '\u2941': MO.REL, // clockwise closed circle arrow
+ '\u2942': MO.RELACCENT, // rightwards arrow above short leftwards arrow
+ '\u2943': MO.RELACCENT, // leftwards arrow above short rightwards arrow
+ '\u2944': MO.RELACCENT, // short rightwards arrow above leftwards arrow
+ '\u2945': MO.RELACCENT, // rightwards arrow with plus below
+ '\u2946': MO.RELACCENT, // leftwards arrow with plus below
+ '\u2947': MO.RELACCENT, // rightwards arrow through x
+ '\u2948': MO.RELACCENT, // left right arrow through small circle
+ '\u2949': MO.REL, // upwards two-headed arrow from small circle
+ '\u294A': MO.RELACCENT, // left barb up right barb down harpoon
+ '\u294B': MO.RELACCENT, // left barb down right barb up harpoon
+ '\u294C': MO.REL, // up barb right down barb left harpoon
+ '\u294D': MO.REL, // up barb left down barb right harpoon
+ '\u294E': MO.WIDEREL, // left barb up right barb up harpoon
+ '\u294F': MO.RELSTRETCH, // up barb right down barb right harpoon
+ '\u2950': MO.WIDEREL, // left barb down right barb down harpoon
+ '\u2951': MO.RELSTRETCH, // up barb left down barb left harpoon
+ '\u2952': MO.WIDEREL, // leftwards harpoon with barb up to bar
+ '\u2953': MO.WIDEREL, // rightwards harpoon with barb up to bar
+ '\u2954': MO.RELSTRETCH, // upwards harpoon with barb right to bar
+ '\u2955': MO.RELSTRETCH, // downwards harpoon with barb right to bar
+ '\u2956': MO.RELSTRETCH, // leftwards harpoon with barb down to bar
+ '\u2957': MO.RELSTRETCH, // rightwards harpoon with barb down to bar
+ '\u2958': MO.RELSTRETCH, // upwards harpoon with barb left to bar
+ '\u2959': MO.RELSTRETCH, // downwards harpoon with barb left to bar
+ '\u295A': MO.WIDEREL, // leftwards harpoon with barb up from bar
+ '\u295B': MO.WIDEREL, // rightwards harpoon with barb up from bar
+ '\u295C': MO.RELSTRETCH, // upwards harpoon with barb right from bar
+ '\u295D': MO.RELSTRETCH, // downwards harpoon with barb right from bar
+ '\u295E': MO.WIDEREL, // leftwards harpoon with barb down from bar
+ '\u295F': MO.WIDEREL, // rightwards harpoon with barb down from bar
+ '\u2960': MO.RELSTRETCH, // upwards harpoon with barb left from bar
+ '\u2961': MO.RELSTRETCH, // downwards harpoon with barb left from bar
+ '\u2962': MO.RELACCENT, // leftwards harpoon with barb up above leftwards harpoon with barb down
+ '\u2963': MO.REL, // upwards harpoon with barb left beside upwards harpoon with barb right
+ '\u2964': MO.RELACCENT, // rightwards harpoon with barb up above rightwards harpoon with barb down
+ '\u2965': MO.REL, // downwards harpoon with barb left beside downwards harpoon with barb right
+ '\u2966': MO.RELACCENT, // leftwards harpoon with barb up above rightwards harpoon with barb up
+ '\u2967': MO.RELACCENT, // leftwards harpoon with barb down above rightwards harpoon with barb down
+ '\u2968': MO.RELACCENT, // rightwards harpoon with barb up above leftwards harpoon with barb up
+ '\u2969': MO.RELACCENT, // rightwards harpoon with barb down above leftwards harpoon with barb down
+ '\u296A': MO.RELACCENT, // leftwards harpoon with barb up above long dash
+ '\u296B': MO.RELACCENT, // leftwards harpoon with barb down below long dash
+ '\u296C': MO.RELACCENT, // rightwards harpoon with barb up above long dash
+ '\u296D': MO.RELACCENT, // rightwards harpoon with barb down below long dash
+ '\u296E': MO.RELSTRETCH, // upwards harpoon with barb left beside downwards harpoon with barb right
+ '\u296F': MO.RELSTRETCH, // downwards harpoon with barb left beside upwards harpoon with barb right
+ '\u2970': MO.RELACCENT, // right double arrow with rounded head
+ '\u2971': MO.RELACCENT, // equals sign above rightwards arrow
+ '\u2972': MO.RELACCENT, // tilde operator above rightwards arrow
+ '\u2973': MO.RELACCENT, // leftwards arrow above tilde operator
+ '\u2974': MO.RELACCENT, // rightwards arrow above tilde operator
+ '\u2975': MO.RELACCENT, // rightwards arrow above almost equal to
+ '\u2976': MO.RELACCENT, // less-than above leftwards arrow
+ '\u2977': MO.RELACCENT, // leftwards arrow through less-than
+ '\u2978': MO.RELACCENT, // greater-than above rightwards arrow
+ '\u2979': MO.RELACCENT, // subset above rightwards arrow
+ '\u297A': MO.RELACCENT, // leftwards arrow through subset
+ '\u297B': MO.RELACCENT, // superset above leftwards arrow
+ '\u297C': MO.RELACCENT, // left fish tail
+ '\u297D': MO.RELACCENT, // right fish tail
+ '\u297E': MO.REL, // up fish tail
+ '\u297F': MO.REL // down fish tail
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsB.js");
+
+})(MathJax.ElementJax.mml);
+// @license-end
diff --git a/js/mathjax/jax/input/AsciiMath/config.js b/js/mathjax/jax/input/AsciiMath/config.js
new file mode 100644
index 0000000..97f5369
--- /dev/null
+++ b/js/mathjax/jax/input/AsciiMath/config.js
@@ -0,0 +1,48 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/input/AsciiMath/config.js
+ *
+ * Initializes the AsciiMath InputJax (the main definition is in
+ * MathJax/jax/input/AsciiMath/jax.js, which is loaded when needed).
+ *
+ * Originally adapted for MathJax by David Lippman.
+ * Additional work done by Davide P. Cervone.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2012-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.InputJax.AsciiMath = MathJax.InputJax({
+ id: "AsciiMath",
+ version: "2.7.9",
+ directory: MathJax.InputJax.directory + "/AsciiMath",
+ extensionDir: MathJax.InputJax.extensionDir + "/AsciiMath",
+
+ config: {
+ fixphi: true, // switch phi and varphi unicode values
+ useMathMLspacing: true, // use MathML spacing rather than TeX spacing?
+ displaystyle: true, // put limits above and below operators
+ decimalsign: "." // can change to "," but watch out for "(1,2)"
+ }
+});
+MathJax.InputJax.AsciiMath.Register("math/asciimath");
+
+MathJax.InputJax.AsciiMath.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/input/AsciiMath/jax.js b/js/mathjax/jax/input/AsciiMath/jax.js
new file mode 100644
index 0000000..bad0cd8
--- /dev/null
+++ b/js/mathjax/jax/input/AsciiMath/jax.js
@@ -0,0 +1,1543 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/input/AsciiMath/jax.js
+ *
+ * An Input Jax for AsciiMath notation
+ * (see http://www1.chapman.edu/~jipsen/mathml/asciimath.html).
+ *
+ * Originally adapted for MathJax by David Lippman.
+ * Additional work done by Davide P. Cervone.
+ *
+ * The current development repository for AsciiMathML is
+ * https://github.com/mathjax/asciimathml
+ *
+ * A portion of this file is taken from
+ * ASCIIMathML.js Version 2.2 Mar 3, 2014, (c) Peter Jipsen http://www.chapman.edu/~jipsen
+ * and is used by permission of Peter Jipsen, who has agreed to allow us to
+ * release it under the Apache2 license (see below). That portion is indicated
+ * via comments.
+ *
+ * The remainder falls under the copyright that follows.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2012-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function (ASCIIMATH) {
+
+ var MML; // Filled in later
+
+ //
+ // Make a documentFragment work-alike that uses MML objects
+ // rather than DOM objects.
+ //
+ var DOCFRAG = MathJax.Object.Subclass({
+ firstChild: null,
+ lastChild: null,
+ Init: function () {
+ this.childNodes = [];
+ },
+ appendChild: function (node) {
+ if (node.parent) {node.parent.removeChild(node)}
+ if (this.lastChild) {this.lastChild.nextSibling = node}
+ if (!this.firstChild) {this.firstChild = node}
+ this.childNodes.push(node); node.parent = this;
+ this.lastChild = node;
+ return node;
+ },
+ removeChild: function (node) {
+ for (var i = 0, m = this.childNodes.length; i < m; i++)
+ {if (this.childNodes[i] === node) break}
+ if (i === m) return;
+ this.childNodes.splice(i,1);
+ if (node === this.firstChild) {this.firstChild = node.nextSibling}
+ if (node === this.lastChild) {
+ if (!this.childNodes.length) {this.lastChild = null}
+ else {this.lastChild = this.childNodes[this.childNodes.length-1]}
+ }
+ if (i) {this.childNodes[i-1].nextSibling = node.nextSibling}
+ node.nextSibling = node.parent = null;
+ return node;
+ },
+ replaceChild: function (node,old) {
+ for (var i = 0, m = this.childNodes.length; i < m; i++)
+ {if (this.childNodes[i] === old) break}
+ if (i) {this.childNodes[i-1].nextSibling = node} else {this.firstChild = node}
+ if (i >= m-1) {this.lastChild = node}
+ this.childNodes[i] = node; node.nextSibling = old.nextSibling;
+ old.nextSibling = old.parent = null;
+ return old;
+ },
+ hasChildNodes: function (node) {
+ return (this.childNodes.length>0);
+ },
+ toString: function () {return "{"+this.childNodes.join("")+"}"}
+ });
+
+ var INITASCIIMATH = function () {
+ MML = MathJax.ElementJax.mml;
+ var MBASEINIT = MML.mbase.prototype.Init;
+
+ //
+ // Make MML elements looks like DOM elements (add the
+ // methods that AsciiMath needs)
+ //
+ MML.mbase.Augment({
+ firstChild: null,
+ lastChild: null,
+ nodeValue: null,
+ nextSibling: null,
+ Init: function () {
+ var obj = MBASEINIT.apply(this,arguments) || this;
+ obj.childNodes = obj.data;
+ obj.nodeName = obj.type;
+ return obj;
+ },
+ appendChild: function (node) {
+ if (node.parent) {node.parent.removeChild(node)}
+ var nodes = arguments;
+ if (node.isa(DOCFRAG)) {
+ nodes = node.childNodes;
+ node.data = node.childNodes = [];
+ node.firstChild = node.lastChild = null;
+ }
+ for (var i = 0, m = nodes.length; i < m; i++) {
+ node = nodes[i];
+ if (this.lastChild) {this.lastChild.nextSibling = node}
+ if (!this.firstChild) {this.firstChild = node}
+ this.Append(node);
+ this.lastChild = node;
+ }
+ return node;
+ },
+ removeChild: function (node) {
+ for (var i = 0, m = this.childNodes.length; i < m; i++)
+ {if (this.childNodes[i] === node) break}
+ if (i === m) return;
+ this.childNodes.splice(i,1);
+ if (node === this.firstChild) {this.firstChild = node.nextSibling}
+ if (node === this.lastChild) {
+ if (!this.childNodes.length) {this.lastChild = null}
+ else {this.lastChild = this.childNodes[this.childNodes.length-1]}
+ }
+ if (i) {this.childNodes[i-1].nextSibling = node.nextSibling}
+ node.nextSibling = node.parent = null;
+ return node;
+ },
+ replaceChild: function (node,old) {
+ for (var i = 0, m = this.childNodes.length; i < m; i++)
+ {if (this.childNodes[i] === old) break}
+ // FIXME: make this work with DOCFRAG's?
+ if (i) {this.childNodes[i-1].nextSibling = node} else {this.firstChild = node}
+ if (i >= m-1) {this.lastChild = node}
+ this.SetData(i,node); node.nextSibling = old.nextSibling;
+ old.nextSibling = old.parent = null;
+ return old;
+ },
+ hasChildNodes: function (node) {
+ return (this.childNodes.length>0);
+ },
+ setAttribute: function (name,value) {this[name] = value}
+ });
+ };
+
+ //
+ // Set up to isolate ASCIIMathML.js
+ //
+
+ var window = {}; // hide the true window
+
+ //
+ // Hide the true document, and add functions that
+ // use and produce MML objects instead of DOM objects
+ //
+ var document = {
+ getElementById: true,
+ createElementNS: function (ns,type) {
+ var node = MML[type]();
+ if (type === "mo" && ASCIIMATH.config.useMathMLspacing) {node.useMMLspacing = 0x80}
+ return node;
+ },
+ createTextNode: function (text) {return MML.chars(text).With({nodeValue:text})},
+ createDocumentFragment: function () {return DOCFRAG()}
+ };
+
+ var navigator = {appName: "MathJax"}; // hide the true navigator object
+
+/******************************************************************
+ *
+ * The following section is ASCIIMathML.js Version 2.2
+ * (c) Peter Jipsen, used with permission.
+ *
+ * Some sections are commented out to save space in the
+ * minified version (but that is not strictly necessary).
+ *
+ ******************************************************************/
+
+/*
+ASCIIMathML.js
+==============
+This file contains JavaScript functions to convert ASCII math notation
+and (some) LaTeX to Presentation MathML. The conversion is done while the
+HTML page loads, and should work with Firefox and other browsers that can
+render MathML.
+
+Just add the next line to your HTML page with this file in the same folder:
+
+<script type="text/javascript" src="ASCIIMathML.js"></script>
+
+Version 2.2 Mar 3, 2014.
+Latest version at https://github.com/mathjax/asciimathml
+If you use it on a webpage, please send the URL to jipsen@chapman.edu
+
+Copyright (c) 2014 Peter Jipsen and other ASCIIMathML.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+//var asciimath = {};
+
+//(function(){
+var mathcolor = "blue"; // change it to "" (to inherit) or another color
+//var mathfontsize = "1em"; // change to e.g. 1.2em for larger math
+//var mathfontfamily = "serif"; // change to "" to inherit (works in IE)
+ // or another family (e.g. "arial")
+//var automathrecognize = false; // writing "amath" on page makes this true
+//var checkForMathML = true; // check if browser can display MathML
+//var notifyIfNoMathML = true; // display note at top if no MathML capability
+//var alertIfNoMathML = false; // show alert box if no MathML capability
+//var translateOnLoad = true; // set to false to do call translators from js
+//var translateASCIIMath = true; // false to preserve `..`
+var displaystyle = true; // puts limits above and below large operators
+var showasciiformulaonhover = true; // helps students learn ASCIIMath
+var decimalsign = "."; // change to "," if you like, beware of `(1,2)`!
+//var AMdelimiter1 = "`", AMescape1 = "\\\\`"; // can use other characters
+//var AMdocumentId = "wikitext" // PmWiki element containing math (default=body)
+var fixphi = true; //false to return to legacy phi/varphi mapping
+
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+var isIE = (navigator.appName.slice(0,9)=="Microsoft");
+/*
+var noMathML = false, translated = false;
+
+if (isIE) { // add MathPlayer info to IE webpages
+ document.write("<object id=\"mathplayer\"\
+ classid=\"clsid:32F66A20-7614-11D4-BD11-00104BD3F987\"></object>");
+ document.write("<?import namespace=\"m\" implementation=\"#mathplayer\"?>");
+}
+
+// Add a stylesheet, replacing any previous custom stylesheet (adapted from TW)
+function setStylesheet(s) {
+ var id = "AMMLcustomStyleSheet";
+ var n = document.getElementById(id);
+ if(document.createStyleSheet) {
+ // Test for IE's non-standard createStyleSheet method
+ if(n)
+ n.parentNode.removeChild(n);
+ // This failed without the &nbsp;
+ document.getElementsByTagName("head")[0].insertAdjacentHTML("beforeEnd","&nbsp;<style id='" + id + "'>" + s + "</style>");
+ } else {
+ if(n) {
+ n.replaceChild(document.createTextNode(s),n.firstChild);
+ } else {
+ n = document.createElement("style");
+ n.type = "text/css";
+ n.id = id;
+ n.appendChild(document.createTextNode(s));
+ document.getElementsByTagName("head")[0].appendChild(n);
+ }
+ }
+}
+
+setStylesheet("#AMMLcloseDiv \{font-size:0.8em; padding-top:1em; color:#014\}\n#AMMLwarningBox \{position:absolute; width:100%; top:0; left:0; z-index:200; text-align:center; font-size:1em; font-weight:bold; padding:0.5em 0 0.5em 0; color:#ffc; background:#c30\}");
+
+function init(){
+ var msg, warnings = new Array();
+ if (document.getElementById==null){
+ alert("This webpage requires a recent browser such as Mozilla Firefox");
+ return null;
+ }
+ if (checkForMathML && (msg = checkMathML())) warnings.push(msg);
+ if (warnings.length>0) displayWarnings(warnings);
+ if (!noMathML) initSymbols();
+ return true;
+}
+
+function checkMathML(){
+ if (navigator.appName.slice(0,8)=="Netscape")
+ if (navigator.appVersion.slice(0,1)>="5") noMathML = null;
+ else noMathML = true;
+ else if (navigator.appName.slice(0,9)=="Microsoft")
+ try {
+ var ActiveX = new ActiveXObject("MathPlayer.Factory.1");
+ noMathML = null;
+ } catch (e) {
+ noMathML = true;
+ }
+ else if (navigator.appName.slice(0,5)=="Opera")
+ if (navigator.appVersion.slice(0,3)>="9.5") noMathML = null;
+ else noMathML = true;
+//noMathML = true; //uncomment to check
+ if (noMathML && notifyIfNoMathML) {
+ var msg = "To view the ASCIIMathML notation use Internet Explorer + MathPlayer or Mozilla Firefox 2.0 or later.";
+ if (alertIfNoMathML)
+ alert(msg);
+ else return msg;
+ }
+}
+
+function hideWarning(){
+ var body = document.getElementsByTagName("body")[0];
+ body.removeChild(document.getElementById('AMMLwarningBox'));
+ body.onclick = null;
+}
+
+function displayWarnings(warnings) {
+ var i, frag, nd = createElementXHTML("div");
+ var body = document.getElementsByTagName("body")[0];
+ body.onclick=hideWarning;
+ nd.id = 'AMMLwarningBox';
+ for (i=0; i<warnings.length; i++) {
+ frag = createElementXHTML("div");
+ frag.appendChild(document.createTextNode(warnings[i]));
+ frag.style.paddingBottom = "1.0em";
+ nd.appendChild(frag);
+ }
+ nd.appendChild(createElementXHTML("p"));
+ nd.appendChild(document.createTextNode("For instructions see the "));
+ var an = createElementXHTML("a");
+ an.appendChild(document.createTextNode("ASCIIMathML"));
+ an.setAttribute("href","http://www.chapman.edu/~jipsen/asciimath.html");
+ nd.appendChild(an);
+ nd.appendChild(document.createTextNode(" homepage"));
+ an = createElementXHTML("div");
+ an.id = 'AMMLcloseDiv';
+ an.appendChild(document.createTextNode('(click anywhere to close this warning)'));
+ nd.appendChild(an);
+ var body = document.getElementsByTagName("body")[0];
+ body.insertBefore(nd,body.childNodes[0]);
+}
+
+function translate(spanclassAM) {
+ if (!translated) { // run this only once
+ translated = true;
+ var body = document.getElementsByTagName("body")[0];
+ var processN = document.getElementById(AMdocumentId);
+ if (translateASCIIMath) AMprocessNode((processN!=null?processN:body), false, spanclassAM);
+ }
+}
+*/
+function createElementXHTML(t) {
+ if (isIE) return document.createElement(t);
+ else return document.createElementNS("http://www.w3.org/1999/xhtml",t);
+}
+
+var AMmathml = "http://www.w3.org/1998/Math/MathML";
+
+function AMcreateElementMathML(t) {
+ if (isIE) return document.createElement("m:"+t);
+ else return document.createElementNS(AMmathml,t);
+}
+
+function createMmlNode(t,frag) {
+ var node;
+ if (isIE) node = document.createElement("m:"+t);
+ else node = document.createElementNS(AMmathml,t);
+ if (frag) node.appendChild(frag);
+ return node;
+}
+
+function newcommand(oldstr,newstr) {
+ AMsymbols.push({input:oldstr, tag:"mo", output:newstr, tex:null, ttype:DEFINITION});
+ refreshSymbols();
+}
+
+function newsymbol(symbolobj) {
+ AMsymbols.push(symbolobj);
+ refreshSymbols();
+}
+
+// character lists for Mozilla/Netscape fonts
+var AMcal = ["\uD835\uDC9C","\u212C","\uD835\uDC9E","\uD835\uDC9F","\u2130","\u2131","\uD835\uDCA2","\u210B","\u2110","\uD835\uDCA5","\uD835\uDCA6","\u2112","\u2133","\uD835\uDCA9","\uD835\uDCAA","\uD835\uDCAB","\uD835\uDCAC","\u211B","\uD835\uDCAE","\uD835\uDCAF","\uD835\uDCB0","\uD835\uDCB1","\uD835\uDCB2","\uD835\uDCB3","\uD835\uDCB4","\uD835\uDCB5","\uD835\uDCB6","\uD835\uDCB7","\uD835\uDCB8","\uD835\uDCB9","\u212F","\uD835\uDCBB","\u210A","\uD835\uDCBD","\uD835\uDCBE","\uD835\uDCBF","\uD835\uDCC0","\uD835\uDCC1","\uD835\uDCC2","\uD835\uDCC3","\u2134","\uD835\uDCC5","\uD835\uDCC6","\uD835\uDCC7","\uD835\uDCC8","\uD835\uDCC9","\uD835\uDCCA","\uD835\uDCCB","\uD835\uDCCC","\uD835\uDCCD","\uD835\uDCCE","\uD835\uDCCF"];
+
+var AMfrk = ["\uD835\uDD04","\uD835\uDD05","\u212D","\uD835\uDD07","\uD835\uDD08","\uD835\uDD09","\uD835\uDD0A","\u210C","\u2111","\uD835\uDD0D","\uD835\uDD0E","\uD835\uDD0F","\uD835\uDD10","\uD835\uDD11","\uD835\uDD12","\uD835\uDD13","\uD835\uDD14","\u211C","\uD835\uDD16","\uD835\uDD17","\uD835\uDD18","\uD835\uDD19","\uD835\uDD1A","\uD835\uDD1B","\uD835\uDD1C","\u2128","\uD835\uDD1E","\uD835\uDD1F","\uD835\uDD20","\uD835\uDD21","\uD835\uDD22","\uD835\uDD23","\uD835\uDD24","\uD835\uDD25","\uD835\uDD26","\uD835\uDD27","\uD835\uDD28","\uD835\uDD29","\uD835\uDD2A","\uD835\uDD2B","\uD835\uDD2C","\uD835\uDD2D","\uD835\uDD2E","\uD835\uDD2F","\uD835\uDD30","\uD835\uDD31","\uD835\uDD32","\uD835\uDD33","\uD835\uDD34","\uD835\uDD35","\uD835\uDD36","\uD835\uDD37"];
+
+var AMbbb = ["\uD835\uDD38","\uD835\uDD39","\u2102","\uD835\uDD3B","\uD835\uDD3C","\uD835\uDD3D","\uD835\uDD3E","\u210D","\uD835\uDD40","\uD835\uDD41","\uD835\uDD42","\uD835\uDD43","\uD835\uDD44","\u2115","\uD835\uDD46","\u2119","\u211A","\u211D","\uD835\uDD4A","\uD835\uDD4B","\uD835\uDD4C","\uD835\uDD4D","\uD835\uDD4E","\uD835\uDD4F","\uD835\uDD50","\u2124","\uD835\uDD52","\uD835\uDD53","\uD835\uDD54","\uD835\uDD55","\uD835\uDD56","\uD835\uDD57","\uD835\uDD58","\uD835\uDD59","\uD835\uDD5A","\uD835\uDD5B","\uD835\uDD5C","\uD835\uDD5D","\uD835\uDD5E","\uD835\uDD5F","\uD835\uDD60","\uD835\uDD61","\uD835\uDD62","\uD835\uDD63","\uD835\uDD64","\uD835\uDD65","\uD835\uDD66","\uD835\uDD67","\uD835\uDD68","\uD835\uDD69","\uD835\uDD6A","\uD835\uDD6B"];
+/*var AMcal = [0xEF35,0x212C,0xEF36,0xEF37,0x2130,0x2131,0xEF38,0x210B,0x2110,0xEF39,0xEF3A,0x2112,0x2133,0xEF3B,0xEF3C,0xEF3D,0xEF3E,0x211B,0xEF3F,0xEF40,0xEF41,0xEF42,0xEF43,0xEF44,0xEF45,0xEF46];
+var AMfrk = [0xEF5D,0xEF5E,0x212D,0xEF5F,0xEF60,0xEF61,0xEF62,0x210C,0x2111,0xEF63,0xEF64,0xEF65,0xEF66,0xEF67,0xEF68,0xEF69,0xEF6A,0x211C,0xEF6B,0xEF6C,0xEF6D,0xEF6E,0xEF6F,0xEF70,0xEF71,0x2128];
+var AMbbb = [0xEF8C,0xEF8D,0x2102,0xEF8E,0xEF8F,0xEF90,0xEF91,0x210D,0xEF92,0xEF93,0xEF94,0xEF95,0xEF96,0x2115,0xEF97,0x2119,0x211A,0x211D,0xEF98,0xEF99,0xEF9A,0xEF9B,0xEF9C,0xEF9D,0xEF9E,0x2124];*/
+
+var CONST = 0, UNARY = 1, BINARY = 2, INFIX = 3, LEFTBRACKET = 4,
+ RIGHTBRACKET = 5, SPACE = 6, UNDEROVER = 7, DEFINITION = 8,
+ LEFTRIGHT = 9, TEXT = 10, /*BIG = 11, LONG = 12, STRETCHY = 13,
+ MATRIX = 14,*/ UNARYUNDEROVER = 15; // token types
+
+var AMquote = {input:"\"", tag:"mtext", output:"mbox", tex:null, ttype:TEXT};
+
+var AMsymbols = [
+//some greek symbols
+{input:"alpha", tag:"mi", output:"\u03B1", tex:null, ttype:CONST},
+{input:"beta", tag:"mi", output:"\u03B2", tex:null, ttype:CONST},
+{input:"chi", tag:"mi", output:"\u03C7", tex:null, ttype:CONST},
+{input:"delta", tag:"mi", output:"\u03B4", tex:null, ttype:CONST},
+{input:"Delta", tag:"mo", output:"\u0394", tex:null, ttype:CONST},
+{input:"epsi", tag:"mi", output:"\u03B5", tex:"epsilon", ttype:CONST},
+{input:"varepsilon", tag:"mi", output:"\u025B", tex:null, ttype:CONST},
+{input:"eta", tag:"mi", output:"\u03B7", tex:null, ttype:CONST},
+{input:"gamma", tag:"mi", output:"\u03B3", tex:null, ttype:CONST},
+{input:"Gamma", tag:"mo", output:"\u0393", tex:null, ttype:CONST},
+{input:"iota", tag:"mi", output:"\u03B9", tex:null, ttype:CONST},
+{input:"kappa", tag:"mi", output:"\u03BA", tex:null, ttype:CONST},
+{input:"lambda", tag:"mi", output:"\u03BB", tex:null, ttype:CONST},
+{input:"Lambda", tag:"mo", output:"\u039B", tex:null, ttype:CONST},
+{input:"lamda", tag:"mi", output:"\u03BB", tex:null, ttype:CONST},
+{input:"Lamda", tag:"mo", output:"\u039B", tex:null, ttype:CONST},
+{input:"mu", tag:"mi", output:"\u03BC", tex:null, ttype:CONST},
+{input:"nu", tag:"mi", output:"\u03BD", tex:null, ttype:CONST},
+{input:"omega", tag:"mi", output:"\u03C9", tex:null, ttype:CONST},
+{input:"Omega", tag:"mo", output:"\u03A9", tex:null, ttype:CONST},
+{input:"phi", tag:"mi", output:fixphi?"\u03D5":"\u03C6", tex:null, ttype:CONST},
+{input:"varphi", tag:"mi", output:fixphi?"\u03C6":"\u03D5", tex:null, ttype:CONST},
+{input:"Phi", tag:"mo", output:"\u03A6", tex:null, ttype:CONST},
+{input:"pi", tag:"mi", output:"\u03C0", tex:null, ttype:CONST},
+{input:"Pi", tag:"mo", output:"\u03A0", tex:null, ttype:CONST},
+{input:"psi", tag:"mi", output:"\u03C8", tex:null, ttype:CONST},
+{input:"Psi", tag:"mi", output:"\u03A8", tex:null, ttype:CONST},
+{input:"rho", tag:"mi", output:"\u03C1", tex:null, ttype:CONST},
+{input:"sigma", tag:"mi", output:"\u03C3", tex:null, ttype:CONST},
+{input:"Sigma", tag:"mo", output:"\u03A3", tex:null, ttype:CONST},
+{input:"tau", tag:"mi", output:"\u03C4", tex:null, ttype:CONST},
+{input:"theta", tag:"mi", output:"\u03B8", tex:null, ttype:CONST},
+{input:"vartheta", tag:"mi", output:"\u03D1", tex:null, ttype:CONST},
+{input:"Theta", tag:"mo", output:"\u0398", tex:null, ttype:CONST},
+{input:"upsilon", tag:"mi", output:"\u03C5", tex:null, ttype:CONST},
+{input:"xi", tag:"mi", output:"\u03BE", tex:null, ttype:CONST},
+{input:"Xi", tag:"mo", output:"\u039E", tex:null, ttype:CONST},
+{input:"zeta", tag:"mi", output:"\u03B6", tex:null, ttype:CONST},
+
+//binary operation symbols
+//{input:"-", tag:"mo", output:"\u0096", tex:null, ttype:CONST},
+{input:"*", tag:"mo", output:"\u22C5", tex:"cdot", ttype:CONST},
+{input:"**", tag:"mo", output:"\u2217", tex:"ast", ttype:CONST},
+{input:"***", tag:"mo", output:"\u22C6", tex:"star", ttype:CONST},
+{input:"//", tag:"mo", output:"/", tex:null, ttype:CONST},
+{input:"\\\\", tag:"mo", output:"\\", tex:"backslash", ttype:CONST},
+{input:"setminus", tag:"mo", output:"\\", tex:null, ttype:CONST},
+{input:"xx", tag:"mo", output:"\u00D7", tex:"times", ttype:CONST},
+{input:"|><", tag:"mo", output:"\u22C9", tex:"ltimes", ttype:CONST},
+{input:"><|", tag:"mo", output:"\u22CA", tex:"rtimes", ttype:CONST},
+{input:"|><|", tag:"mo", output:"\u22C8", tex:"bowtie", ttype:CONST},
+{input:"-:", tag:"mo", output:"\u00F7", tex:"div", ttype:CONST},
+{input:"divide", tag:"mo", output:"-:", tex:null, ttype:DEFINITION},
+{input:"@", tag:"mo", output:"\u2218", tex:"circ", ttype:CONST},
+{input:"o+", tag:"mo", output:"\u2295", tex:"oplus", ttype:CONST},
+{input:"ox", tag:"mo", output:"\u2297", tex:"otimes", ttype:CONST},
+{input:"o.", tag:"mo", output:"\u2299", tex:"odot", ttype:CONST},
+{input:"sum", tag:"mo", output:"\u2211", tex:null, ttype:UNDEROVER},
+{input:"prod", tag:"mo", output:"\u220F", tex:null, ttype:UNDEROVER},
+{input:"^^", tag:"mo", output:"\u2227", tex:"wedge", ttype:CONST},
+{input:"^^^", tag:"mo", output:"\u22C0", tex:"bigwedge", ttype:UNDEROVER},
+{input:"vv", tag:"mo", output:"\u2228", tex:"vee", ttype:CONST},
+{input:"vvv", tag:"mo", output:"\u22C1", tex:"bigvee", ttype:UNDEROVER},
+{input:"nn", tag:"mo", output:"\u2229", tex:"cap", ttype:CONST},
+{input:"nnn", tag:"mo", output:"\u22C2", tex:"bigcap", ttype:UNDEROVER},
+{input:"uu", tag:"mo", output:"\u222A", tex:"cup", ttype:CONST},
+{input:"uuu", tag:"mo", output:"\u22C3", tex:"bigcup", ttype:UNDEROVER},
+
+//binary relation symbols
+{input:"!=", tag:"mo", output:"\u2260", tex:"ne", ttype:CONST},
+{input:":=", tag:"mo", output:":=", tex:null, ttype:CONST},
+{input:"lt", tag:"mo", output:"<", tex:null, ttype:CONST},
+{input:"<=", tag:"mo", output:"\u2264", tex:"le", ttype:CONST},
+{input:"lt=", tag:"mo", output:"\u2264", tex:"leq", ttype:CONST},
+{input:"gt", tag:"mo", output:">", tex:null, ttype:CONST},
+{input:">=", tag:"mo", output:"\u2265", tex:"ge", ttype:CONST},
+{input:"gt=", tag:"mo", output:"\u2265", tex:"geq", ttype:CONST},
+{input:"-<", tag:"mo", output:"\u227A", tex:"prec", ttype:CONST},
+{input:"-lt", tag:"mo", output:"\u227A", tex:null, ttype:CONST},
+{input:">-", tag:"mo", output:"\u227B", tex:"succ", ttype:CONST},
+{input:"-<=", tag:"mo", output:"\u2AAF", tex:"preceq", ttype:CONST},
+{input:">-=", tag:"mo", output:"\u2AB0", tex:"succeq", ttype:CONST},
+{input:"in", tag:"mo", output:"\u2208", tex:null, ttype:CONST},
+{input:"!in", tag:"mo", output:"\u2209", tex:"notin", ttype:CONST},
+{input:"sub", tag:"mo", output:"\u2282", tex:"subset", ttype:CONST},
+{input:"sup", tag:"mo", output:"\u2283", tex:"supset", ttype:CONST},
+{input:"sube", tag:"mo", output:"\u2286", tex:"subseteq", ttype:CONST},
+{input:"supe", tag:"mo", output:"\u2287", tex:"supseteq", ttype:CONST},
+{input:"-=", tag:"mo", output:"\u2261", tex:"equiv", ttype:CONST},
+{input:"~=", tag:"mo", output:"\u2245", tex:"cong", ttype:CONST},
+{input:"~~", tag:"mo", output:"\u2248", tex:"approx", ttype:CONST},
+{input:"prop", tag:"mo", output:"\u221D", tex:"propto", ttype:CONST},
+
+//logical symbols
+{input:"and", tag:"mtext", output:"and", tex:null, ttype:SPACE},
+{input:"or", tag:"mtext", output:"or", tex:null, ttype:SPACE},
+{input:"not", tag:"mo", output:"\u00AC", tex:"neg", ttype:CONST},
+{input:"=>", tag:"mo", output:"\u21D2", tex:"implies", ttype:CONST},
+{input:"if", tag:"mo", output:"if", tex:null, ttype:SPACE},
+{input:"<=>", tag:"mo", output:"\u21D4", tex:"iff", ttype:CONST},
+{input:"AA", tag:"mo", output:"\u2200", tex:"forall", ttype:CONST},
+{input:"EE", tag:"mo", output:"\u2203", tex:"exists", ttype:CONST},
+{input:"_|_", tag:"mo", output:"\u22A5", tex:"bot", ttype:CONST},
+{input:"TT", tag:"mo", output:"\u22A4", tex:"top", ttype:CONST},
+{input:"|--", tag:"mo", output:"\u22A2", tex:"vdash", ttype:CONST},
+{input:"|==", tag:"mo", output:"\u22A8", tex:"models", ttype:CONST},
+
+//grouping brackets
+{input:"(", tag:"mo", output:"(", tex:"left(", ttype:LEFTBRACKET},
+{input:")", tag:"mo", output:")", tex:"right)", ttype:RIGHTBRACKET},
+{input:"[", tag:"mo", output:"[", tex:"left[", ttype:LEFTBRACKET},
+{input:"]", tag:"mo", output:"]", tex:"right]", ttype:RIGHTBRACKET},
+{input:"{", tag:"mo", output:"{", tex:null, ttype:LEFTBRACKET},
+{input:"}", tag:"mo", output:"}", tex:null, ttype:RIGHTBRACKET},
+{input:"|", tag:"mo", output:"|", tex:null, ttype:LEFTRIGHT},
+{input:":|:", tag:"mo", output:"|", tex:null, ttype:CONST},
+{input:"|:", tag:"mo", output:"|", tex:null, ttype:LEFTBRACKET},
+{input:":|", tag:"mo", output:"|", tex:null, ttype:RIGHTBRACKET},
+//{input:"||", tag:"mo", output:"||", tex:null, ttype:LEFTRIGHT},
+{input:"(:", tag:"mo", output:"\u2329", tex:"langle", ttype:LEFTBRACKET},
+{input:":)", tag:"mo", output:"\u232A", tex:"rangle", ttype:RIGHTBRACKET},
+{input:"<<", tag:"mo", output:"\u2329", tex:null, ttype:LEFTBRACKET},
+{input:">>", tag:"mo", output:"\u232A", tex:null, ttype:RIGHTBRACKET},
+{input:"{:", tag:"mo", output:"{:", tex:null, ttype:LEFTBRACKET, invisible:true},
+{input:":}", tag:"mo", output:":}", tex:null, ttype:RIGHTBRACKET, invisible:true},
+
+//miscellaneous symbols
+{input:"int", tag:"mo", output:"\u222B", tex:null, ttype:CONST},
+{input:"dx", tag:"mi", output:"{:d x:}", tex:null, ttype:DEFINITION},
+{input:"dy", tag:"mi", output:"{:d y:}", tex:null, ttype:DEFINITION},
+{input:"dz", tag:"mi", output:"{:d z:}", tex:null, ttype:DEFINITION},
+{input:"dt", tag:"mi", output:"{:d t:}", tex:null, ttype:DEFINITION},
+{input:"oint", tag:"mo", output:"\u222E", tex:null, ttype:CONST},
+{input:"del", tag:"mo", output:"\u2202", tex:"partial", ttype:CONST},
+{input:"grad", tag:"mo", output:"\u2207", tex:"nabla", ttype:CONST},
+{input:"+-", tag:"mo", output:"\u00B1", tex:"pm", ttype:CONST},
+{input:"O/", tag:"mo", output:"\u2205", tex:"emptyset", ttype:CONST},
+{input:"oo", tag:"mo", output:"\u221E", tex:"infty", ttype:CONST},
+{input:"aleph", tag:"mo", output:"\u2135", tex:null, ttype:CONST},
+{input:"...", tag:"mo", output:"...", tex:"ldots", ttype:CONST},
+{input:":.", tag:"mo", output:"\u2234", tex:"therefore", ttype:CONST},
+{input:":'", tag:"mo", output:"\u2235", tex:"because", ttype:CONST},
+{input:"/_", tag:"mo", output:"\u2220", tex:"angle", ttype:CONST},
+{input:"/_\\", tag:"mo", output:"\u25B3", tex:"triangle", ttype:CONST},
+{input:"'", tag:"mo", output:"\u2032", tex:"prime", ttype:CONST},
+{input:"tilde", tag:"mover", output:"~", tex:null, ttype:UNARY, acc:true},
+{input:"\\ ", tag:"mo", output:"\u00A0", tex:null, ttype:CONST},
+{input:"frown", tag:"mo", output:"\u2322", tex:null, ttype:CONST},
+{input:"quad", tag:"mo", output:"\u00A0\u00A0", tex:null, ttype:CONST},
+{input:"qquad", tag:"mo", output:"\u00A0\u00A0\u00A0\u00A0", tex:null, ttype:CONST},
+{input:"cdots", tag:"mo", output:"\u22EF", tex:null, ttype:CONST},
+{input:"vdots", tag:"mo", output:"\u22EE", tex:null, ttype:CONST},
+{input:"ddots", tag:"mo", output:"\u22F1", tex:null, ttype:CONST},
+{input:"diamond", tag:"mo", output:"\u22C4", tex:null, ttype:CONST},
+{input:"square", tag:"mo", output:"\u25A1", tex:null, ttype:CONST},
+{input:"|__", tag:"mo", output:"\u230A", tex:"lfloor", ttype:CONST},
+{input:"__|", tag:"mo", output:"\u230B", tex:"rfloor", ttype:CONST},
+{input:"|~", tag:"mo", output:"\u2308", tex:"lceiling", ttype:CONST},
+{input:"~|", tag:"mo", output:"\u2309", tex:"rceiling", ttype:CONST},
+{input:"CC", tag:"mo", output:"\u2102", tex:null, ttype:CONST},
+{input:"NN", tag:"mo", output:"\u2115", tex:null, ttype:CONST},
+{input:"QQ", tag:"mo", output:"\u211A", tex:null, ttype:CONST},
+{input:"RR", tag:"mo", output:"\u211D", tex:null, ttype:CONST},
+{input:"ZZ", tag:"mo", output:"\u2124", tex:null, ttype:CONST},
+{input:"f", tag:"mi", output:"f", tex:null, ttype:UNARY, func:true},
+{input:"g", tag:"mi", output:"g", tex:null, ttype:UNARY, func:true},
+
+//standard functions
+{input:"lim", tag:"mo", output:"lim", tex:null, ttype:UNDEROVER},
+{input:"Lim", tag:"mo", output:"Lim", tex:null, ttype:UNDEROVER},
+{input:"sin", tag:"mo", output:"sin", tex:null, ttype:UNARY, func:true},
+{input:"cos", tag:"mo", output:"cos", tex:null, ttype:UNARY, func:true},
+{input:"tan", tag:"mo", output:"tan", tex:null, ttype:UNARY, func:true},
+{input:"sinh", tag:"mo", output:"sinh", tex:null, ttype:UNARY, func:true},
+{input:"cosh", tag:"mo", output:"cosh", tex:null, ttype:UNARY, func:true},
+{input:"tanh", tag:"mo", output:"tanh", tex:null, ttype:UNARY, func:true},
+{input:"cot", tag:"mo", output:"cot", tex:null, ttype:UNARY, func:true},
+{input:"sec", tag:"mo", output:"sec", tex:null, ttype:UNARY, func:true},
+{input:"csc", tag:"mo", output:"csc", tex:null, ttype:UNARY, func:true},
+{input:"arcsin", tag:"mo", output:"arcsin", tex:null, ttype:UNARY, func:true},
+{input:"arccos", tag:"mo", output:"arccos", tex:null, ttype:UNARY, func:true},
+{input:"arctan", tag:"mo", output:"arctan", tex:null, ttype:UNARY, func:true},
+{input:"coth", tag:"mo", output:"coth", tex:null, ttype:UNARY, func:true},
+{input:"sech", tag:"mo", output:"sech", tex:null, ttype:UNARY, func:true},
+{input:"csch", tag:"mo", output:"csch", tex:null, ttype:UNARY, func:true},
+{input:"exp", tag:"mo", output:"exp", tex:null, ttype:UNARY, func:true},
+{input:"abs", tag:"mo", output:"abs", tex:null, ttype:UNARY, rewriteleftright:["|","|"]},
+{input:"norm", tag:"mo", output:"norm", tex:null, ttype:UNARY, rewriteleftright:["\u2225","\u2225"]},
+{input:"floor", tag:"mo", output:"floor", tex:null, ttype:UNARY, rewriteleftright:["\u230A","\u230B"]},
+{input:"ceil", tag:"mo", output:"ceil", tex:null, ttype:UNARY, rewriteleftright:["\u2308","\u2309"]},
+{input:"log", tag:"mo", output:"log", tex:null, ttype:UNARY, func:true},
+{input:"ln", tag:"mo", output:"ln", tex:null, ttype:UNARY, func:true},
+{input:"det", tag:"mo", output:"det", tex:null, ttype:UNARY, func:true},
+{input:"dim", tag:"mo", output:"dim", tex:null, ttype:CONST},
+{input:"mod", tag:"mo", output:"mod", tex:null, ttype:CONST},
+{input:"gcd", tag:"mo", output:"gcd", tex:null, ttype:UNARY, func:true},
+{input:"lcm", tag:"mo", output:"lcm", tex:null, ttype:UNARY, func:true},
+{input:"lub", tag:"mo", output:"lub", tex:null, ttype:CONST},
+{input:"glb", tag:"mo", output:"glb", tex:null, ttype:CONST},
+{input:"min", tag:"mo", output:"min", tex:null, ttype:UNDEROVER},
+{input:"max", tag:"mo", output:"max", tex:null, ttype:UNDEROVER},
+{input:"Sin", tag:"mo", output:"Sin", tex:null, ttype:UNARY, func:true},
+{input:"Cos", tag:"mo", output:"Cos", tex:null, ttype:UNARY, func:true},
+{input:"Tan", tag:"mo", output:"Tan", tex:null, ttype:UNARY, func:true},
+{input:"Arcsin", tag:"mo", output:"Arcsin", tex:null, ttype:UNARY, func:true},
+{input:"Arccos", tag:"mo", output:"Arccos", tex:null, ttype:UNARY, func:true},
+{input:"Arctan", tag:"mo", output:"Arctan", tex:null, ttype:UNARY, func:true},
+{input:"Sinh", tag:"mo", output:"Sinh", tex:null, ttype:UNARY, func:true},
+{input:"Cosh", tag:"mo", output:"Cosh", tex:null, ttype:UNARY, func:true},
+{input:"Tanh", tag:"mo", output:"Tanh", tex:null, ttype:UNARY, func:true},
+{input:"Cot", tag:"mo", output:"Cot", tex:null, ttype:UNARY, func:true},
+{input:"Sec", tag:"mo", output:"Sec", tex:null, ttype:UNARY, func:true},
+{input:"Csc", tag:"mo", output:"Csc", tex:null, ttype:UNARY, func:true},
+{input:"Log", tag:"mo", output:"Log", tex:null, ttype:UNARY, func:true},
+{input:"Ln", tag:"mo", output:"Ln", tex:null, ttype:UNARY, func:true},
+{input:"Abs", tag:"mo", output:"abs", tex:null, ttype:UNARY, notexcopy:true, rewriteleftright:["|","|"]},
+
+//arrows
+{input:"uarr", tag:"mo", output:"\u2191", tex:"uparrow", ttype:CONST},
+{input:"darr", tag:"mo", output:"\u2193", tex:"downarrow", ttype:CONST},
+{input:"rarr", tag:"mo", output:"\u2192", tex:"rightarrow", ttype:CONST},
+{input:"->", tag:"mo", output:"\u2192", tex:"to", ttype:CONST},
+{input:">->", tag:"mo", output:"\u21A3", tex:"rightarrowtail", ttype:CONST},
+{input:"->>", tag:"mo", output:"\u21A0", tex:"twoheadrightarrow", ttype:CONST},
+{input:">->>", tag:"mo", output:"\u2916", tex:"twoheadrightarrowtail", ttype:CONST},
+{input:"|->", tag:"mo", output:"\u21A6", tex:"mapsto", ttype:CONST},
+{input:"larr", tag:"mo", output:"\u2190", tex:"leftarrow", ttype:CONST},
+{input:"harr", tag:"mo", output:"\u2194", tex:"leftrightarrow", ttype:CONST},
+{input:"rArr", tag:"mo", output:"\u21D2", tex:"Rightarrow", ttype:CONST},
+{input:"lArr", tag:"mo", output:"\u21D0", tex:"Leftarrow", ttype:CONST},
+{input:"hArr", tag:"mo", output:"\u21D4", tex:"Leftrightarrow", ttype:CONST},
+//commands with argument
+{input:"sqrt", tag:"msqrt", output:"sqrt", tex:null, ttype:UNARY},
+{input:"root", tag:"mroot", output:"root", tex:null, ttype:BINARY},
+{input:"frac", tag:"mfrac", output:"/", tex:null, ttype:BINARY},
+{input:"/", tag:"mfrac", output:"/", tex:null, ttype:INFIX},
+{input:"stackrel", tag:"mover", output:"stackrel", tex:null, ttype:BINARY},
+{input:"overset", tag:"mover", output:"stackrel", tex:null, ttype:BINARY},
+{input:"underset", tag:"munder", output:"stackrel", tex:null, ttype:BINARY},
+{input:"_", tag:"msub", output:"_", tex:null, ttype:INFIX},
+{input:"^", tag:"msup", output:"^", tex:null, ttype:INFIX},
+{input:"hat", tag:"mover", output:"\u005E", tex:null, ttype:UNARY, acc:true},
+{input:"bar", tag:"mover", output:"\u00AF", tex:"overline", ttype:UNARY, acc:true},
+{input:"vec", tag:"mover", output:"\u2192", tex:null, ttype:UNARY, acc:true},
+{input:"dot", tag:"mover", output:".", tex:null, ttype:UNARY, acc:true},
+{input:"ddot", tag:"mover", output:"..", tex:null, ttype:UNARY, acc:true},
+{input:"overarc", tag:"mover", output:"\u23DC", tex:"overparen", ttype:UNARY, acc:true},
+{input:"ul", tag:"munder", output:"\u0332", tex:"underline", ttype:UNARY, acc:true},
+{input:"ubrace", tag:"munder", output:"\u23DF", tex:"underbrace", ttype:UNARYUNDEROVER, acc:true},
+{input:"obrace", tag:"mover", output:"\u23DE", tex:"overbrace", ttype:UNARYUNDEROVER, acc:true},
+{input:"text", tag:"mtext", output:"text", tex:null, ttype:TEXT},
+{input:"mbox", tag:"mtext", output:"mbox", tex:null, ttype:TEXT},
+{input:"color", tag:"mstyle", ttype:BINARY},
+{input:"id", tag:"mrow", ttype:BINARY},
+{input:"class", tag:"mrow", ttype:BINARY},
+{input:"cancel", tag:"menclose", output:"cancel", tex:null, ttype:UNARY},
+AMquote,
+{input:"bb", tag:"mstyle", atname:"mathvariant", atval:"bold", output:"bb", tex:null, ttype:UNARY},
+{input:"mathbf", tag:"mstyle", atname:"mathvariant", atval:"bold", output:"mathbf", tex:null, ttype:UNARY},
+{input:"sf", tag:"mstyle", atname:"mathvariant", atval:"sans-serif", output:"sf", tex:null, ttype:UNARY},
+{input:"mathsf", tag:"mstyle", atname:"mathvariant", atval:"sans-serif", output:"mathsf", tex:null, ttype:UNARY},
+{input:"bbb", tag:"mstyle", atname:"mathvariant", atval:"double-struck", output:"bbb", tex:null, ttype:UNARY, codes:AMbbb},
+{input:"mathbb", tag:"mstyle", atname:"mathvariant", atval:"double-struck", output:"mathbb", tex:null, ttype:UNARY, codes:AMbbb},
+{input:"cc", tag:"mstyle", atname:"mathvariant", atval:"script", output:"cc", tex:null, ttype:UNARY, codes:AMcal},
+{input:"mathcal", tag:"mstyle", atname:"mathvariant", atval:"script", output:"mathcal", tex:null, ttype:UNARY, codes:AMcal},
+{input:"tt", tag:"mstyle", atname:"mathvariant", atval:"monospace", output:"tt", tex:null, ttype:UNARY},
+{input:"mathtt", tag:"mstyle", atname:"mathvariant", atval:"monospace", output:"mathtt", tex:null, ttype:UNARY},
+{input:"fr", tag:"mstyle", atname:"mathvariant", atval:"fraktur", output:"fr", tex:null, ttype:UNARY, codes:AMfrk},
+{input:"mathfrak", tag:"mstyle", atname:"mathvariant", atval:"fraktur", output:"mathfrak", tex:null, ttype:UNARY, codes:AMfrk}
+];
+
+function compareNames(s1,s2) {
+ if (s1.input > s2.input) return 1
+ else return -1;
+}
+
+var AMnames = []; //list of input symbols
+
+function initSymbols() {
+ var i;
+ var symlen = AMsymbols.length;
+ for (i=0; i<symlen; i++) {
+ if (AMsymbols[i].tex) {
+ AMsymbols.push({input:AMsymbols[i].tex,
+ tag:AMsymbols[i].tag, output:AMsymbols[i].output, ttype:AMsymbols[i].ttype,
+ acc:(AMsymbols[i].acc||false)});
+ }
+ }
+ refreshSymbols();
+}
+
+function refreshSymbols(){
+ var i;
+ AMsymbols.sort(compareNames);
+ for (i=0; i<AMsymbols.length; i++) AMnames[i] = AMsymbols[i].input;
+}
+
+function define(oldstr,newstr) {
+ AMsymbols.push({input:oldstr, tag:"mo", output:newstr, tex:null, ttype:DEFINITION});
+ refreshSymbols(); // this may be a problem if many symbols are defined!
+}
+
+function AMremoveCharsAndBlanks(str,n) {
+//remove n characters and any following blanks
+ var st;
+ if (str.charAt(n)=="\\" && str.charAt(n+1)!="\\" && str.charAt(n+1)!=" ")
+ st = str.slice(n+1);
+ else st = str.slice(n);
+ for (var i=0; i<st.length && st.charCodeAt(i)<=32; i=i+1);
+ return st.slice(i);
+}
+
+function position(arr, str, n) {
+// return position >=n where str appears or would be inserted
+// assumes arr is sorted
+ if (n==0) {
+ var h,m;
+ n = -1;
+ h = arr.length;
+ while (n+1<h) {
+ m = (n+h) >> 1;
+ if (arr[m]<str) n = m; else h = m;
+ }
+ return h;
+ } else
+ for (var i=n; i<arr.length && arr[i]<str; i++);
+ return i; // i=arr.length || arr[i]>=str
+}
+
+function AMgetSymbol(str) {
+//return maximal initial substring of str that appears in names
+//return null if there is none
+ var k = 0; //new pos
+ var j = 0; //old pos
+ var mk; //match pos
+ var st;
+ var tagst;
+ var match = "";
+ var more = true;
+ for (var i=1; i<=str.length && more; i++) {
+ st = str.slice(0,i); //initial substring of length i
+ j = k;
+ k = position(AMnames, st, j);
+ if (k<AMnames.length && str.slice(0,AMnames[k].length)==AMnames[k]){
+ match = AMnames[k];
+ mk = k;
+ i = match.length;
+ }
+ more = k<AMnames.length && str.slice(0,AMnames[k].length)>=AMnames[k];
+ }
+ AMpreviousSymbol=AMcurrentSymbol;
+ if (match!=""){
+ AMcurrentSymbol=AMsymbols[mk].ttype;
+ return AMsymbols[mk];
+ }
+// if str[0] is a digit or - return maxsubstring of digits.digits
+ AMcurrentSymbol=CONST;
+ k = 1;
+ st = str.slice(0,1);
+ var integ = true;
+ while ("0"<=st && st<="9" && k<=str.length) {
+ st = str.slice(k,k+1);
+ k++;
+ }
+ if (st == decimalsign) {
+ st = str.slice(k,k+1);
+ if ("0"<=st && st<="9") {
+ integ = false;
+ k++;
+ while ("0"<=st && st<="9" && k<=str.length) {
+ st = str.slice(k,k+1);
+ k++;
+ }
+ }
+ }
+ if ((integ && k>1) || k>2) {
+ st = str.slice(0,k-1);
+ tagst = "mn";
+ } else {
+ k = 2;
+ st = str.slice(0,1); //take 1 character
+ tagst = (("A">st || st>"Z") && ("a">st || st>"z")?"mo":"mi");
+ }
+ if (st=="-" && AMpreviousSymbol==INFIX) {
+ AMcurrentSymbol = INFIX; //trick "/" into recognizing "-" on second parse
+ return {input:st, tag:tagst, output:st, ttype:UNARY, func:true};
+ }
+ return {input:st, tag:tagst, output:st, ttype:CONST};
+}
+
+function AMremoveBrackets(node) {
+ var st;
+ if (!node.hasChildNodes()) { return; }
+ if (node.firstChild.hasChildNodes() && (node.nodeName=="mrow" || node.nodeName=="M:MROW")) {
+ st = node.firstChild.firstChild.nodeValue;
+ if (st=="(" || st=="[" || st=="{") node.removeChild(node.firstChild);
+ }
+ if (node.lastChild.hasChildNodes() && (node.nodeName=="mrow" || node.nodeName=="M:MROW")) {
+ st = node.lastChild.firstChild.nodeValue;
+ if (st==")" || st=="]" || st=="}") node.removeChild(node.lastChild);
+ }
+}
+
+/*Parsing ASCII math expressions with the following grammar
+v ::= [A-Za-z] | greek letters | numbers | other constant symbols
+u ::= sqrt | text | bb | other unary symbols for font commands
+b ::= frac | root | stackrel binary symbols
+l ::= ( | [ | { | (: | {: left brackets
+r ::= ) | ] | } | :) | :} right brackets
+S ::= v | lEr | uS | bSS Simple expression
+I ::= S_S | S^S | S_S^S | S Intermediate expression
+E ::= IE | I/I Expression
+Each terminal symbol is translated into a corresponding mathml node.*/
+
+var AMnestingDepth,AMpreviousSymbol,AMcurrentSymbol;
+
+function AMparseSexpr(str) { //parses str and returns [node,tailstr]
+ var symbol, node, result, i, st,// rightvert = false,
+ newFrag = document.createDocumentFragment();
+ str = AMremoveCharsAndBlanks(str,0);
+ symbol = AMgetSymbol(str); //either a token or a bracket or empty
+ if (symbol == null || symbol.ttype == RIGHTBRACKET && AMnestingDepth > 0) {
+ return [null,str];
+ }
+ if (symbol.ttype == DEFINITION) {
+ str = symbol.output+AMremoveCharsAndBlanks(str,symbol.input.length);
+ symbol = AMgetSymbol(str);
+ }
+ switch (symbol.ttype) { case UNDEROVER:
+ case CONST:
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ return [createMmlNode(symbol.tag, //its a constant
+ document.createTextNode(symbol.output)),str];
+ case LEFTBRACKET: //read (expr+)
+ AMnestingDepth++;
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ result = AMparseExpr(str,true);
+ AMnestingDepth--;
+ if (typeof symbol.invisible == "boolean" && symbol.invisible)
+ node = createMmlNode("mrow",result[0]);
+ else {
+ node = createMmlNode("mo",document.createTextNode(symbol.output));
+ node = createMmlNode("mrow",node);
+ node.appendChild(result[0]);
+ }
+ return [node,result[1]];
+ case TEXT:
+ if (symbol!=AMquote) str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ if (str.charAt(0)=="{") i=str.indexOf("}");
+ else if (str.charAt(0)=="(") i=str.indexOf(")");
+ else if (str.charAt(0)=="[") i=str.indexOf("]");
+ else if (symbol==AMquote) i=str.slice(1).indexOf("\"")+1;
+ else i = 0;
+ if (i==-1) i = str.length;
+ st = str.slice(1,i);
+ if (st.charAt(0) == " ") {
+ node = createMmlNode("mspace");
+ node.setAttribute("width","1ex");
+ newFrag.appendChild(node);
+ }
+ newFrag.appendChild(
+ createMmlNode(symbol.tag,document.createTextNode(st)));
+ if (st.charAt(st.length-1) == " ") {
+ node = createMmlNode("mspace");
+ node.setAttribute("width","1ex");
+ newFrag.appendChild(node);
+ }
+ str = AMremoveCharsAndBlanks(str,i+1);
+ return [createMmlNode("mrow",newFrag),str];
+ case UNARYUNDEROVER:
+ case UNARY:
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ result = AMparseSexpr(str);
+ if (result[0]==null) return [createMmlNode(symbol.tag,
+ document.createTextNode(symbol.output)),str];
+ if (typeof symbol.func == "boolean" && symbol.func) { // functions hack
+ st = str.charAt(0);
+ if (st=="^" || st=="_" || st=="/" || st=="|" || st=="," ||
+ (symbol.input.length==1 && symbol.input.match(/\w/) && st!="(")) {
+ return [createMmlNode(symbol.tag,
+ document.createTextNode(symbol.output)),str];
+ } else {
+ node = createMmlNode("mrow",
+ createMmlNode(symbol.tag,document.createTextNode(symbol.output)));
+ node.appendChild(result[0]);
+ return [node,result[1]];
+ }
+ }
+ AMremoveBrackets(result[0]);
+ if (symbol.input == "sqrt") { // sqrt
+ return [createMmlNode(symbol.tag,result[0]),result[1]];
+ } else if (typeof symbol.rewriteleftright != "undefined") { // abs, floor, ceil
+ node = createMmlNode("mrow", createMmlNode("mo",document.createTextNode(symbol.rewriteleftright[0])));
+ node.appendChild(result[0]);
+ node.appendChild(createMmlNode("mo",document.createTextNode(symbol.rewriteleftright[1])));
+ return [node,result[1]];
+ } else if (symbol.input == "cancel") { // cancel
+ node = createMmlNode(symbol.tag,result[0]);
+ node.setAttribute("notation","updiagonalstrike");
+ return [node,result[1]];
+ } else if (typeof symbol.acc == "boolean" && symbol.acc) { // accent
+ node = createMmlNode(symbol.tag,result[0]);
+ var accnode = createMmlNode("mo",document.createTextNode(symbol.output));
+ if (symbol.input=="vec" && (
+ (result[0].nodeName=="mrow" && result[0].childNodes.length==1
+ && result[0].firstChild.firstChild.nodeValue !== null
+ && result[0].firstChild.firstChild.nodeValue.length==1) ||
+ (result[0].firstChild.nodeValue !== null
+ && result[0].firstChild.nodeValue.length==1) )) {
+ accnode.setAttribute("stretchy",false);
+ }
+ node.appendChild(accnode);
+ return [node,result[1]];
+ } else { // font change command
+ if (!isIE && typeof symbol.codes != "undefined") {
+ for (i=0; i<result[0].childNodes.length; i++)
+ if (result[0].childNodes[i].nodeName=="mi" || result[0].nodeName=="mi") {
+ st = (result[0].nodeName=="mi"?result[0].firstChild.nodeValue:
+ result[0].childNodes[i].firstChild.nodeValue);
+ var newst = [];
+ for (var j=0; j<st.length; j++)
+ if (st.charCodeAt(j)>64 && st.charCodeAt(j)<91)
+ newst = newst + symbol.codes[st.charCodeAt(j)-65];
+ else if (st.charCodeAt(j)>96 && st.charCodeAt(j)<123)
+ newst = newst + symbol.codes[st.charCodeAt(j)-71];
+ else newst = newst + st.charAt(j);
+ if (result[0].nodeName=="mi")
+ result[0]=createMmlNode("mo").
+ appendChild(document.createTextNode(newst));
+ else result[0].replaceChild(createMmlNode("mo").
+ appendChild(document.createTextNode(newst)),
+ result[0].childNodes[i]);
+ }
+ }
+ node = createMmlNode(symbol.tag,result[0]);
+ node.setAttribute(symbol.atname,symbol.atval);
+ return [node,result[1]];
+ }
+ case BINARY:
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ result = AMparseSexpr(str);
+ if (result[0]==null) return [createMmlNode("mo",
+ document.createTextNode(symbol.input)),str];
+ AMremoveBrackets(result[0]);
+ var result2 = AMparseSexpr(result[1]);
+ if (result2[0]==null) return [createMmlNode("mo",
+ document.createTextNode(symbol.input)),str];
+ AMremoveBrackets(result2[0]);
+ if (['color', 'class', 'id'].indexOf(symbol.input) >= 0) {
+
+ // Get the second argument
+ if (str.charAt(0)=="{") i=str.indexOf("}");
+ else if (str.charAt(0)=="(") i=str.indexOf(")");
+ else if (str.charAt(0)=="[") i=str.indexOf("]");
+ st = str.slice(1,i);
+
+ // Make a mathml node
+ node = createMmlNode(symbol.tag,result2[0]);
+
+ // Set the correct attribute
+ if (symbol.input === "color") node.setAttribute("mathcolor", st)
+ else if (symbol.input === "class") node.setAttribute("class", st)
+ else if (symbol.input === "id") node.setAttribute("id", st)
+ return [node,result2[1]];
+ }
+ if (symbol.input=="root" || symbol.output=="stackrel")
+ newFrag.appendChild(result2[0]);
+ newFrag.appendChild(result[0]);
+ if (symbol.input=="frac") newFrag.appendChild(result2[0]);
+ return [createMmlNode(symbol.tag,newFrag),result2[1]];
+ case INFIX:
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ return [createMmlNode("mo",document.createTextNode(symbol.output)),str];
+ case SPACE:
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ node = createMmlNode("mspace");
+ node.setAttribute("width","1ex");
+ newFrag.appendChild(node);
+ newFrag.appendChild(
+ createMmlNode(symbol.tag,document.createTextNode(symbol.output)));
+ node = createMmlNode("mspace");
+ node.setAttribute("width","1ex");
+ newFrag.appendChild(node);
+ return [createMmlNode("mrow",newFrag),str];
+ case LEFTRIGHT:
+// if (rightvert) return [null,str]; else rightvert = true;
+ AMnestingDepth++;
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ result = AMparseExpr(str,false);
+ AMnestingDepth--;
+ st = "";
+ if (result[0].lastChild!=null)
+ st = result[0].lastChild.firstChild.nodeValue;
+ if (st == "|" && str.charAt(0)!==",") { // its an absolute value subterm
+ node = createMmlNode("mo",document.createTextNode(symbol.output));
+ node = createMmlNode("mrow",node);
+ node.appendChild(result[0]);
+ return [node,result[1]];
+ } else { // the "|" is a \mid so use unicode 2223 (divides) for spacing
+ node = createMmlNode("mo",document.createTextNode("\u2223"));
+ node = createMmlNode("mrow",node);
+ return [node,str];
+ }
+ default:
+//alert("default");
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ return [createMmlNode(symbol.tag, //its a constant
+ document.createTextNode(symbol.output)),str];
+ }
+}
+
+function AMparseIexpr(str) {
+ var symbol, sym1, sym2, node, result, underover;
+ str = AMremoveCharsAndBlanks(str,0);
+ sym1 = AMgetSymbol(str);
+ result = AMparseSexpr(str);
+ node = result[0];
+ str = result[1];
+ symbol = AMgetSymbol(str);
+ if (symbol.ttype == INFIX && symbol.input != "/") {
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+// if (symbol.input == "/") result = AMparseIexpr(str); else ...
+ result = AMparseSexpr(str);
+ if (result[0] == null) // show box in place of missing argument
+ result[0] = createMmlNode("mo",document.createTextNode("\u25A1"));
+ else AMremoveBrackets(result[0]);
+ str = result[1];
+// if (symbol.input == "/") AMremoveBrackets(node);
+ underover = (sym1.ttype == UNDEROVER || sym1.ttype == UNARYUNDEROVER);
+ if (symbol.input == "_") {
+ sym2 = AMgetSymbol(str);
+ if (sym2.input == "^") {
+ str = AMremoveCharsAndBlanks(str,sym2.input.length);
+ var res2 = AMparseSexpr(str);
+ AMremoveBrackets(res2[0]);
+ str = res2[1];
+ node = createMmlNode((underover?"munderover":"msubsup"),node);
+ node.appendChild(result[0]);
+ node.appendChild(res2[0]);
+ node = createMmlNode("mrow",node); // so sum does not stretch
+ } else {
+ node = createMmlNode((underover?"munder":"msub"),node);
+ node.appendChild(result[0]);
+ }
+ } else if (symbol.input == "^" && underover) {
+ node = createMmlNode("mover",node);
+ node.appendChild(result[0]);
+ } else {
+ node = createMmlNode(symbol.tag,node);
+ node.appendChild(result[0]);
+ }
+ if (typeof sym1.func != 'undefined' && sym1.func) {
+ sym2 = AMgetSymbol(str);
+ if (sym2.ttype != INFIX && sym2.ttype != RIGHTBRACKET &&
+ (sym1.input.length>1 || sym2.ttype == LEFTBRACKET)) {
+ result = AMparseIexpr(str);
+ node = createMmlNode("mrow",node);
+ node.appendChild(result[0]);
+ str = result[1];
+ }
+ }
+ }
+ return [node,str];
+}
+
+function AMparseExpr(str,rightbracket) {
+ var symbol, node, result, i,
+ newFrag = document.createDocumentFragment();
+ do {
+ str = AMremoveCharsAndBlanks(str,0);
+ result = AMparseIexpr(str);
+ node = result[0];
+ str = result[1];
+ symbol = AMgetSymbol(str);
+ if (symbol.ttype == INFIX && symbol.input == "/") {
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ result = AMparseIexpr(str);
+ if (result[0] == null) // show box in place of missing argument
+ result[0] = createMmlNode("mo",document.createTextNode("\u25A1"));
+ else AMremoveBrackets(result[0]);
+ str = result[1];
+ AMremoveBrackets(node);
+ node = createMmlNode(symbol.tag,node);
+ node.appendChild(result[0]);
+ newFrag.appendChild(node);
+ symbol = AMgetSymbol(str);
+ }
+ else if (node!=undefined) newFrag.appendChild(node);
+ } while ((symbol.ttype != RIGHTBRACKET &&
+ (symbol.ttype != LEFTRIGHT || rightbracket)
+ || AMnestingDepth == 0) && symbol!=null && symbol.output!="");
+ if (symbol.ttype == RIGHTBRACKET || symbol.ttype == LEFTRIGHT) {
+// if (AMnestingDepth > 0) AMnestingDepth--;
+ var len = newFrag.childNodes.length;
+ if (len>0 && newFrag.childNodes[len-1].nodeName == "mrow"
+ && newFrag.childNodes[len-1].lastChild
+ && newFrag.childNodes[len-1].lastChild.firstChild ) { //matrix
+ //removed to allow row vectors: //&& len>1 &&
+ //newFrag.childNodes[len-2].nodeName == "mo" &&
+ //newFrag.childNodes[len-2].firstChild.nodeValue == ","
+ var right = newFrag.childNodes[len-1].lastChild.firstChild.nodeValue;
+ if (right==")" || right=="]") {
+ var left = newFrag.childNodes[len-1].firstChild.firstChild.nodeValue;
+ if (left=="(" && right==")" && symbol.output != "}" ||
+ left=="[" && right=="]") {
+ var pos = []; // positions of commas
+ var matrix = true;
+ var m = newFrag.childNodes.length;
+ for (i=0; matrix && i<m; i=i+2) {
+ pos[i] = [];
+ node = newFrag.childNodes[i];
+ if (matrix) matrix = node.nodeName=="mrow" &&
+ (i==m-1 || node.nextSibling.nodeName=="mo" &&
+ node.nextSibling.firstChild.nodeValue==",")&&
+ node.firstChild.firstChild.nodeValue==left &&
+ node.lastChild.firstChild.nodeValue==right;
+ if (matrix)
+ for (var j=0; j<node.childNodes.length; j++)
+ if (node.childNodes[j].firstChild.nodeValue==",")
+ pos[i][pos[i].length]=j;
+ if (matrix && i>1) matrix = pos[i].length == pos[i-2].length;
+ }
+ matrix = matrix && (pos.length>1 || pos[0].length>0);
+ var columnlines = [];
+ if (matrix) {
+ var row, frag, n, k, table = document.createDocumentFragment();
+ for (i=0; i<m; i=i+2) {
+ row = document.createDocumentFragment();
+ frag = document.createDocumentFragment();
+ node = newFrag.firstChild; // <mrow>(-,-,...,-,-)</mrow>
+ n = node.childNodes.length;
+ k = 0;
+ node.removeChild(node.firstChild); //remove (
+ for (j=1; j<n-1; j++) {
+ if (typeof pos[i][k] != "undefined" && j==pos[i][k]){
+ node.removeChild(node.firstChild); //remove ,
+ if (node.firstChild.nodeName=="mrow" && node.firstChild.childNodes.length==1 &&
+ node.firstChild.firstChild.firstChild.nodeValue=="\u2223") {
+ //is columnline marker - skip it
+ if (i==0) { columnlines.push("solid"); }
+ node.removeChild(node.firstChild); //remove mrow
+ node.removeChild(node.firstChild); //remove ,
+ j+=2;
+ k++;
+ } else if (i==0) { columnlines.push("none"); }
+ row.appendChild(createMmlNode("mtd",frag));
+ k++;
+ } else frag.appendChild(node.firstChild);
+ }
+ row.appendChild(createMmlNode("mtd",frag));
+ if (i==0) { columnlines.push("none"); }
+ if (newFrag.childNodes.length>2) {
+ newFrag.removeChild(newFrag.firstChild); //remove <mrow>)</mrow>
+ newFrag.removeChild(newFrag.firstChild); //remove <mo>,</mo>
+ }
+ table.appendChild(createMmlNode("mtr",row));
+ }
+ node = createMmlNode("mtable",table);
+ node.setAttribute("columnlines", columnlines.join(" "));
+ if (typeof symbol.invisible == "boolean" && symbol.invisible) node.setAttribute("columnalign","left");
+ newFrag.replaceChild(node,newFrag.firstChild);
+ }
+ }
+ }
+ }
+ str = AMremoveCharsAndBlanks(str,symbol.input.length);
+ if (typeof symbol.invisible != "boolean" || !symbol.invisible) {
+ node = createMmlNode("mo",document.createTextNode(symbol.output));
+ newFrag.appendChild(node);
+ }
+ }
+ return [newFrag,str];
+}
+
+function parseMath(str,latex) {
+ var frag, node;
+ AMnestingDepth = 0;
+ //some basic cleanup for dealing with stuff editors like TinyMCE adds
+ str = str.replace(/&nbsp;/g,"");
+ str = str.replace(/&gt;/g,">");
+ str = str.replace(/&lt;/g,"<");
+ frag = AMparseExpr(str.replace(/^\s+/g,""),false)[0];
+ node = createMmlNode("mstyle",frag);
+ if (mathcolor != "") node.setAttribute("mathcolor",mathcolor);
+ if (mathfontsize != "") {
+ node.setAttribute("fontsize", mathfontsize);
+ node.setAttribute("mathsize", mathfontsize);
+ }
+ if (mathfontfamily != "") {
+ node.setAttribute("fontfamily", mathfontfamily);
+ node.setAttribute("mathvariant", mathfontfamily);
+ }
+
+ if (displaystyle) node.setAttribute("displaystyle","true");
+ node = createMmlNode("math",node);
+ if (showasciiformulaonhover) //fixed by djhsu so newline
+ node.setAttribute("title",str.replace(/\s+/g," "));//does not show in Gecko
+ return node;
+}
+
+/*
+function strarr2docFrag(arr, linebreaks, latex) {
+ var newFrag=document.createDocumentFragment();
+ var expr = false;
+ for (var i=0; i<arr.length; i++) {
+ if (expr) newFrag.appendChild(parseMath(arr[i],latex));
+ else {
+ var arri = (linebreaks ? arr[i].split("\n\n") : [arr[i]]);
+ newFrag.appendChild(createElementXHTML("span").
+ appendChild(document.createTextNode(arri[0])));
+ for (var j=1; j<arri.length; j++) {
+ newFrag.appendChild(createElementXHTML("p"));
+ newFrag.appendChild(createElementXHTML("span").
+ appendChild(document.createTextNode(arri[j])));
+ }
+ }
+ expr = !expr;
+ }
+ return newFrag;
+}
+
+function AMautomathrec(str) {
+//formula is a space (or start of str) followed by a maximal sequence of *two* or more tokens, possibly separated by runs of digits and/or space.
+//tokens are single letters (except a, A, I) and ASCIIMathML tokens
+ var texcommand = "\\\\[a-zA-Z]+|\\\\\\s|";
+ var ambigAMtoken = "\\b(?:oo|lim|ln|int|oint|del|grad|aleph|prod|prop|sinh|cosh|tanh|cos|sec|pi|tt|fr|sf|sube|supe|sub|sup|det|mod|gcd|lcm|min|max|vec|ddot|ul|chi|eta|nu|mu)(?![a-z])|";
+ var englishAMtoken = "\\b(?:sum|ox|log|sin|tan|dim|hat|bar|dot)(?![a-z])|";
+ var secondenglishAMtoken = "|\\bI\\b|\\bin\\b|\\btext\\b"; // took if and or not out
+ var simpleAMtoken = "NN|ZZ|QQ|RR|CC|TT|AA|EE|sqrt|dx|dy|dz|dt|xx|vv|uu|nn|bb|cc|csc|cot|alpha|beta|delta|Delta|epsilon|gamma|Gamma|kappa|lambda|Lambda|omega|phi|Phi|Pi|psi|Psi|rho|sigma|Sigma|tau|theta|Theta|xi|Xi|zeta"; // uuu nnn?
+ var letter = "[a-zA-HJ-Z](?=(?:[^a-zA-Z]|$|"+ambigAMtoken+englishAMtoken+simpleAMtoken+"))|";
+ var token = letter+texcommand+"\\d+|[-()[\\]{}+=*&^_%\\\@/<>,\\|!:;'~]|\\.(?!(?:\x20|$))|"+ambigAMtoken+englishAMtoken+simpleAMtoken;
+ var re = new RegExp("(^|\\s)((("+token+")\\s?)(("+token+secondenglishAMtoken+")\\s?)+)([,.?]?(?=\\s|$))","g");
+ str = str.replace(re," `$2`$7");
+ var arr = str.split(AMdelimiter1);
+ var re1 = new RegExp("(^|\\s)([b-zB-HJ-Z+*<>]|"+texcommand+ambigAMtoken+simpleAMtoken+")(\\s|\\n|$)","g");
+ var re2 = new RegExp("(^|\\s)([a-z]|"+texcommand+ambigAMtoken+simpleAMtoken+")([,.])","g"); // removed |\d+ for now
+ for (i=0; i<arr.length; i++) //single nonenglish tokens
+ if (i%2==0) {
+ arr[i] = arr[i].replace(re1," `$2`$3");
+ arr[i] = arr[i].replace(re2," `$2`$3");
+ arr[i] = arr[i].replace(/([{}[\]])/,"`$1`");
+ }
+ str = arr.join(AMdelimiter1);
+ str = str.replace(/((^|\s)\([a-zA-Z]{2,}.*?)\)`/g,"$1`)"); //fix parentheses
+ str = str.replace(/`(\((a\s|in\s))(.*?[a-zA-Z]{2,}\))/g,"$1`$3"); //fix parentheses
+ str = str.replace(/\sin`/g,"` in");
+ str = str.replace(/`(\(\w\)[,.]?(\s|\n|$))/g,"$1`");
+ str = str.replace(/`([0-9.]+|e.g|i.e)`(\.?)/gi,"$1$2");
+ str = str.replace(/`([0-9.]+:)`/g,"$1");
+ return str;
+}
+
+function processNodeR(n, linebreaks,latex) {
+ var mtch, str, arr, frg, i;
+ if (n.childNodes.length == 0) {
+ if ((n.nodeType!=8 || linebreaks) &&
+ n.parentNode.nodeName!="form" && n.parentNode.nodeName!="FORM" &&
+ n.parentNode.nodeName!="textarea" && n.parentNode.nodeName!="TEXTAREA"
+ //&&
+ //n.parentNode.nodeName!="pre" && n.parentNode.nodeName!="PRE"
+ ) {
+ str = n.nodeValue;
+ if (!(str == null)) {
+ str = str.replace(/\r\n\r\n/g,"\n\n");
+ str = str.replace(/\x20+/g," ");
+ str = str.replace(/\s*\r\n/g," ");
+ if(latex) {
+// DELIMITERS:
+ mtch = (str.indexOf("\$")==-1 ? false : true);
+ str = str.replace(/([^\\])\$/g,"$1 \$");
+ str = str.replace(/^\$/," \$"); // in case \$ at start of string
+ arr = str.split(" \$");
+ for (i=0; i<arr.length; i++)
+ arr[i]=arr[i].replace(/\\\$/g,"\$");
+ } else {
+ mtch = false;
+ str = str.replace(new RegExp(AMescape1, "g"),
+ function(){mtch = true; return "AMescape1"});
+ str = str.replace(/\\?end{?a?math}?/i,
+ function(){automathrecognize = false; mtch = true; return ""});
+ str = str.replace(/amath\b|\\begin{a?math}/i,
+ function(){automathrecognize = true; mtch = true; return ""});
+ arr = str.split(AMdelimiter1);
+ if (automathrecognize)
+ for (i=0; i<arr.length; i++)
+ if (i%2==0) arr[i] = AMautomathrec(arr[i]);
+ str = arr.join(AMdelimiter1);
+ arr = str.split(AMdelimiter1);
+ for (i=0; i<arr.length; i++) // this is a problem ************
+ arr[i]=arr[i].replace(/AMescape1/g,AMdelimiter1);
+ }
+ if (arr.length>1 || mtch) {
+ if (!noMathML) {
+ frg = strarr2docFrag(arr,n.nodeType==8,latex);
+ var len = frg.childNodes.length;
+ n.parentNode.replaceChild(frg,n);
+ return len-1;
+ } else return 0;
+ }
+ }
+ } else return 0;
+ } else if (n.nodeName!="math") {
+ for (i=0; i<n.childNodes.length; i++)
+ i += processNodeR(n.childNodes[i], linebreaks,latex);
+ }
+ return 0;
+}
+
+function AMprocessNode(n, linebreaks, spanclassAM) {
+ var frag,st;
+ if (spanclassAM!=null) {
+ frag = document.getElementsByTagName("span")
+ for (var i=0;i<frag.length;i++)
+ if (frag[i].className == "AM")
+ processNodeR(frag[i],linebreaks,false);
+ } else {
+ try {
+ st = n.innerHTML; // look for AMdelimiter on page
+ } catch(err) {}
+//alert(st)
+ if (st==null || /amath\b|\\begin{a?math}/i.test(st) ||
+ st.indexOf(AMdelimiter1+" ")!=-1 || st.slice(-1)==AMdelimiter1 ||
+ st.indexOf(AMdelimiter1+"<")!=-1 || st.indexOf(AMdelimiter1+"\n")!=-1) {
+ processNodeR(n,linebreaks,false);
+ }
+ }
+}
+
+function generic(){
+ if(!init()) return;
+ if (translateOnLoad) {
+ translate();
+ }
+};
+//setup onload function
+if(typeof window.addEventListener != 'undefined'){
+ //.. gecko, safari, konqueror and standard
+ window.addEventListener('load', generic, false);
+}
+else if(typeof document.addEventListener != 'undefined'){
+ //.. opera 7
+ document.addEventListener('load', generic, false);
+}
+else if(typeof window.attachEvent != 'undefined'){
+ //.. win/ie
+ window.attachEvent('onload', generic);
+}else{
+ //.. mac/ie5 and anything else that gets this far
+ //if there's an existing onload function
+ if(typeof window.onload == 'function'){
+ //store it
+ var existing = onload;
+ //add new onload handler
+ window.onload = function(){
+ //call existing onload function
+ existing();
+ //call generic onload function
+ generic();
+ };
+ }else{
+ window.onload = generic;
+ }
+}
+
+//expose some functions to outside
+asciimath.newcommand = newcommand;
+asciimath.newsymbol = newsymbol;
+asciimath.AMprocesssNode = AMprocessNode;
+asciimath.parseMath = parseMath;
+asciimath.translate = translate;
+})();
+
+*/
+
+/******************************************************************
+ *
+ * The previous section is ASCIIMathML.js Version 2.2
+ * (c) Peter Jipsen, used with permission.
+ *
+ ******************************************************************/
+
+showasciiformulaonhover = false;
+mathfontfamily = "";
+mathcolor = "";
+mathfontsize = "";
+
+//
+// Remove remapping of mathvariants to plane1 (MathJax handles that)
+// Change functions to mi rather than mo (to get spacing right)
+//
+(function () {
+ for (var i = 0, m = AMsymbols.length; i < m; i++) {
+ if (AMsymbols[i].codes) {delete AMsymbols[i].codes}
+ if (AMsymbols[i].func) {AMsymbols[i].tag = "mi"}
+ }
+})();
+
+//
+// Access to AsciiMath functions and values
+//
+ASCIIMATH.Augment({
+ AM: {
+ Init: function () {
+ displaystyle = ASCIIMATH.config.displaystyle;
+ // Old versions use the "decimal" option, so take it into account if it
+ // is defined by the user. See issue 384.
+ decimalsign = (ASCIIMATH.config.decimal || ASCIIMATH.config.decimalsign);
+ // unfix phi and varphi, if requested
+ if (!ASCIIMATH.config.fixphi) {
+ for (var i = 0, m = AMsymbols.length; i < m; i++) {
+ if (AMsymbols[i].input === "phi") {AMsymbols[i].output = "\u03C6"}
+ if (AMsymbols[i].input === "varphi") {AMsymbols[i].output = "\u03D5"; i = m}
+ }
+ }
+
+ INITASCIIMATH();
+ initSymbols();
+ },
+ Augment: function (def) {
+ for (var id in def) {if (def.hasOwnProperty(id)) {
+ switch (id) {
+ case "displaystyle": displaystyle = def[id]; break;
+ case "decimal": decimal = def[id]; break;
+ case "parseMath": parseMath = def[id]; break;
+ case "parseExpr": AMparseExpr = def[id]; break;
+ case "parseIexpr": AMparseIexpr = def[id]; break;
+ case "parseSexpr": AMparseSexpr = def[id]; break;
+ case "removeBrackets": AMremoveBrackets = def[id]; break;
+ case "getSymbol": AMgetSymbol = def[id]; break;
+ case "position": position = def[id]; break;
+ case "removeCharsAndBlanks": AMremoveCharsAndBlanks = def[id]; break;
+ case "createMmlNode": createMmlNode = def[id]; break;
+ case "createElementMathML": AMcreateElementMathML = def[id]; break;
+ case "createElementXHTML": createElementXHTML = def[id]; break;
+ case "initSymbols": initSymbols = def[id]; break;
+ case "refreshSymbols": refreshSymbols = def[id]; break;
+ case "compareNames": compareNames = def[id]; break;
+ };
+ this[id] = def[id];
+ }};
+ },
+ parseMath: parseMath,
+ parseExpr: AMparseExpr,
+ parseIexpr: AMparseIexpr,
+ parseSexr: AMparseSexpr,
+ removeBrackets: AMremoveBrackets,
+ getSymbol: AMgetSymbol,
+ position: position,
+ removeCharsAndBlanks: AMremoveCharsAndBlanks,
+ createMmlNode: createMmlNode,
+ createElementMathML: AMcreateElementMathML,
+ createElementXHTML: createElementXHTML,
+ initSymbols: initSymbols,
+ refreshSymbols: refreshSymbols,
+ compareNames: compareNames,
+
+ createDocumentFragment: DOCFRAG,
+ document: document,
+
+ define: define,
+ newcommand: newcommand,
+ newsymbol: newsymbol,
+ symbols: AMsymbols,
+ names: AMnames,
+
+ TOKEN: {
+ CONST:CONST, UNARY:UNARY, BINARY:BINARY, INFIX:INFIX,
+ LEFTBRACKET:LEFTBRACKET, RIGHTBRACKET:RIGHTBRACKET, SPACE:SPACE,
+ UNDEROVER:UNDEROVER, DEFINITION:DEFINITION, LEFTRIGHT:LEFTRIGHT, TEXT:TEXT,
+ UNARYUNDEROVER:UNARYUNDEROVER
+ }
+ }
+});
+
+//
+// Make minimizer think these have been used
+//
+var junk = [window, navigator]; junk = null;
+
+})(MathJax.InputJax.AsciiMath);
+
+
+/************************************************************************/
+
+(function (ASCIIMATH) {
+ var MML;
+
+ ASCIIMATH.Augment({
+ sourceMenuTitle: /*_(MathMenu)*/ ["AsciiMathInput","AsciiMath Input"],
+ annotationEncoding: "text/x-asciimath",
+
+ prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run before processing AsciiMath
+ postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run after processing AsciiMath
+
+ Translate: function (script) {
+ var mml, math = MathJax.HTML.getScript(script);
+ var data = {math:math, script:script};
+ var callback = this.prefilterHooks.Execute(data); if (callback) return callback;
+ math = data.math;
+ try {
+ mml = this.AM.parseMath(math);
+ } catch(err) {
+ if (!err.asciimathError) {throw err}
+ mml = this.formatError(err,math);
+ }
+ data.math = MML(mml); this.postfilterHooks.Execute(data);
+ return this.postfilterHooks.Execute(data) || data.math;
+ },
+ formatError: function (err,math,script) {
+ var message = err.message.replace(/\n.*/,"");
+ MathJax.Hub.signal.Post(["AsciiMath Jax - parse error",message,math,script]);
+ return MML.Error(message);
+ },
+ Error: function (message) {
+ throw MathJax.Hub.Insert(Error(message),{asciimathError: true});
+ },
+ //
+ // Initialize the MML variable and AsciiMath itself
+ //
+ Startup: function () {
+ MML = MathJax.ElementJax.mml;
+ this.AM.Init();
+ }
+ });
+
+ ASCIIMATH.loadComplete("jax.js");
+
+})(MathJax.InputJax.AsciiMath);
+
+
+
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/config.js b/js/mathjax/jax/input/MathML/config.js
new file mode 100644
index 0000000..d5f902b
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/config.js
@@ -0,0 +1,43 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/input/MathML/config.js
+ *
+ * Initializes the MathML InputJax (the main definition is in
+ * MathJax/jax/input/MathML/jax.js, which is loaded when needed).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2009-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.InputJax.MathML = MathJax.InputJax({
+ id: "MathML",
+ version: "2.7.9",
+ directory: MathJax.InputJax.directory + "/MathML",
+ extensionDir: MathJax.InputJax.extensionDir + "/MathML",
+ entityDir: MathJax.InputJax.directory + "/MathML/entities",
+
+ config: {
+ useMathMLspacing: false // false means use TeX spacing, true means MML spacing
+ }
+});
+MathJax.InputJax.MathML.Register("math/mml");
+
+MathJax.InputJax.MathML.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/a.js b/js/mathjax/jax/input/MathML/entities/a.js
new file mode 100644
index 0000000..4e7dae4
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/a.js
@@ -0,0 +1,92 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/a.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'AElig': '\u00C6',
+ 'AMP': '\u0026',
+ 'Aacute': '\u00C1',
+ 'Abreve': '\u0102',
+ 'Acirc': '\u00C2',
+ 'Acy': '\u0410',
+ 'Agrave': '\u00C0',
+ 'Alpha': '\u0391',
+ 'Amacr': '\u0100',
+ 'And': '\u2A53',
+ 'Aogon': '\u0104',
+ 'Aring': '\u00C5',
+ 'Assign': '\u2254',
+ 'Atilde': '\u00C3',
+ 'Auml': '\u00C4',
+ 'aacute': '\u00E1',
+ 'abreve': '\u0103',
+ 'ac': '\u223E',
+ 'acE': '\u223E\u0333',
+ 'acd': '\u223F',
+ 'acirc': '\u00E2',
+ 'acy': '\u0430',
+ 'aelig': '\u00E6',
+ 'af': '\u2061',
+ 'agrave': '\u00E0',
+ 'alefsym': '\u2135',
+ 'amacr': '\u0101',
+ 'amp': '\u0026',
+ 'andand': '\u2A55',
+ 'andd': '\u2A5C',
+ 'andslope': '\u2A58',
+ 'andv': '\u2A5A',
+ 'ange': '\u29A4',
+ 'angle': '\u2220',
+ 'angmsdaa': '\u29A8',
+ 'angmsdab': '\u29A9',
+ 'angmsdac': '\u29AA',
+ 'angmsdad': '\u29AB',
+ 'angmsdae': '\u29AC',
+ 'angmsdaf': '\u29AD',
+ 'angmsdag': '\u29AE',
+ 'angmsdah': '\u29AF',
+ 'angrt': '\u221F',
+ 'angrtvb': '\u22BE',
+ 'angrtvbd': '\u299D',
+ 'angst': '\u00C5',
+ 'angzarr': '\u237C',
+ 'aogon': '\u0105',
+ 'ap': '\u2248',
+ 'apE': '\u2A70',
+ 'apacir': '\u2A6F',
+ 'apid': '\u224B',
+ 'apos': '\u0027',
+ 'approx': '\u2248',
+ 'approxeq': '\u224A',
+ 'aring': '\u00E5',
+ 'ast': '\u002A',
+ 'asymp': '\u2248',
+ 'asympeq': '\u224D',
+ 'atilde': '\u00E3',
+ 'auml': '\u00E4',
+ 'awconint': '\u2233',
+ 'awint': '\u2A11'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/a.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/b.js b/js/mathjax/jax/input/MathML/entities/b.js
new file mode 100644
index 0000000..c3e04ee
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/b.js
@@ -0,0 +1,118 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/b.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Barv': '\u2AE7',
+ 'Barwed': '\u2306',
+ 'Bcy': '\u0411',
+ 'Bernoullis': '\u212C',
+ 'Beta': '\u0392',
+ 'Bumpeq': '\u224E',
+ 'bNot': '\u2AED',
+ 'backcong': '\u224C',
+ 'backepsilon': '\u03F6',
+ 'barvee': '\u22BD',
+ 'barwed': '\u2305',
+ 'barwedge': '\u2305',
+ 'bbrk': '\u23B5',
+ 'bbrktbrk': '\u23B6',
+ 'bcong': '\u224C',
+ 'bcy': '\u0431',
+ 'bdquo': '\u201E',
+ 'becaus': '\u2235',
+ 'because': '\u2235',
+ 'bemptyv': '\u29B0',
+ 'bepsi': '\u03F6',
+ 'bernou': '\u212C',
+ 'bigcap': '\u22C2',
+ 'bigcup': '\u22C3',
+ 'bigvee': '\u22C1',
+ 'bigwedge': '\u22C0',
+ 'bkarow': '\u290D',
+ 'blacksquare': '\u25AA',
+ 'blacktriangleright': '\u25B8',
+ 'blank': '\u2423',
+ 'blk12': '\u2592',
+ 'blk14': '\u2591',
+ 'blk34': '\u2593',
+ 'block': '\u2588',
+ 'bne': '\u003D\u20E5',
+ 'bnequiv': '\u2261\u20E5',
+ 'bnot': '\u2310',
+ 'bot': '\u22A5',
+ 'bottom': '\u22A5',
+ 'boxDL': '\u2557',
+ 'boxDR': '\u2554',
+ 'boxDl': '\u2556',
+ 'boxDr': '\u2553',
+ 'boxH': '\u2550',
+ 'boxHD': '\u2566',
+ 'boxHU': '\u2569',
+ 'boxHd': '\u2564',
+ 'boxHu': '\u2567',
+ 'boxUL': '\u255D',
+ 'boxUR': '\u255A',
+ 'boxUl': '\u255C',
+ 'boxUr': '\u2559',
+ 'boxV': '\u2551',
+ 'boxVH': '\u256C',
+ 'boxVL': '\u2563',
+ 'boxVR': '\u2560',
+ 'boxVh': '\u256B',
+ 'boxVl': '\u2562',
+ 'boxVr': '\u255F',
+ 'boxbox': '\u29C9',
+ 'boxdL': '\u2555',
+ 'boxdR': '\u2552',
+ 'boxh': '\u2500',
+ 'boxhD': '\u2565',
+ 'boxhU': '\u2568',
+ 'boxhd': '\u252C',
+ 'boxhu': '\u2534',
+ 'boxuL': '\u255B',
+ 'boxuR': '\u2558',
+ 'boxv': '\u2502',
+ 'boxvH': '\u256A',
+ 'boxvL': '\u2561',
+ 'boxvR': '\u255E',
+ 'boxvh': '\u253C',
+ 'boxvl': '\u2524',
+ 'boxvr': '\u251C',
+ 'bprime': '\u2035',
+ 'breve': '\u02D8',
+ 'brvbar': '\u00A6',
+ 'bsemi': '\u204F',
+ 'bsim': '\u223D',
+ 'bsime': '\u22CD',
+ 'bsolb': '\u29C5',
+ 'bsolhsub': '\u27C8',
+ 'bullet': '\u2022',
+ 'bump': '\u224E',
+ 'bumpE': '\u2AAE',
+ 'bumpe': '\u224F',
+ 'bumpeq': '\u224F'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/b.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/c.js b/js/mathjax/jax/input/MathML/entities/c.js
new file mode 100644
index 0000000..90ef2e6
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/c.js
@@ -0,0 +1,116 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/c.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'CHcy': '\u0427',
+ 'COPY': '\u00A9',
+ 'Cacute': '\u0106',
+ 'CapitalDifferentialD': '\u2145',
+ 'Cayleys': '\u212D',
+ 'Ccaron': '\u010C',
+ 'Ccedil': '\u00C7',
+ 'Ccirc': '\u0108',
+ 'Cconint': '\u2230',
+ 'Cdot': '\u010A',
+ 'Cedilla': '\u00B8',
+ 'Chi': '\u03A7',
+ 'ClockwiseContourIntegral': '\u2232',
+ 'CloseCurlyDoubleQuote': '\u201D',
+ 'CloseCurlyQuote': '\u2019',
+ 'Colon': '\u2237',
+ 'Colone': '\u2A74',
+ 'Conint': '\u222F',
+ 'CounterClockwiseContourIntegral': '\u2233',
+ 'cacute': '\u0107',
+ 'capand': '\u2A44',
+ 'capbrcup': '\u2A49',
+ 'capcap': '\u2A4B',
+ 'capcup': '\u2A47',
+ 'capdot': '\u2A40',
+ 'caps': '\u2229\uFE00',
+ 'caret': '\u2041',
+ 'caron': '\u02C7',
+ 'ccaps': '\u2A4D',
+ 'ccaron': '\u010D',
+ 'ccedil': '\u00E7',
+ 'ccirc': '\u0109',
+ 'ccups': '\u2A4C',
+ 'ccupssm': '\u2A50',
+ 'cdot': '\u010B',
+ 'cedil': '\u00B8',
+ 'cemptyv': '\u29B2',
+ 'cent': '\u00A2',
+ 'centerdot': '\u00B7',
+ 'chcy': '\u0447',
+ 'checkmark': '\u2713',
+ 'cir': '\u25CB',
+ 'cirE': '\u29C3',
+ 'cire': '\u2257',
+ 'cirfnint': '\u2A10',
+ 'cirmid': '\u2AEF',
+ 'cirscir': '\u29C2',
+ 'clubsuit': '\u2663',
+ 'colone': '\u2254',
+ 'coloneq': '\u2254',
+ 'comma': '\u002C',
+ 'commat': '\u0040',
+ 'compfn': '\u2218',
+ 'complement': '\u2201',
+ 'complexes': '\u2102',
+ 'cong': '\u2245',
+ 'congdot': '\u2A6D',
+ 'conint': '\u222E',
+ 'coprod': '\u2210',
+ 'copy': '\u00A9',
+ 'copysr': '\u2117',
+ 'crarr': '\u21B5',
+ 'cross': '\u2717',
+ 'csub': '\u2ACF',
+ 'csube': '\u2AD1',
+ 'csup': '\u2AD0',
+ 'csupe': '\u2AD2',
+ 'cudarrl': '\u2938',
+ 'cudarrr': '\u2935',
+ 'cularrp': '\u293D',
+ 'cupbrcap': '\u2A48',
+ 'cupcap': '\u2A46',
+ 'cupcup': '\u2A4A',
+ 'cupdot': '\u228D',
+ 'cupor': '\u2A45',
+ 'cups': '\u222A\uFE00',
+ 'curarrm': '\u293C',
+ 'curlyeqprec': '\u22DE',
+ 'curlyeqsucc': '\u22DF',
+ 'curren': '\u00A4',
+ 'curvearrowleft': '\u21B6',
+ 'curvearrowright': '\u21B7',
+ 'cuvee': '\u22CE',
+ 'cuwed': '\u22CF',
+ 'cwconint': '\u2232',
+ 'cwint': '\u2231',
+ 'cylcty': '\u232D'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/c.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/d.js b/js/mathjax/jax/input/MathML/entities/d.js
new file mode 100644
index 0000000..7dd0375
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/d.js
@@ -0,0 +1,114 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/d.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'DD': '\u2145',
+ 'DDotrahd': '\u2911',
+ 'DJcy': '\u0402',
+ 'DScy': '\u0405',
+ 'DZcy': '\u040F',
+ 'Darr': '\u21A1',
+ 'Dashv': '\u2AE4',
+ 'Dcaron': '\u010E',
+ 'Dcy': '\u0414',
+ 'DiacriticalAcute': '\u00B4',
+ 'DiacriticalDot': '\u02D9',
+ 'DiacriticalDoubleAcute': '\u02DD',
+ 'DiacriticalGrave': '\u0060',
+ 'DiacriticalTilde': '\u02DC',
+ 'Dot': '\u00A8',
+ 'DotDot': '\u20DC',
+ 'DoubleContourIntegral': '\u222F',
+ 'DoubleDownArrow': '\u21D3',
+ 'DoubleLeftArrow': '\u21D0',
+ 'DoubleLeftRightArrow': '\u21D4',
+ 'DoubleLeftTee': '\u2AE4',
+ 'DoubleLongLeftArrow': '\u27F8',
+ 'DoubleLongLeftRightArrow': '\u27FA',
+ 'DoubleLongRightArrow': '\u27F9',
+ 'DoubleRightArrow': '\u21D2',
+ 'DoubleUpArrow': '\u21D1',
+ 'DoubleUpDownArrow': '\u21D5',
+ 'DownArrowBar': '\u2913',
+ 'DownArrowUpArrow': '\u21F5',
+ 'DownBreve': '\u0311',
+ 'DownLeftRightVector': '\u2950',
+ 'DownLeftTeeVector': '\u295E',
+ 'DownLeftVectorBar': '\u2956',
+ 'DownRightTeeVector': '\u295F',
+ 'DownRightVectorBar': '\u2957',
+ 'DownTeeArrow': '\u21A7',
+ 'Dstrok': '\u0110',
+ 'dArr': '\u21D3',
+ 'dHar': '\u2965',
+ 'darr': '\u2193',
+ 'dash': '\u2010',
+ 'dashv': '\u22A3',
+ 'dbkarow': '\u290F',
+ 'dblac': '\u02DD',
+ 'dcaron': '\u010F',
+ 'dcy': '\u0434',
+ 'dd': '\u2146',
+ 'ddagger': '\u2021',
+ 'ddotseq': '\u2A77',
+ 'demptyv': '\u29B1',
+ 'dfisht': '\u297F',
+ 'dharl': '\u21C3',
+ 'dharr': '\u21C2',
+ 'diam': '\u22C4',
+ 'diamond': '\u22C4',
+ 'diamondsuit': '\u2666',
+ 'diams': '\u2666',
+ 'die': '\u00A8',
+ 'disin': '\u22F2',
+ 'divide': '\u00F7',
+ 'divonx': '\u22C7',
+ 'djcy': '\u0452',
+ 'dlcorn': '\u231E',
+ 'dlcrop': '\u230D',
+ 'dollar': '\u0024',
+ 'doteq': '\u2250',
+ 'dotminus': '\u2238',
+ 'doublebarwedge': '\u2306',
+ 'downarrow': '\u2193',
+ 'downdownarrows': '\u21CA',
+ 'downharpoonleft': '\u21C3',
+ 'downharpoonright': '\u21C2',
+ 'drbkarow': '\u2910',
+ 'drcorn': '\u231F',
+ 'drcrop': '\u230C',
+ 'dscy': '\u0455',
+ 'dsol': '\u29F6',
+ 'dstrok': '\u0111',
+ 'dtri': '\u25BF',
+ 'dtrif': '\u25BE',
+ 'duarr': '\u21F5',
+ 'duhar': '\u296F',
+ 'dwangle': '\u29A6',
+ 'dzcy': '\u045F',
+ 'dzigrarr': '\u27FF'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/d.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/e.js b/js/mathjax/jax/input/MathML/entities/e.js
new file mode 100644
index 0000000..215047d
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/e.js
@@ -0,0 +1,94 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/e.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'ENG': '\u014A',
+ 'ETH': '\u00D0',
+ 'Eacute': '\u00C9',
+ 'Ecaron': '\u011A',
+ 'Ecirc': '\u00CA',
+ 'Ecy': '\u042D',
+ 'Edot': '\u0116',
+ 'Egrave': '\u00C8',
+ 'Emacr': '\u0112',
+ 'EmptySmallSquare': '\u25FB',
+ 'EmptyVerySmallSquare': '\u25AB',
+ 'Eogon': '\u0118',
+ 'Epsilon': '\u0395',
+ 'Equal': '\u2A75',
+ 'Esim': '\u2A73',
+ 'Eta': '\u0397',
+ 'Euml': '\u00CB',
+ 'eDDot': '\u2A77',
+ 'eDot': '\u2251',
+ 'eacute': '\u00E9',
+ 'easter': '\u2A6E',
+ 'ecaron': '\u011B',
+ 'ecirc': '\u00EA',
+ 'ecolon': '\u2255',
+ 'ecy': '\u044D',
+ 'edot': '\u0117',
+ 'ee': '\u2147',
+ 'eg': '\u2A9A',
+ 'egrave': '\u00E8',
+ 'egsdot': '\u2A98',
+ 'el': '\u2A99',
+ 'elinters': '\u23E7',
+ 'elsdot': '\u2A97',
+ 'emacr': '\u0113',
+ 'emptyset': '\u2205',
+ 'emptyv': '\u2205',
+ 'emsp': '\u2003',
+ 'emsp13': '\u2004',
+ 'emsp14': '\u2005',
+ 'eng': '\u014B',
+ 'ensp': '\u2002',
+ 'eogon': '\u0119',
+ 'epar': '\u22D5',
+ 'eparsl': '\u29E3',
+ 'eplus': '\u2A71',
+ 'epsilon': '\u03B5',
+ 'eqcirc': '\u2256',
+ 'eqcolon': '\u2255',
+ 'eqsim': '\u2242',
+ 'eqslantgtr': '\u2A96',
+ 'eqslantless': '\u2A95',
+ 'equals': '\u003D',
+ 'equest': '\u225F',
+ 'equiv': '\u2261',
+ 'equivDD': '\u2A78',
+ 'eqvparsl': '\u29E5',
+ 'erarr': '\u2971',
+ 'esdot': '\u2250',
+ 'esim': '\u2242',
+ 'euml': '\u00EB',
+ 'euro': '\u20AC',
+ 'excl': '\u0021',
+ 'exist': '\u2203',
+ 'expectation': '\u2130',
+ 'exponentiale': '\u2147'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/e.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/f.js b/js/mathjax/jax/input/MathML/entities/f.js
new file mode 100644
index 0000000..5319a4e
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/f.js
@@ -0,0 +1,62 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/f.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Fcy': '\u0424',
+ 'FilledSmallSquare': '\u25FC',
+ 'Fouriertrf': '\u2131',
+ 'fallingdotseq': '\u2252',
+ 'fcy': '\u0444',
+ 'female': '\u2640',
+ 'ffilig': '\uFB03',
+ 'fflig': '\uFB00',
+ 'ffllig': '\uFB04',
+ 'filig': '\uFB01',
+ 'fjlig': '\u0066\u006A',
+ 'fllig': '\uFB02',
+ 'fltns': '\u25B1',
+ 'fnof': '\u0192',
+ 'forall': '\u2200',
+ 'forkv': '\u2AD9',
+ 'fpartint': '\u2A0D',
+ 'frac12': '\u00BD',
+ 'frac13': '\u2153',
+ 'frac14': '\u00BC',
+ 'frac15': '\u2155',
+ 'frac16': '\u2159',
+ 'frac18': '\u215B',
+ 'frac23': '\u2154',
+ 'frac25': '\u2156',
+ 'frac34': '\u00BE',
+ 'frac35': '\u2157',
+ 'frac38': '\u215C',
+ 'frac45': '\u2158',
+ 'frac56': '\u215A',
+ 'frac58': '\u215D',
+ 'frac78': '\u215E',
+ 'frasl': '\u2044'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/f.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/fr.js b/js/mathjax/jax/input/MathML/entities/fr.js
new file mode 100644
index 0000000..cf2aca7
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/fr.js
@@ -0,0 +1,81 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/fr.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Afr': '\uD835\uDD04',
+ 'Bfr': '\uD835\uDD05',
+ 'Cfr': '\u212D',
+ 'Dfr': '\uD835\uDD07',
+ 'Efr': '\uD835\uDD08',
+ 'Ffr': '\uD835\uDD09',
+ 'Gfr': '\uD835\uDD0A',
+ 'Hfr': '\u210C',
+ 'Ifr': '\u2111',
+ 'Jfr': '\uD835\uDD0D',
+ 'Kfr': '\uD835\uDD0E',
+ 'Lfr': '\uD835\uDD0F',
+ 'Mfr': '\uD835\uDD10',
+ 'Nfr': '\uD835\uDD11',
+ 'Ofr': '\uD835\uDD12',
+ 'Pfr': '\uD835\uDD13',
+ 'Qfr': '\uD835\uDD14',
+ 'Rfr': '\u211C',
+ 'Sfr': '\uD835\uDD16',
+ 'Tfr': '\uD835\uDD17',
+ 'Ufr': '\uD835\uDD18',
+ 'Vfr': '\uD835\uDD19',
+ 'Wfr': '\uD835\uDD1A',
+ 'Xfr': '\uD835\uDD1B',
+ 'Yfr': '\uD835\uDD1C',
+ 'Zfr': '\u2128',
+ 'afr': '\uD835\uDD1E',
+ 'bfr': '\uD835\uDD1F',
+ 'cfr': '\uD835\uDD20',
+ 'dfr': '\uD835\uDD21',
+ 'efr': '\uD835\uDD22',
+ 'ffr': '\uD835\uDD23',
+ 'gfr': '\uD835\uDD24',
+ 'hfr': '\uD835\uDD25',
+ 'ifr': '\uD835\uDD26',
+ 'jfr': '\uD835\uDD27',
+ 'kfr': '\uD835\uDD28',
+ 'lfr': '\uD835\uDD29',
+ 'mfr': '\uD835\uDD2A',
+ 'nfr': '\uD835\uDD2B',
+ 'ofr': '\uD835\uDD2C',
+ 'pfr': '\uD835\uDD2D',
+ 'qfr': '\uD835\uDD2E',
+ 'rfr': '\uD835\uDD2F',
+ 'sfr': '\uD835\uDD30',
+ 'tfr': '\uD835\uDD31',
+ 'ufr': '\uD835\uDD32',
+ 'vfr': '\uD835\uDD33',
+ 'wfr': '\uD835\uDD34',
+ 'xfr': '\uD835\uDD35',
+ 'yfr': '\uD835\uDD36',
+ 'zfr': '\uD835\uDD37'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/fr.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/g.js b/js/mathjax/jax/input/MathML/entities/g.js
new file mode 100644
index 0000000..8c3f003
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/g.js
@@ -0,0 +1,85 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/g.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'GJcy': '\u0403',
+ 'GT': '\u003E',
+ 'Gammad': '\u03DC',
+ 'Gbreve': '\u011E',
+ 'Gcedil': '\u0122',
+ 'Gcirc': '\u011C',
+ 'Gcy': '\u0413',
+ 'Gdot': '\u0120',
+ 'GreaterGreater': '\u2AA2',
+ 'Gt': '\u226B',
+ 'gE': '\u2267',
+ 'gacute': '\u01F5',
+ 'gammad': '\u03DD',
+ 'gbreve': '\u011F',
+ 'gcirc': '\u011D',
+ 'gcy': '\u0433',
+ 'gdot': '\u0121',
+ 'ge': '\u2265',
+ 'gel': '\u22DB',
+ 'geq': '\u2265',
+ 'geqq': '\u2267',
+ 'geqslant': '\u2A7E',
+ 'ges': '\u2A7E',
+ 'gescc': '\u2AA9',
+ 'gesdot': '\u2A80',
+ 'gesdoto': '\u2A82',
+ 'gesdotol': '\u2A84',
+ 'gesl': '\u22DB\uFE00',
+ 'gesles': '\u2A94',
+ 'gg': '\u226B',
+ 'ggg': '\u22D9',
+ 'gjcy': '\u0453',
+ 'gl': '\u2277',
+ 'glE': '\u2A92',
+ 'gla': '\u2AA5',
+ 'glj': '\u2AA4',
+ 'gnapprox': '\u2A8A',
+ 'gneq': '\u2A88',
+ 'gneqq': '\u2269',
+ 'grave': '\u0060',
+ 'gsim': '\u2273',
+ 'gsime': '\u2A8E',
+ 'gsiml': '\u2A90',
+ 'gtcc': '\u2AA7',
+ 'gtcir': '\u2A7A',
+ 'gtlPar': '\u2995',
+ 'gtquest': '\u2A7C',
+ 'gtrapprox': '\u2A86',
+ 'gtrarr': '\u2978',
+ 'gtrdot': '\u22D7',
+ 'gtreqless': '\u22DB',
+ 'gtreqqless': '\u2A8C',
+ 'gtrless': '\u2277',
+ 'gtrsim': '\u2273',
+ 'gvertneqq': '\u2269\uFE00',
+ 'gvnE': '\u2269\uFE00'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/g.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/h.js b/js/mathjax/jax/input/MathML/entities/h.js
new file mode 100644
index 0000000..1a22014
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/h.js
@@ -0,0 +1,54 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/h.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'HARDcy': '\u042A',
+ 'Hcirc': '\u0124',
+ 'HilbertSpace': '\u210B',
+ 'HorizontalLine': '\u2500',
+ 'Hstrok': '\u0126',
+ 'hArr': '\u21D4',
+ 'hairsp': '\u200A',
+ 'half': '\u00BD',
+ 'hamilt': '\u210B',
+ 'hardcy': '\u044A',
+ 'harr': '\u2194',
+ 'harrcir': '\u2948',
+ 'hcirc': '\u0125',
+ 'hearts': '\u2665',
+ 'heartsuit': '\u2665',
+ 'hercon': '\u22B9',
+ 'hksearow': '\u2925',
+ 'hkswarow': '\u2926',
+ 'hoarr': '\u21FF',
+ 'homtht': '\u223B',
+ 'horbar': '\u2015',
+ 'hslash': '\u210F',
+ 'hstrok': '\u0127',
+ 'hybull': '\u2043',
+ 'hyphen': '\u2010'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/h.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/i.js b/js/mathjax/jax/input/MathML/entities/i.js
new file mode 100644
index 0000000..3ee68f4
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/i.js
@@ -0,0 +1,88 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/i.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'IEcy': '\u0415',
+ 'IJlig': '\u0132',
+ 'IOcy': '\u0401',
+ 'Iacute': '\u00CD',
+ 'Icirc': '\u00CE',
+ 'Icy': '\u0418',
+ 'Idot': '\u0130',
+ 'Igrave': '\u00CC',
+ 'Imacr': '\u012A',
+ 'Implies': '\u21D2',
+ 'Int': '\u222C',
+ 'Iogon': '\u012E',
+ 'Iota': '\u0399',
+ 'Itilde': '\u0128',
+ 'Iukcy': '\u0406',
+ 'Iuml': '\u00CF',
+ 'iacute': '\u00ED',
+ 'ic': '\u2063',
+ 'icirc': '\u00EE',
+ 'icy': '\u0438',
+ 'iecy': '\u0435',
+ 'iexcl': '\u00A1',
+ 'iff': '\u21D4',
+ 'igrave': '\u00EC',
+ 'ii': '\u2148',
+ 'iiiint': '\u2A0C',
+ 'iiint': '\u222D',
+ 'iinfin': '\u29DC',
+ 'iiota': '\u2129',
+ 'ijlig': '\u0133',
+ 'imacr': '\u012B',
+ 'image': '\u2111',
+ 'imagline': '\u2110',
+ 'imagpart': '\u2111',
+ 'imof': '\u22B7',
+ 'imped': '\u01B5',
+ 'in': '\u2208',
+ 'incare': '\u2105',
+ 'infintie': '\u29DD',
+ 'inodot': '\u0131',
+ 'int': '\u222B',
+ 'integers': '\u2124',
+ 'intercal': '\u22BA',
+ 'intlarhk': '\u2A17',
+ 'intprod': '\u2A3C',
+ 'iocy': '\u0451',
+ 'iogon': '\u012F',
+ 'iprod': '\u2A3C',
+ 'iquest': '\u00BF',
+ 'isin': '\u2208',
+ 'isinE': '\u22F9',
+ 'isindot': '\u22F5',
+ 'isins': '\u22F4',
+ 'isinsv': '\u22F3',
+ 'isinv': '\u2208',
+ 'it': '\u2062',
+ 'itilde': '\u0129',
+ 'iukcy': '\u0456',
+ 'iuml': '\u00EF'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/i.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/j.js b/js/mathjax/jax/input/MathML/entities/j.js
new file mode 100644
index 0000000..cea0ee9
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/j.js
@@ -0,0 +1,37 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/j.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Jcirc': '\u0134',
+ 'Jcy': '\u0419',
+ 'Jsercy': '\u0408',
+ 'Jukcy': '\u0404',
+ 'jcirc': '\u0135',
+ 'jcy': '\u0439',
+ 'jsercy': '\u0458',
+ 'jukcy': '\u0454'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/j.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/k.js b/js/mathjax/jax/input/MathML/entities/k.js
new file mode 100644
index 0000000..2bb63b3
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/k.js
@@ -0,0 +1,39 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/k.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'KHcy': '\u0425',
+ 'KJcy': '\u040C',
+ 'Kappa': '\u039A',
+ 'Kcedil': '\u0136',
+ 'Kcy': '\u041A',
+ 'kcedil': '\u0137',
+ 'kcy': '\u043A',
+ 'kgreen': '\u0138',
+ 'khcy': '\u0445',
+ 'kjcy': '\u045C'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/k.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/l.js b/js/mathjax/jax/input/MathML/entities/l.js
new file mode 100644
index 0000000..9136ea5
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/l.js
@@ -0,0 +1,181 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/l.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'LJcy': '\u0409',
+ 'LT': '\u003C',
+ 'Lacute': '\u0139',
+ 'Lang': '\u27EA',
+ 'Laplacetrf': '\u2112',
+ 'Lcaron': '\u013D',
+ 'Lcedil': '\u013B',
+ 'Lcy': '\u041B',
+ 'LeftArrowBar': '\u21E4',
+ 'LeftDoubleBracket': '\u27E6',
+ 'LeftDownTeeVector': '\u2961',
+ 'LeftDownVectorBar': '\u2959',
+ 'LeftRightVector': '\u294E',
+ 'LeftTeeArrow': '\u21A4',
+ 'LeftTeeVector': '\u295A',
+ 'LeftTriangleBar': '\u29CF',
+ 'LeftUpDownVector': '\u2951',
+ 'LeftUpTeeVector': '\u2960',
+ 'LeftUpVectorBar': '\u2958',
+ 'LeftVectorBar': '\u2952',
+ 'LessLess': '\u2AA1',
+ 'Lmidot': '\u013F',
+ 'LowerLeftArrow': '\u2199',
+ 'LowerRightArrow': '\u2198',
+ 'Lstrok': '\u0141',
+ 'Lt': '\u226A',
+ 'lAarr': '\u21DA',
+ 'lArr': '\u21D0',
+ 'lAtail': '\u291B',
+ 'lBarr': '\u290E',
+ 'lE': '\u2266',
+ 'lHar': '\u2962',
+ 'lacute': '\u013A',
+ 'laemptyv': '\u29B4',
+ 'lagran': '\u2112',
+ 'lang': '\u27E8',
+ 'langd': '\u2991',
+ 'langle': '\u27E8',
+ 'laquo': '\u00AB',
+ 'larr': '\u2190',
+ 'larrb': '\u21E4',
+ 'larrbfs': '\u291F',
+ 'larrfs': '\u291D',
+ 'larrhk': '\u21A9',
+ 'larrpl': '\u2939',
+ 'larrsim': '\u2973',
+ 'lat': '\u2AAB',
+ 'latail': '\u2919',
+ 'late': '\u2AAD',
+ 'lates': '\u2AAD\uFE00',
+ 'lbarr': '\u290C',
+ 'lbbrk': '\u2772',
+ 'lbrke': '\u298B',
+ 'lbrksld': '\u298F',
+ 'lbrkslu': '\u298D',
+ 'lcaron': '\u013E',
+ 'lcedil': '\u013C',
+ 'lceil': '\u2308',
+ 'lcub': '\u007B',
+ 'lcy': '\u043B',
+ 'ldca': '\u2936',
+ 'ldquo': '\u201C',
+ 'ldquor': '\u201E',
+ 'ldrdhar': '\u2967',
+ 'ldrushar': '\u294B',
+ 'ldsh': '\u21B2',
+ 'leftarrow': '\u2190',
+ 'leftarrowtail': '\u21A2',
+ 'leftharpoondown': '\u21BD',
+ 'leftharpoonup': '\u21BC',
+ 'leftrightarrow': '\u2194',
+ 'leftrightarrows': '\u21C6',
+ 'leftrightharpoons': '\u21CB',
+ 'leftrightsquigarrow': '\u21AD',
+ 'leg': '\u22DA',
+ 'leq': '\u2264',
+ 'leqq': '\u2266',
+ 'leqslant': '\u2A7D',
+ 'les': '\u2A7D',
+ 'lescc': '\u2AA8',
+ 'lesdot': '\u2A7F',
+ 'lesdoto': '\u2A81',
+ 'lesdotor': '\u2A83',
+ 'lesg': '\u22DA\uFE00',
+ 'lesges': '\u2A93',
+ 'lessapprox': '\u2A85',
+ 'lesseqgtr': '\u22DA',
+ 'lesseqqgtr': '\u2A8B',
+ 'lessgtr': '\u2276',
+ 'lesssim': '\u2272',
+ 'lfisht': '\u297C',
+ 'lfloor': '\u230A',
+ 'lg': '\u2276',
+ 'lgE': '\u2A91',
+ 'lhard': '\u21BD',
+ 'lharu': '\u21BC',
+ 'lharul': '\u296A',
+ 'lhblk': '\u2584',
+ 'ljcy': '\u0459',
+ 'll': '\u226A',
+ 'llarr': '\u21C7',
+ 'llcorner': '\u231E',
+ 'llhard': '\u296B',
+ 'lltri': '\u25FA',
+ 'lmidot': '\u0140',
+ 'lmoustache': '\u23B0',
+ 'lnapprox': '\u2A89',
+ 'lneq': '\u2A87',
+ 'lneqq': '\u2268',
+ 'loang': '\u27EC',
+ 'loarr': '\u21FD',
+ 'lobrk': '\u27E6',
+ 'longleftarrow': '\u27F5',
+ 'longleftrightarrow': '\u27F7',
+ 'longrightarrow': '\u27F6',
+ 'looparrowleft': '\u21AB',
+ 'lopar': '\u2985',
+ 'loplus': '\u2A2D',
+ 'lotimes': '\u2A34',
+ 'lowbar': '\u005F',
+ 'lozenge': '\u25CA',
+ 'lozf': '\u29EB',
+ 'lpar': '\u0028',
+ 'lparlt': '\u2993',
+ 'lrarr': '\u21C6',
+ 'lrcorner': '\u231F',
+ 'lrhar': '\u21CB',
+ 'lrhard': '\u296D',
+ 'lrm': '\u200E',
+ 'lrtri': '\u22BF',
+ 'lsaquo': '\u2039',
+ 'lsh': '\u21B0',
+ 'lsim': '\u2272',
+ 'lsime': '\u2A8D',
+ 'lsimg': '\u2A8F',
+ 'lsqb': '\u005B',
+ 'lsquo': '\u2018',
+ 'lsquor': '\u201A',
+ 'lstrok': '\u0142',
+ 'ltcc': '\u2AA6',
+ 'ltcir': '\u2A79',
+ 'ltdot': '\u22D6',
+ 'lthree': '\u22CB',
+ 'ltlarr': '\u2976',
+ 'ltquest': '\u2A7B',
+ 'ltrPar': '\u2996',
+ 'ltrie': '\u22B4',
+ 'ltrif': '\u25C2',
+ 'lurdshar': '\u294A',
+ 'luruhar': '\u2966',
+ 'lvertneqq': '\u2268\uFE00',
+ 'lvnE': '\u2268\uFE00'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/l.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/m.js b/js/mathjax/jax/input/MathML/entities/m.js
new file mode 100644
index 0000000..823a6a2
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/m.js
@@ -0,0 +1,63 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/m.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Map': '\u2905',
+ 'Mcy': '\u041C',
+ 'MediumSpace': '\u205F',
+ 'Mellintrf': '\u2133',
+ 'Mu': '\u039C',
+ 'mDDot': '\u223A',
+ 'male': '\u2642',
+ 'maltese': '\u2720',
+ 'map': '\u21A6',
+ 'mapsto': '\u21A6',
+ 'mapstodown': '\u21A7',
+ 'mapstoleft': '\u21A4',
+ 'mapstoup': '\u21A5',
+ 'marker': '\u25AE',
+ 'mcomma': '\u2A29',
+ 'mcy': '\u043C',
+ 'mdash': '\u2014',
+ 'measuredangle': '\u2221',
+ 'micro': '\u00B5',
+ 'mid': '\u2223',
+ 'midast': '\u002A',
+ 'midcir': '\u2AF0',
+ 'middot': '\u00B7',
+ 'minus': '\u2212',
+ 'minusb': '\u229F',
+ 'minusd': '\u2238',
+ 'minusdu': '\u2A2A',
+ 'mlcp': '\u2ADB',
+ 'mldr': '\u2026',
+ 'mnplus': '\u2213',
+ 'models': '\u22A7',
+ 'mp': '\u2213',
+ 'mstpos': '\u223E',
+ 'mumap': '\u22B8'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/m.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/n.js b/js/mathjax/jax/input/MathML/entities/n.js
new file mode 100644
index 0000000..491daf5
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/n.js
@@ -0,0 +1,222 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/n.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'NJcy': '\u040A',
+ 'Nacute': '\u0143',
+ 'Ncaron': '\u0147',
+ 'Ncedil': '\u0145',
+ 'Ncy': '\u041D',
+ 'NegativeMediumSpace': '\u200B',
+ 'NegativeThickSpace': '\u200B',
+ 'NegativeThinSpace': '\u200B',
+ 'NegativeVeryThinSpace': '\u200B',
+ 'NewLine': '\u000A',
+ 'NoBreak': '\u2060',
+ 'NonBreakingSpace': '\u00A0',
+ 'Not': '\u2AEC',
+ 'NotCongruent': '\u2262',
+ 'NotCupCap': '\u226D',
+ 'NotEqualTilde': '\u2242\u0338',
+ 'NotGreaterFullEqual': '\u2267\u0338',
+ 'NotGreaterGreater': '\u226B\u0338',
+ 'NotGreaterLess': '\u2279',
+ 'NotGreaterSlantEqual': '\u2A7E\u0338',
+ 'NotGreaterTilde': '\u2275',
+ 'NotHumpDownHump': '\u224E\u0338',
+ 'NotHumpEqual': '\u224F\u0338',
+ 'NotLeftTriangleBar': '\u29CF\u0338',
+ 'NotLessGreater': '\u2278',
+ 'NotLessLess': '\u226A\u0338',
+ 'NotLessSlantEqual': '\u2A7D\u0338',
+ 'NotLessTilde': '\u2274',
+ 'NotNestedGreaterGreater': '\u2AA2\u0338',
+ 'NotNestedLessLess': '\u2AA1\u0338',
+ 'NotPrecedesEqual': '\u2AAF\u0338',
+ 'NotReverseElement': '\u220C',
+ 'NotRightTriangleBar': '\u29D0\u0338',
+ 'NotSquareSubset': '\u228F\u0338',
+ 'NotSquareSubsetEqual': '\u22E2',
+ 'NotSquareSuperset': '\u2290\u0338',
+ 'NotSquareSupersetEqual': '\u22E3',
+ 'NotSubset': '\u2282\u20D2',
+ 'NotSucceedsEqual': '\u2AB0\u0338',
+ 'NotSucceedsTilde': '\u227F\u0338',
+ 'NotSuperset': '\u2283\u20D2',
+ 'NotTildeEqual': '\u2244',
+ 'NotTildeFullEqual': '\u2247',
+ 'NotTildeTilde': '\u2249',
+ 'Ntilde': '\u00D1',
+ 'Nu': '\u039D',
+ 'nGg': '\u22D9\u0338',
+ 'nGt': '\u226B\u20D2',
+ 'nGtv': '\u226B\u0338',
+ 'nLl': '\u22D8\u0338',
+ 'nLt': '\u226A\u20D2',
+ 'nLtv': '\u226A\u0338',
+ 'nabla': '\u2207',
+ 'nacute': '\u0144',
+ 'nang': '\u2220\u20D2',
+ 'nap': '\u2249',
+ 'napE': '\u2A70\u0338',
+ 'napid': '\u224B\u0338',
+ 'napos': '\u0149',
+ 'napprox': '\u2249',
+ 'natural': '\u266E',
+ 'naturals': '\u2115',
+ 'nbsp': '\u00A0',
+ 'nbump': '\u224E\u0338',
+ 'nbumpe': '\u224F\u0338',
+ 'ncap': '\u2A43',
+ 'ncaron': '\u0148',
+ 'ncedil': '\u0146',
+ 'ncong': '\u2247',
+ 'ncongdot': '\u2A6D\u0338',
+ 'ncup': '\u2A42',
+ 'ncy': '\u043D',
+ 'ndash': '\u2013',
+ 'ne': '\u2260',
+ 'neArr': '\u21D7',
+ 'nearhk': '\u2924',
+ 'nearrow': '\u2197',
+ 'nedot': '\u2250\u0338',
+ 'nequiv': '\u2262',
+ 'nesear': '\u2928',
+ 'nesim': '\u2242\u0338',
+ 'nexist': '\u2204',
+ 'nexists': '\u2204',
+ 'ngE': '\u2267\u0338',
+ 'nge': '\u2271',
+ 'ngeq': '\u2271',
+ 'ngeqq': '\u2267\u0338',
+ 'ngeqslant': '\u2A7E\u0338',
+ 'nges': '\u2A7E\u0338',
+ 'ngsim': '\u2275',
+ 'ngt': '\u226F',
+ 'ngtr': '\u226F',
+ 'nhArr': '\u21CE',
+ 'nhpar': '\u2AF2',
+ 'ni': '\u220B',
+ 'nis': '\u22FC',
+ 'nisd': '\u22FA',
+ 'niv': '\u220B',
+ 'njcy': '\u045A',
+ 'nlArr': '\u21CD',
+ 'nlE': '\u2266\u0338',
+ 'nldr': '\u2025',
+ 'nle': '\u2270',
+ 'nleftarrow': '\u219A',
+ 'nleftrightarrow': '\u21AE',
+ 'nleq': '\u2270',
+ 'nleqq': '\u2266\u0338',
+ 'nleqslant': '\u2A7D\u0338',
+ 'nles': '\u2A7D\u0338',
+ 'nless': '\u226E',
+ 'nlsim': '\u2274',
+ 'nlt': '\u226E',
+ 'nltri': '\u22EA',
+ 'nltrie': '\u22EC',
+ 'nmid': '\u2224',
+ 'notin': '\u2209',
+ 'notinE': '\u22F9\u0338',
+ 'notindot': '\u22F5\u0338',
+ 'notinva': '\u2209',
+ 'notinvb': '\u22F7',
+ 'notinvc': '\u22F6',
+ 'notni': '\u220C',
+ 'notniva': '\u220C',
+ 'notnivb': '\u22FE',
+ 'notnivc': '\u22FD',
+ 'npar': '\u2226',
+ 'nparallel': '\u2226',
+ 'nparsl': '\u2AFD\u20E5',
+ 'npart': '\u2202\u0338',
+ 'npolint': '\u2A14',
+ 'npr': '\u2280',
+ 'nprcue': '\u22E0',
+ 'npre': '\u2AAF\u0338',
+ 'nprec': '\u2280',
+ 'npreceq': '\u2AAF\u0338',
+ 'nrArr': '\u21CF',
+ 'nrarrc': '\u2933\u0338',
+ 'nrarrw': '\u219D\u0338',
+ 'nrightarrow': '\u219B',
+ 'nrtri': '\u22EB',
+ 'nrtrie': '\u22ED',
+ 'nsc': '\u2281',
+ 'nsccue': '\u22E1',
+ 'nsce': '\u2AB0\u0338',
+ 'nshortmid': '\u2224',
+ 'nshortparallel': '\u2226',
+ 'nsim': '\u2241',
+ 'nsime': '\u2244',
+ 'nsimeq': '\u2244',
+ 'nsmid': '\u2224',
+ 'nspar': '\u2226',
+ 'nsqsube': '\u22E2',
+ 'nsqsupe': '\u22E3',
+ 'nsub': '\u2284',
+ 'nsubE': '\u2AC5\u0338',
+ 'nsube': '\u2288',
+ 'nsubset': '\u2282\u20D2',
+ 'nsubseteq': '\u2288',
+ 'nsubseteqq': '\u2AC5\u0338',
+ 'nsucc': '\u2281',
+ 'nsucceq': '\u2AB0\u0338',
+ 'nsup': '\u2285',
+ 'nsupE': '\u2AC6\u0338',
+ 'nsupe': '\u2289',
+ 'nsupset': '\u2283\u20D2',
+ 'nsupseteq': '\u2289',
+ 'nsupseteqq': '\u2AC6\u0338',
+ 'ntgl': '\u2279',
+ 'ntilde': '\u00F1',
+ 'ntlg': '\u2278',
+ 'ntriangleleft': '\u22EA',
+ 'ntrianglelefteq': '\u22EC',
+ 'ntriangleright': '\u22EB',
+ 'ntrianglerighteq': '\u22ED',
+ 'num': '\u0023',
+ 'numero': '\u2116',
+ 'numsp': '\u2007',
+ 'nvHarr': '\u2904',
+ 'nvap': '\u224D\u20D2',
+ 'nvge': '\u2265\u20D2',
+ 'nvgt': '\u003E\u20D2',
+ 'nvinfin': '\u29DE',
+ 'nvlArr': '\u2902',
+ 'nvle': '\u2264\u20D2',
+ 'nvlt': '\u003C\u20D2',
+ 'nvltrie': '\u22B4\u20D2',
+ 'nvrArr': '\u2903',
+ 'nvrtrie': '\u22B5\u20D2',
+ 'nvsim': '\u223C\u20D2',
+ 'nwArr': '\u21D6',
+ 'nwarhk': '\u2923',
+ 'nwarrow': '\u2196',
+ 'nwnear': '\u2927'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/n.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/o.js b/js/mathjax/jax/input/MathML/entities/o.js
new file mode 100644
index 0000000..5017e8e
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/o.js
@@ -0,0 +1,92 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/o.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'OElig': '\u0152',
+ 'Oacute': '\u00D3',
+ 'Ocirc': '\u00D4',
+ 'Ocy': '\u041E',
+ 'Odblac': '\u0150',
+ 'Ograve': '\u00D2',
+ 'Omacr': '\u014C',
+ 'Omicron': '\u039F',
+ 'OpenCurlyDoubleQuote': '\u201C',
+ 'OpenCurlyQuote': '\u2018',
+ 'Or': '\u2A54',
+ 'Oslash': '\u00D8',
+ 'Otilde': '\u00D5',
+ 'Otimes': '\u2A37',
+ 'Ouml': '\u00D6',
+ 'OverBracket': '\u23B4',
+ 'OverParenthesis': '\u23DC',
+ 'oS': '\u24C8',
+ 'oacute': '\u00F3',
+ 'oast': '\u229B',
+ 'ocir': '\u229A',
+ 'ocirc': '\u00F4',
+ 'ocy': '\u043E',
+ 'odash': '\u229D',
+ 'odblac': '\u0151',
+ 'odiv': '\u2A38',
+ 'odot': '\u2299',
+ 'odsold': '\u29BC',
+ 'oelig': '\u0153',
+ 'ofcir': '\u29BF',
+ 'ogon': '\u02DB',
+ 'ograve': '\u00F2',
+ 'ogt': '\u29C1',
+ 'ohbar': '\u29B5',
+ 'ohm': '\u03A9',
+ 'oint': '\u222E',
+ 'olarr': '\u21BA',
+ 'olcir': '\u29BE',
+ 'olcross': '\u29BB',
+ 'oline': '\u203E',
+ 'olt': '\u29C0',
+ 'omacr': '\u014D',
+ 'omid': '\u29B6',
+ 'ominus': '\u2296',
+ 'opar': '\u29B7',
+ 'operp': '\u29B9',
+ 'oplus': '\u2295',
+ 'orarr': '\u21BB',
+ 'ord': '\u2A5D',
+ 'order': '\u2134',
+ 'orderof': '\u2134',
+ 'ordf': '\u00AA',
+ 'ordm': '\u00BA',
+ 'origof': '\u22B6',
+ 'oror': '\u2A56',
+ 'orslope': '\u2A57',
+ 'orv': '\u2A5B',
+ 'oslash': '\u00F8',
+ 'otilde': '\u00F5',
+ 'otimes': '\u2297',
+ 'otimesas': '\u2A36',
+ 'ouml': '\u00F6',
+ 'ovbar': '\u233D'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/o.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/opf.js b/js/mathjax/jax/input/MathML/entities/opf.js
new file mode 100644
index 0000000..8085482
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/opf.js
@@ -0,0 +1,81 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/opf.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Aopf': '\uD835\uDD38',
+ 'Bopf': '\uD835\uDD39',
+ 'Copf': '\u2102',
+ 'Dopf': '\uD835\uDD3B',
+ 'Eopf': '\uD835\uDD3C',
+ 'Fopf': '\uD835\uDD3D',
+ 'Gopf': '\uD835\uDD3E',
+ 'Hopf': '\u210D',
+ 'Iopf': '\uD835\uDD40',
+ 'Jopf': '\uD835\uDD41',
+ 'Kopf': '\uD835\uDD42',
+ 'Lopf': '\uD835\uDD43',
+ 'Mopf': '\uD835\uDD44',
+ 'Nopf': '\u2115',
+ 'Oopf': '\uD835\uDD46',
+ 'Popf': '\u2119',
+ 'Qopf': '\u211A',
+ 'Ropf': '\u211D',
+ 'Sopf': '\uD835\uDD4A',
+ 'Topf': '\uD835\uDD4B',
+ 'Uopf': '\uD835\uDD4C',
+ 'Vopf': '\uD835\uDD4D',
+ 'Wopf': '\uD835\uDD4E',
+ 'Xopf': '\uD835\uDD4F',
+ 'Yopf': '\uD835\uDD50',
+ 'Zopf': '\u2124',
+ 'aopf': '\uD835\uDD52',
+ 'bopf': '\uD835\uDD53',
+ 'copf': '\uD835\uDD54',
+ 'dopf': '\uD835\uDD55',
+ 'eopf': '\uD835\uDD56',
+ 'fopf': '\uD835\uDD57',
+ 'gopf': '\uD835\uDD58',
+ 'hopf': '\uD835\uDD59',
+ 'iopf': '\uD835\uDD5A',
+ 'jopf': '\uD835\uDD5B',
+ 'kopf': '\uD835\uDD5C',
+ 'lopf': '\uD835\uDD5D',
+ 'mopf': '\uD835\uDD5E',
+ 'nopf': '\uD835\uDD5F',
+ 'oopf': '\uD835\uDD60',
+ 'popf': '\uD835\uDD61',
+ 'qopf': '\uD835\uDD62',
+ 'ropf': '\uD835\uDD63',
+ 'sopf': '\uD835\uDD64',
+ 'topf': '\uD835\uDD65',
+ 'uopf': '\uD835\uDD66',
+ 'vopf': '\uD835\uDD67',
+ 'wopf': '\uD835\uDD68',
+ 'xopf': '\uD835\uDD69',
+ 'yopf': '\uD835\uDD6A',
+ 'zopf': '\uD835\uDD6B'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/opf.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/p.js b/js/mathjax/jax/input/MathML/entities/p.js
new file mode 100644
index 0000000..41870fe
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/p.js
@@ -0,0 +1,86 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/p.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Pcy': '\u041F',
+ 'Poincareplane': '\u210C',
+ 'Pr': '\u2ABB',
+ 'Prime': '\u2033',
+ 'Proportion': '\u2237',
+ 'par': '\u2225',
+ 'para': '\u00B6',
+ 'parallel': '\u2225',
+ 'parsim': '\u2AF3',
+ 'parsl': '\u2AFD',
+ 'part': '\u2202',
+ 'pcy': '\u043F',
+ 'percnt': '\u0025',
+ 'permil': '\u2030',
+ 'perp': '\u22A5',
+ 'pertenk': '\u2031',
+ 'phmmat': '\u2133',
+ 'phone': '\u260E',
+ 'pitchfork': '\u22D4',
+ 'planck': '\u210F',
+ 'planckh': '\u210E',
+ 'plankv': '\u210F',
+ 'plus': '\u002B',
+ 'plusacir': '\u2A23',
+ 'plusb': '\u229E',
+ 'pluscir': '\u2A22',
+ 'plusdo': '\u2214',
+ 'plusdu': '\u2A25',
+ 'pluse': '\u2A72',
+ 'plusmn': '\u00B1',
+ 'plussim': '\u2A26',
+ 'plustwo': '\u2A27',
+ 'pm': '\u00B1',
+ 'pointint': '\u2A15',
+ 'pound': '\u00A3',
+ 'pr': '\u227A',
+ 'prE': '\u2AB3',
+ 'prcue': '\u227C',
+ 'pre': '\u2AAF',
+ 'prec': '\u227A',
+ 'precapprox': '\u2AB7',
+ 'preccurlyeq': '\u227C',
+ 'preceq': '\u2AAF',
+ 'precsim': '\u227E',
+ 'primes': '\u2119',
+ 'prnE': '\u2AB5',
+ 'prnap': '\u2AB9',
+ 'prnsim': '\u22E8',
+ 'prod': '\u220F',
+ 'profalar': '\u232E',
+ 'profline': '\u2312',
+ 'profsurf': '\u2313',
+ 'prop': '\u221D',
+ 'propto': '\u221D',
+ 'prsim': '\u227E',
+ 'prurel': '\u22B0',
+ 'puncsp': '\u2008'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/p.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/q.js b/js/mathjax/jax/input/MathML/entities/q.js
new file mode 100644
index 0000000..c900aa4
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/q.js
@@ -0,0 +1,37 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/q.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'QUOT': '\u0022',
+ 'qint': '\u2A0C',
+ 'qprime': '\u2057',
+ 'quaternions': '\u210D',
+ 'quatint': '\u2A16',
+ 'quest': '\u003F',
+ 'questeq': '\u225F',
+ 'quot': '\u0022'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/q.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/r.js b/js/mathjax/jax/input/MathML/entities/r.js
new file mode 100644
index 0000000..92129bf
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/r.js
@@ -0,0 +1,140 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/r.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'RBarr': '\u2910',
+ 'REG': '\u00AE',
+ 'Racute': '\u0154',
+ 'Rang': '\u27EB',
+ 'Rarrtl': '\u2916',
+ 'Rcaron': '\u0158',
+ 'Rcedil': '\u0156',
+ 'Rcy': '\u0420',
+ 'ReverseElement': '\u220B',
+ 'ReverseUpEquilibrium': '\u296F',
+ 'Rho': '\u03A1',
+ 'RightArrowBar': '\u21E5',
+ 'RightDoubleBracket': '\u27E7',
+ 'RightDownTeeVector': '\u295D',
+ 'RightDownVectorBar': '\u2955',
+ 'RightTeeVector': '\u295B',
+ 'RightTriangleBar': '\u29D0',
+ 'RightUpDownVector': '\u294F',
+ 'RightUpTeeVector': '\u295C',
+ 'RightUpVectorBar': '\u2954',
+ 'RightVectorBar': '\u2953',
+ 'RoundImplies': '\u2970',
+ 'RuleDelayed': '\u29F4',
+ 'rAarr': '\u21DB',
+ 'rArr': '\u21D2',
+ 'rAtail': '\u291C',
+ 'rBarr': '\u290F',
+ 'rHar': '\u2964',
+ 'race': '\u223D\u0331',
+ 'racute': '\u0155',
+ 'radic': '\u221A',
+ 'raemptyv': '\u29B3',
+ 'rang': '\u27E9',
+ 'rangd': '\u2992',
+ 'range': '\u29A5',
+ 'rangle': '\u27E9',
+ 'raquo': '\u00BB',
+ 'rarr': '\u2192',
+ 'rarrap': '\u2975',
+ 'rarrb': '\u21E5',
+ 'rarrbfs': '\u2920',
+ 'rarrc': '\u2933',
+ 'rarrfs': '\u291E',
+ 'rarrhk': '\u21AA',
+ 'rarrlp': '\u21AC',
+ 'rarrpl': '\u2945',
+ 'rarrsim': '\u2974',
+ 'rarrw': '\u219D',
+ 'ratail': '\u291A',
+ 'ratio': '\u2236',
+ 'rationals': '\u211A',
+ 'rbarr': '\u290D',
+ 'rbbrk': '\u2773',
+ 'rbrke': '\u298C',
+ 'rbrksld': '\u298E',
+ 'rbrkslu': '\u2990',
+ 'rcaron': '\u0159',
+ 'rcedil': '\u0157',
+ 'rceil': '\u2309',
+ 'rcub': '\u007D',
+ 'rcy': '\u0440',
+ 'rdca': '\u2937',
+ 'rdldhar': '\u2969',
+ 'rdquo': '\u201D',
+ 'rdquor': '\u201D',
+ 'rdsh': '\u21B3',
+ 'real': '\u211C',
+ 'realine': '\u211B',
+ 'realpart': '\u211C',
+ 'reals': '\u211D',
+ 'rect': '\u25AD',
+ 'reg': '\u00AE',
+ 'rfisht': '\u297D',
+ 'rfloor': '\u230B',
+ 'rhard': '\u21C1',
+ 'rharu': '\u21C0',
+ 'rharul': '\u296C',
+ 'rightarrow': '\u2192',
+ 'rightarrowtail': '\u21A3',
+ 'rightharpoondown': '\u21C1',
+ 'rightharpoonup': '\u21C0',
+ 'rightleftarrows': '\u21C4',
+ 'rightleftharpoons': '\u21CC',
+ 'rightsquigarrow': '\u219D',
+ 'risingdotseq': '\u2253',
+ 'rlarr': '\u21C4',
+ 'rlhar': '\u21CC',
+ 'rlm': '\u200F',
+ 'rmoustache': '\u23B1',
+ 'rnmid': '\u2AEE',
+ 'roang': '\u27ED',
+ 'roarr': '\u21FE',
+ 'robrk': '\u27E7',
+ 'ropar': '\u2986',
+ 'roplus': '\u2A2E',
+ 'rotimes': '\u2A35',
+ 'rpar': '\u0029',
+ 'rpargt': '\u2994',
+ 'rppolint': '\u2A12',
+ 'rrarr': '\u21C9',
+ 'rsaquo': '\u203A',
+ 'rsh': '\u21B1',
+ 'rsqb': '\u005D',
+ 'rsquo': '\u2019',
+ 'rsquor': '\u2019',
+ 'rthree': '\u22CC',
+ 'rtrie': '\u22B5',
+ 'rtrif': '\u25B8',
+ 'rtriltri': '\u29CE',
+ 'ruluhar': '\u2968',
+ 'rx': '\u211E'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/r.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/s.js b/js/mathjax/jax/input/MathML/entities/s.js
new file mode 100644
index 0000000..181d853
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/s.js
@@ -0,0 +1,172 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/s.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'SHCHcy': '\u0429',
+ 'SHcy': '\u0428',
+ 'SOFTcy': '\u042C',
+ 'Sacute': '\u015A',
+ 'Sc': '\u2ABC',
+ 'Scaron': '\u0160',
+ 'Scedil': '\u015E',
+ 'Scirc': '\u015C',
+ 'Scy': '\u0421',
+ 'ShortDownArrow': '\u2193',
+ 'ShortLeftArrow': '\u2190',
+ 'ShortRightArrow': '\u2192',
+ 'ShortUpArrow': '\u2191',
+ 'Sub': '\u22D0',
+ 'Sup': '\u22D1',
+ 'sacute': '\u015B',
+ 'sbquo': '\u201A',
+ 'sc': '\u227B',
+ 'scE': '\u2AB4',
+ 'scaron': '\u0161',
+ 'sccue': '\u227D',
+ 'sce': '\u2AB0',
+ 'scedil': '\u015F',
+ 'scirc': '\u015D',
+ 'scpolint': '\u2A13',
+ 'scsim': '\u227F',
+ 'scy': '\u0441',
+ 'sdotb': '\u22A1',
+ 'sdote': '\u2A66',
+ 'seArr': '\u21D8',
+ 'searhk': '\u2925',
+ 'searrow': '\u2198',
+ 'semi': '\u003B',
+ 'seswar': '\u2929',
+ 'setminus': '\u2216',
+ 'setmn': '\u2216',
+ 'sext': '\u2736',
+ 'sfrown': '\u2322',
+ 'shchcy': '\u0449',
+ 'shcy': '\u0448',
+ 'shortmid': '\u2223',
+ 'shortparallel': '\u2225',
+ 'shy': '\u00AD',
+ 'sigmaf': '\u03C2',
+ 'sim': '\u223C',
+ 'simdot': '\u2A6A',
+ 'sime': '\u2243',
+ 'simeq': '\u2243',
+ 'simg': '\u2A9E',
+ 'simgE': '\u2AA0',
+ 'siml': '\u2A9D',
+ 'simlE': '\u2A9F',
+ 'simplus': '\u2A24',
+ 'simrarr': '\u2972',
+ 'slarr': '\u2190',
+ 'smallsetminus': '\u2216',
+ 'smashp': '\u2A33',
+ 'smeparsl': '\u29E4',
+ 'smid': '\u2223',
+ 'smt': '\u2AAA',
+ 'smte': '\u2AAC',
+ 'smtes': '\u2AAC\uFE00',
+ 'softcy': '\u044C',
+ 'sol': '\u002F',
+ 'solb': '\u29C4',
+ 'solbar': '\u233F',
+ 'spadesuit': '\u2660',
+ 'spar': '\u2225',
+ 'sqcap': '\u2293',
+ 'sqcaps': '\u2293\uFE00',
+ 'sqcup': '\u2294',
+ 'sqcups': '\u2294\uFE00',
+ 'sqsub': '\u228F',
+ 'sqsube': '\u2291',
+ 'sqsubset': '\u228F',
+ 'sqsubseteq': '\u2291',
+ 'sqsup': '\u2290',
+ 'sqsupe': '\u2292',
+ 'sqsupset': '\u2290',
+ 'sqsupseteq': '\u2292',
+ 'squ': '\u25A1',
+ 'square': '\u25A1',
+ 'squarf': '\u25AA',
+ 'squf': '\u25AA',
+ 'srarr': '\u2192',
+ 'ssetmn': '\u2216',
+ 'ssmile': '\u2323',
+ 'sstarf': '\u22C6',
+ 'star': '\u2606',
+ 'starf': '\u2605',
+ 'straightepsilon': '\u03F5',
+ 'straightphi': '\u03D5',
+ 'strns': '\u00AF',
+ 'subdot': '\u2ABD',
+ 'sube': '\u2286',
+ 'subedot': '\u2AC3',
+ 'submult': '\u2AC1',
+ 'subplus': '\u2ABF',
+ 'subrarr': '\u2979',
+ 'subset': '\u2282',
+ 'subseteq': '\u2286',
+ 'subseteqq': '\u2AC5',
+ 'subsetneq': '\u228A',
+ 'subsetneqq': '\u2ACB',
+ 'subsim': '\u2AC7',
+ 'subsub': '\u2AD5',
+ 'subsup': '\u2AD3',
+ 'succ': '\u227B',
+ 'succapprox': '\u2AB8',
+ 'succcurlyeq': '\u227D',
+ 'succeq': '\u2AB0',
+ 'succnapprox': '\u2ABA',
+ 'succneqq': '\u2AB6',
+ 'succnsim': '\u22E9',
+ 'succsim': '\u227F',
+ 'sum': '\u2211',
+ 'sung': '\u266A',
+ 'sup': '\u2283',
+ 'sup1': '\u00B9',
+ 'sup2': '\u00B2',
+ 'sup3': '\u00B3',
+ 'supdot': '\u2ABE',
+ 'supdsub': '\u2AD8',
+ 'supe': '\u2287',
+ 'supedot': '\u2AC4',
+ 'suphsol': '\u27C9',
+ 'suphsub': '\u2AD7',
+ 'suplarr': '\u297B',
+ 'supmult': '\u2AC2',
+ 'supplus': '\u2AC0',
+ 'supset': '\u2283',
+ 'supseteq': '\u2287',
+ 'supseteqq': '\u2AC6',
+ 'supsetneq': '\u228B',
+ 'supsetneqq': '\u2ACC',
+ 'supsim': '\u2AC8',
+ 'supsub': '\u2AD4',
+ 'supsup': '\u2AD6',
+ 'swArr': '\u21D9',
+ 'swarhk': '\u2926',
+ 'swarrow': '\u2199',
+ 'swnwar': '\u292A',
+ 'szlig': '\u00DF'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/s.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/scr.js b/js/mathjax/jax/input/MathML/entities/scr.js
new file mode 100644
index 0000000..c94df31
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/scr.js
@@ -0,0 +1,81 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/scr.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Ascr': '\uD835\uDC9C',
+ 'Bscr': '\u212C',
+ 'Cscr': '\uD835\uDC9E',
+ 'Dscr': '\uD835\uDC9F',
+ 'Escr': '\u2130',
+ 'Fscr': '\u2131',
+ 'Gscr': '\uD835\uDCA2',
+ 'Hscr': '\u210B',
+ 'Iscr': '\u2110',
+ 'Jscr': '\uD835\uDCA5',
+ 'Kscr': '\uD835\uDCA6',
+ 'Lscr': '\u2112',
+ 'Mscr': '\u2133',
+ 'Nscr': '\uD835\uDCA9',
+ 'Oscr': '\uD835\uDCAA',
+ 'Pscr': '\uD835\uDCAB',
+ 'Qscr': '\uD835\uDCAC',
+ 'Rscr': '\u211B',
+ 'Sscr': '\uD835\uDCAE',
+ 'Tscr': '\uD835\uDCAF',
+ 'Uscr': '\uD835\uDCB0',
+ 'Vscr': '\uD835\uDCB1',
+ 'Wscr': '\uD835\uDCB2',
+ 'Xscr': '\uD835\uDCB3',
+ 'Yscr': '\uD835\uDCB4',
+ 'Zscr': '\uD835\uDCB5',
+ 'ascr': '\uD835\uDCB6',
+ 'bscr': '\uD835\uDCB7',
+ 'cscr': '\uD835\uDCB8',
+ 'dscr': '\uD835\uDCB9',
+ 'escr': '\u212F',
+ 'fscr': '\uD835\uDCBB',
+ 'gscr': '\u210A',
+ 'hscr': '\uD835\uDCBD',
+ 'iscr': '\uD835\uDCBE',
+ 'jscr': '\uD835\uDCBF',
+ 'kscr': '\uD835\uDCC0',
+ 'lscr': '\uD835\uDCC1',
+ 'mscr': '\uD835\uDCC2',
+ 'nscr': '\uD835\uDCC3',
+ 'oscr': '\u2134',
+ 'pscr': '\uD835\uDCC5',
+ 'qscr': '\uD835\uDCC6',
+ 'rscr': '\uD835\uDCC7',
+ 'sscr': '\uD835\uDCC8',
+ 'tscr': '\uD835\uDCC9',
+ 'uscr': '\uD835\uDCCA',
+ 'vscr': '\uD835\uDCCB',
+ 'wscr': '\uD835\uDCCC',
+ 'xscr': '\uD835\uDCCD',
+ 'yscr': '\uD835\uDCCE',
+ 'zscr': '\uD835\uDCCF'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/scr.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/t.js b/js/mathjax/jax/input/MathML/entities/t.js
new file mode 100644
index 0000000..b70d29c
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/t.js
@@ -0,0 +1,88 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/t.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'THORN': '\u00DE',
+ 'TRADE': '\u2122',
+ 'TSHcy': '\u040B',
+ 'TScy': '\u0426',
+ 'Tab': '\u0009',
+ 'Tau': '\u03A4',
+ 'Tcaron': '\u0164',
+ 'Tcedil': '\u0162',
+ 'Tcy': '\u0422',
+ 'ThickSpace': '\u205F\u200A',
+ 'ThinSpace': '\u2009',
+ 'TripleDot': '\u20DB',
+ 'Tstrok': '\u0166',
+ 'target': '\u2316',
+ 'tbrk': '\u23B4',
+ 'tcaron': '\u0165',
+ 'tcedil': '\u0163',
+ 'tcy': '\u0442',
+ 'tdot': '\u20DB',
+ 'telrec': '\u2315',
+ 'there4': '\u2234',
+ 'therefore': '\u2234',
+ 'thetasym': '\u03D1',
+ 'thickapprox': '\u2248',
+ 'thicksim': '\u223C',
+ 'thinsp': '\u2009',
+ 'thkap': '\u2248',
+ 'thksim': '\u223C',
+ 'thorn': '\u00FE',
+ 'timesb': '\u22A0',
+ 'timesbar': '\u2A31',
+ 'timesd': '\u2A30',
+ 'tint': '\u222D',
+ 'toea': '\u2928',
+ 'top': '\u22A4',
+ 'topbot': '\u2336',
+ 'topcir': '\u2AF1',
+ 'topfork': '\u2ADA',
+ 'tosa': '\u2929',
+ 'tprime': '\u2034',
+ 'trade': '\u2122',
+ 'triangledown': '\u25BF',
+ 'triangleleft': '\u25C3',
+ 'trianglelefteq': '\u22B4',
+ 'triangleright': '\u25B9',
+ 'trianglerighteq': '\u22B5',
+ 'tridot': '\u25EC',
+ 'trie': '\u225C',
+ 'triminus': '\u2A3A',
+ 'triplus': '\u2A39',
+ 'trisb': '\u29CD',
+ 'tritime': '\u2A3B',
+ 'trpezium': '\u23E2',
+ 'tscy': '\u0446',
+ 'tshcy': '\u045B',
+ 'tstrok': '\u0167',
+ 'twixt': '\u226C',
+ 'twoheadleftarrow': '\u219E',
+ 'twoheadrightarrow': '\u21A0'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/t.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/u.js b/js/mathjax/jax/input/MathML/entities/u.js
new file mode 100644
index 0000000..cf22bdc
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/u.js
@@ -0,0 +1,94 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/u.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Uacute': '\u00DA',
+ 'Uarr': '\u219F',
+ 'Uarrocir': '\u2949',
+ 'Ubrcy': '\u040E',
+ 'Ubreve': '\u016C',
+ 'Ucirc': '\u00DB',
+ 'Ucy': '\u0423',
+ 'Udblac': '\u0170',
+ 'Ugrave': '\u00D9',
+ 'Umacr': '\u016A',
+ 'UnderBracket': '\u23B5',
+ 'UnderParenthesis': '\u23DD',
+ 'Uogon': '\u0172',
+ 'UpArrowBar': '\u2912',
+ 'UpArrowDownArrow': '\u21C5',
+ 'UpEquilibrium': '\u296E',
+ 'UpTeeArrow': '\u21A5',
+ 'UpperLeftArrow': '\u2196',
+ 'UpperRightArrow': '\u2197',
+ 'Upsi': '\u03D2',
+ 'Uring': '\u016E',
+ 'Utilde': '\u0168',
+ 'Uuml': '\u00DC',
+ 'uArr': '\u21D1',
+ 'uHar': '\u2963',
+ 'uacute': '\u00FA',
+ 'uarr': '\u2191',
+ 'ubrcy': '\u045E',
+ 'ubreve': '\u016D',
+ 'ucirc': '\u00FB',
+ 'ucy': '\u0443',
+ 'udarr': '\u21C5',
+ 'udblac': '\u0171',
+ 'udhar': '\u296E',
+ 'ufisht': '\u297E',
+ 'ugrave': '\u00F9',
+ 'uharl': '\u21BF',
+ 'uharr': '\u21BE',
+ 'uhblk': '\u2580',
+ 'ulcorn': '\u231C',
+ 'ulcorner': '\u231C',
+ 'ulcrop': '\u230F',
+ 'ultri': '\u25F8',
+ 'umacr': '\u016B',
+ 'uml': '\u00A8',
+ 'uogon': '\u0173',
+ 'uparrow': '\u2191',
+ 'updownarrow': '\u2195',
+ 'upharpoonleft': '\u21BF',
+ 'upharpoonright': '\u21BE',
+ 'uplus': '\u228E',
+ 'upsih': '\u03D2',
+ 'upsilon': '\u03C5',
+ 'urcorn': '\u231D',
+ 'urcorner': '\u231D',
+ 'urcrop': '\u230E',
+ 'uring': '\u016F',
+ 'urtri': '\u25F9',
+ 'utdot': '\u22F0',
+ 'utilde': '\u0169',
+ 'utri': '\u25B5',
+ 'utrif': '\u25B4',
+ 'uuarr': '\u21C8',
+ 'uuml': '\u00FC',
+ 'uwangle': '\u29A7'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/u.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/v.js b/js/mathjax/jax/input/MathML/entities/v.js
new file mode 100644
index 0000000..e944c95
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/v.js
@@ -0,0 +1,75 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/v.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'VDash': '\u22AB',
+ 'Vbar': '\u2AEB',
+ 'Vcy': '\u0412',
+ 'Vdashl': '\u2AE6',
+ 'Verbar': '\u2016',
+ 'Vert': '\u2016',
+ 'VerticalLine': '\u007C',
+ 'VerticalSeparator': '\u2758',
+ 'VeryThinSpace': '\u200A',
+ 'vArr': '\u21D5',
+ 'vBar': '\u2AE8',
+ 'vBarv': '\u2AE9',
+ 'vDash': '\u22A8',
+ 'vangrt': '\u299C',
+ 'varepsilon': '\u03F5',
+ 'varkappa': '\u03F0',
+ 'varnothing': '\u2205',
+ 'varphi': '\u03D5',
+ 'varpi': '\u03D6',
+ 'varpropto': '\u221D',
+ 'varr': '\u2195',
+ 'varrho': '\u03F1',
+ 'varsigma': '\u03C2',
+ 'varsubsetneq': '\u228A\uFE00',
+ 'varsubsetneqq': '\u2ACB\uFE00',
+ 'varsupsetneq': '\u228B\uFE00',
+ 'varsupsetneqq': '\u2ACC\uFE00',
+ 'vartheta': '\u03D1',
+ 'vartriangleleft': '\u22B2',
+ 'vartriangleright': '\u22B3',
+ 'vcy': '\u0432',
+ 'vdash': '\u22A2',
+ 'vee': '\u2228',
+ 'veeeq': '\u225A',
+ 'verbar': '\u007C',
+ 'vert': '\u007C',
+ 'vltri': '\u22B2',
+ 'vnsub': '\u2282\u20D2',
+ 'vnsup': '\u2283\u20D2',
+ 'vprop': '\u221D',
+ 'vrtri': '\u22B3',
+ 'vsubnE': '\u2ACB\uFE00',
+ 'vsubne': '\u228A\uFE00',
+ 'vsupnE': '\u2ACC\uFE00',
+ 'vsupne': '\u228B\uFE00',
+ 'vzigzag': '\u299A'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/v.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/w.js b/js/mathjax/jax/input/MathML/entities/w.js
new file mode 100644
index 0000000..2f2f9f9
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/w.js
@@ -0,0 +1,37 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/w.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'Wcirc': '\u0174',
+ 'wcirc': '\u0175',
+ 'wedbar': '\u2A5F',
+ 'wedge': '\u2227',
+ 'wedgeq': '\u2259',
+ 'wp': '\u2118',
+ 'wr': '\u2240',
+ 'wreath': '\u2240'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/w.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/x.js b/js/mathjax/jax/input/MathML/entities/x.js
new file mode 100644
index 0000000..7b23395
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/x.js
@@ -0,0 +1,49 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/x.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'xcap': '\u22C2',
+ 'xcirc': '\u25EF',
+ 'xcup': '\u22C3',
+ 'xdtri': '\u25BD',
+ 'xhArr': '\u27FA',
+ 'xharr': '\u27F7',
+ 'xlArr': '\u27F8',
+ 'xlarr': '\u27F5',
+ 'xmap': '\u27FC',
+ 'xnis': '\u22FB',
+ 'xodot': '\u2A00',
+ 'xoplus': '\u2A01',
+ 'xotime': '\u2A02',
+ 'xrArr': '\u27F9',
+ 'xrarr': '\u27F6',
+ 'xsqcup': '\u2A06',
+ 'xuplus': '\u2A04',
+ 'xutri': '\u25B3',
+ 'xvee': '\u22C1',
+ 'xwedge': '\u22C0'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/x.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/y.js b/js/mathjax/jax/input/MathML/entities/y.js
new file mode 100644
index 0000000..bcaebab
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/y.js
@@ -0,0 +1,43 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/y.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'YAcy': '\u042F',
+ 'YIcy': '\u0407',
+ 'YUcy': '\u042E',
+ 'Yacute': '\u00DD',
+ 'Ycirc': '\u0176',
+ 'Ycy': '\u042B',
+ 'Yuml': '\u0178',
+ 'yacute': '\u00FD',
+ 'yacy': '\u044F',
+ 'ycirc': '\u0177',
+ 'ycy': '\u044B',
+ 'yicy': '\u0457',
+ 'yucy': '\u044E',
+ 'yuml': '\u00FF'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/y.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/entities/z.js b/js/mathjax/jax/input/MathML/entities/z.js
new file mode 100644
index 0000000..2883e8d
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/entities/z.js
@@ -0,0 +1,44 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/entities/z.js
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MATHML) {
+ MathJax.Hub.Insert(MATHML.Parse.Entity,{
+ 'ZHcy': '\u0416',
+ 'Zacute': '\u0179',
+ 'Zcaron': '\u017D',
+ 'Zcy': '\u0417',
+ 'Zdot': '\u017B',
+ 'ZeroWidthSpace': '\u200B',
+ 'Zeta': '\u0396',
+ 'zacute': '\u017A',
+ 'zcaron': '\u017E',
+ 'zcy': '\u0437',
+ 'zdot': '\u017C',
+ 'zeetrf': '\u2128',
+ 'zhcy': '\u0436',
+ 'zwj': '\u200D',
+ 'zwnj': '\u200C'
+ });
+
+ MathJax.Ajax.loadComplete(MATHML.entityDir+"/z.js");
+
+})(MathJax.InputJax.MathML);
+// @license-end
diff --git a/js/mathjax/jax/input/MathML/jax.js b/js/mathjax/jax/input/MathML/jax.js
new file mode 100644
index 0000000..cc4081b
--- /dev/null
+++ b/js/mathjax/jax/input/MathML/jax.js
@@ -0,0 +1,783 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/input/MathML/jax.js
+ *
+ * Implements the MathML InputJax that reads mathematics in
+ * MathML format and converts it to the MML ElementJax
+ * internal format.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function (MATHML,BROWSER) {
+ var MML;
+
+ var _ = function (id) {
+ return MathJax.Localization._.apply(MathJax.Localization,
+ [["MathML",id]].concat([].slice.call(arguments,1)))
+ };
+
+ MATHML.Parse = MathJax.Object.Subclass({
+
+ Init: function (string,script) {this.Parse(string,script)},
+
+ //
+ // Parse the MathML and check for errors
+ //
+ Parse: function (math,script) {
+ var doc;
+ if (typeof math !== "string") {doc = math.parentNode} else {
+ doc = MATHML.ParseXML(this.preProcessMath.call(this,math));
+ if (doc == null) {MATHML.Error(["ErrorParsingMathML","Error parsing MathML"])}
+ }
+ var err = doc.getElementsByTagName("parsererror")[0];
+ if (err) MATHML.Error(["ParsingError","Error parsing MathML: %1",
+ err.textContent.replace(/This page.*?errors:|XML Parsing Error: |Below is a rendering of the page.*/g,"")]);
+ if (doc.childNodes.length !== 1)
+ {MATHML.Error(["MathMLSingleElement","MathML must be formed by a single element"])}
+ if (doc.firstChild.nodeName.toLowerCase() === "html") {
+ var h1 = doc.getElementsByTagName("h1")[0];
+ if (h1 && h1.textContent === "XML parsing error" && h1.nextSibling)
+ MATHML.Error(["ParsingError","Error parsing MathML: %1",
+ String(h1.nextSibling.nodeValue).replace(/fatal parsing error: /,"")]);
+ }
+ if (doc.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") !== "math") {
+ MATHML.Error(["MathMLRootElement",
+ "MathML must be formed by a <math> element, not %1",
+ "<"+doc.firstChild.nodeName+">"]);
+ }
+ var data = {math:doc.firstChild, script:script};
+ MATHML.DOMfilterHooks.Execute(data);
+ this.mml = this.MakeMML(data.math);
+ },
+
+ //
+ // Convert the MathML structure to the MathJax Element jax structure
+ //
+ MakeMML: function (node) {
+ var CLASS = String(node.getAttribute("class")||""); // make sure CLASS is a string
+ var mml, type = node.nodeName.toLowerCase().replace(/^[a-z]+:/,"");
+ var match = (CLASS.match(/(^| )MJX-TeXAtom-([^ ]*)/));
+ if (match) {
+ mml = this.TeXAtom(match[2],match[2] === "OP" && !CLASS.match(/MJX-fixedlimits/));
+ } else if (!(MML[type] && MML[type].isa && MML[type].isa(MML.mbase))) {
+ MathJax.Hub.signal.Post(["MathML Jax - unknown node type",type]);
+ return MML.Error(_("UnknownNodeType","Unknown node type: %1",type));
+ } else {
+ mml = MML[type]();
+ }
+ this.AddAttributes(mml,node); this.CheckClass(mml,mml["class"]);
+ this.AddChildren(mml,node);
+ if (MATHML.config.useMathMLspacing) {mml.useMMLspacing = 0x08}
+ return mml;
+ },
+ TeXAtom: function (mclass,movablelimits) {
+ var mml = MML.TeXAtom().With({texClass:MML.TEXCLASS[mclass]});
+ if (movablelimits) {mml.movesupsub = mml.movablelimits = true}
+ return mml;
+ },
+ CheckClass: function (mml,CLASS) {
+ CLASS = (CLASS||"").split(/ /); var NCLASS = [];
+ for (var i = 0, m = CLASS.length; i < m; i++) {
+ if (CLASS[i].substr(0,4) === "MJX-") {
+ if (CLASS[i] === "MJX-arrow") {
+ // This class was used in former versions of MathJax to attach an
+ // arrow to the updiagonalstrike notation. For backward
+ // compatibility, let's continue to accept this case. See issue 481.
+ if (!mml.notation.match("/"+MML.NOTATION.UPDIAGONALARROW+"/"))
+ mml.notation += " "+MML.NOTATION.UPDIAGONALARROW;
+ } else if (CLASS[i] === "MJX-variant") {
+ mml.variantForm = true;
+ //
+ // Variant forms come from AMSsymbols, and it sets up the
+ // character mappings, so load that if needed.
+ //
+ if (!MathJax.Extension["TeX/AMSsymbols"])
+ {MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/AMSsymbols.js"))}
+ } else if (CLASS[i].substr(0,11) !== "MJX-TeXAtom") {
+ mml.mathvariant = CLASS[i].substr(3);
+ //
+ // Caligraphic and oldstyle bold are set up in the boldsymbol
+ // extension, so load it if it isn't already loaded.
+ //
+ if (mml.mathvariant === "-tex-caligraphic-bold" ||
+ mml.mathvariant === "-tex-oldstyle-bold") {
+ if (!MathJax.Extension["TeX/boldsymbol"])
+ {MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/boldsymbol.js"))}
+ }
+ }
+ } else {NCLASS.push(CLASS[i])}
+ }
+ if (NCLASS.length) {mml["class"] = NCLASS.join(" ")} else {delete mml["class"]}
+ },
+
+ //
+ // Add the attributes to the mml node
+ //
+ AddAttributes: function (mml,node) {
+ mml.attr = {}; mml.attrNames = [];
+ for (var i = 0, m = node.attributes.length; i < m; i++) {
+ var name = node.attributes[i].name;
+ if (name == "xlink:href") {name = "href"}
+ if (name.match(/:/)) continue;
+ if (name.match(/^_moz-math-((column|row)(align|line)|font-style)$/)) continue;
+ var value = node.attributes[i].value;
+ value = this.filterAttribute(name,value);
+ var defaults = (mml.type === "mstyle" ? MML.math.prototype.defaults : mml.defaults);
+ if (value != null) {
+ var val = value.toLowerCase();
+ if (val === "true" || val === "false") {
+ if (typeof (defaults[name]) === "boolean" || defaults[name] === MML.INHERIT ||
+ mml.type === "math" || mml.type === "mstyle" ||
+ (defaults[name] === MML.AUTO &&
+ (mml.defaultDef == null || typeof(mml.defaultDef[name]) === "boolean"))) {
+ value = (val === "true");
+ }
+ }
+ if (defaults[name] != null || MML.copyAttributes[name])
+ {mml[name] = value} else {mml.attr[name] = value}
+ mml.attrNames.push(name);
+ }
+ }
+ },
+ filterAttribute: function (name,value) {return value}, // safe mode overrides this
+
+ //
+ // Create the children for the mml node
+ //
+ AddChildren: function (mml,node) {
+ for (var i = 0, m = node.childNodes.length; i < m; i++) {
+ var child = node.childNodes[i];
+ if (child.nodeName === "#comment") continue;
+ if (child.nodeName === "#text") {
+ if ((mml.isToken || mml.isChars) && !mml.mmlSelfClosing) {
+ var text = child.nodeValue;
+ if (mml.isToken) {
+ text = text.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity);
+ text = this.trimSpace(text);
+ }
+ mml.Append(MML.chars(text));
+ } else if (child.nodeValue.match(/\S/)) {
+ MATHML.Error(["UnexpectedTextNode",
+ "Unexpected text node: %1","'"+child.nodeValue+"'"]);
+ }
+ } else if (mml.type === "annotation-xml") {
+ mml.Append(MML.xml(child));
+ } else {
+ var cmml = this.MakeMML(child); mml.Append(cmml);
+ if (cmml.mmlSelfClosing && cmml.data.length)
+ {mml.Append.apply(mml,cmml.data); cmml.data = []}
+ }
+ }
+ if (mml.type === "mrow" && mml.data.length >= 2) {
+ var first = mml.data[0], last = mml.data[mml.data.length-1];
+ if (first.type === "mo" && first.Get("fence") &&
+ last.type === "mo" && last.Get("fence")) {
+ if (first.data[0]) {mml.open = first.data.join("")}
+ if (last.data[0]) {mml.close = last.data.join("")}
+ }
+ }
+ },
+
+ //
+ // Clean Up the <math> source to prepare for XML parsing
+ //
+ preProcessMath: function (math) {
+ if (math.match(/^<[a-z]+:/i) && !math.match(/^<[^<>]* xmlns:/)) {
+ math = math.replace(/^<([a-z]+)(:math)/i,'<$1$2 xmlns:$1="http://www.w3.org/1998/Math/MathML"')
+ }
+ // HTML5 removes xmlns: namespaces, so put them back for XML
+ var match = math.match(/^(<math( ('.*?'|".*?"|[^>])+)>)/i);
+ if (match && match[2].match(/ (?!xmlns=)[a-z]+=\"http:/i)) {
+ math = match[1].replace(/ (?!xmlns=)([a-z]+=(['"])http:.*?\2)/ig," xmlns:$1 $1") +
+ math.substr(match[0].length);
+ }
+ if (math.match(/^<math[ >]/i) && !math.match(/^<[^<>]* xmlns=/)) {
+ // append the MathML namespace
+ math = math.replace(/^<(math)/i,'<math xmlns="http://www.w3.org/1998/Math/MathML"')
+ }
+ math = math.replace(/^\s*(?:\/\/)?<!(--)?\[CDATA\[((.|\n)*)(\/\/)?\]\]\1>\s*$/,"$2");
+ return math.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity);
+ },
+
+ //
+ // Remove attribute whitespace
+ //
+ trimSpace: function (string) {
+ return string.replace(/[\t\n\r]/g," ") // whitespace to spaces
+ .replace(/^ +/,"") // initial whitespace
+ .replace(/ +$/,"") // trailing whitespace
+ .replace(/ +/g," "); // internal multiple whitespace
+ },
+
+ //
+ // Replace a named entity by its value
+ // (look up from external files if necessary)
+ //
+ replaceEntity: function (match,entity) {
+ if (entity.match(/^(lt|amp|quot)$/)) {return match} // these mess up attribute parsing
+ if (MATHML.Parse.Entity[entity]) {return MATHML.Parse.Entity[entity]}
+ var file = entity.charAt(0).toLowerCase();
+ var font = entity.match(/^[a-zA-Z](fr|scr|opf)$/);
+ if (font) {file = font[1]}
+ if (!MATHML.Parse.loaded[file]) {
+ MATHML.Parse.loaded[file] = true;
+ MathJax.Hub.RestartAfter(MathJax.Ajax.Require(MATHML.entityDir+"/"+file+".js"));
+ }
+ return match;
+ }
+ }, {
+ loaded: [] // the entity files that are loaded
+ });
+
+ /************************************************************************/
+
+ MATHML.Augment({
+ sourceMenuTitle: /*_(MathMenu)*/ ["OriginalMathML","Original MathML"],
+
+ prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML string before processing MathML
+ DOMfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML DOM before processing
+ postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on internal jax format after processing MathML
+
+ Translate: function (script) {
+ if (!this.ParseXML) {this.ParseXML = this.createParser()}
+ var mml, math, data = {script:script};
+ if (script.firstChild &&
+ script.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") === "math") {
+ data.math = script.firstChild;
+ } else {
+ math = MathJax.HTML.getScript(script);
+ if (BROWSER.isMSIE) {math = math.replace(/(&nbsp;)+$/,"")}
+ data.math = math;
+ }
+ var callback = this.prefilterHooks.Execute(data); if (callback) return callback;
+ math = data.math;
+ try {
+ mml = MATHML.Parse(math,script).mml;
+ } catch(err) {
+ if (!err.mathmlError) {throw err}
+ mml = this.formatError(err,math,script);
+ }
+ data.math = MML(mml);
+ return this.postfilterHooks.Execute(data) || data.math;
+ },
+ prefilterMath: function (math,script) {return math},
+ prefilterMathML: function (math,script) {return math},
+ formatError: function (err,math,script) {
+ var message = err.message.replace(/\n.*/,"");
+ MathJax.Hub.signal.Post(["MathML Jax - parse error",message,math,script]);
+ return MML.Error(message);
+ },
+ Error: function (message) {
+ //
+ // Translate message if it is ["id","message",args]
+ //
+ if (MathJax.Object.isArray(message)) {message = _.apply(_,message)}
+ throw MathJax.Hub.Insert(Error(message),{mathmlError: true});
+ },
+ //
+ // Parsers for various forms (DOMParser, Windows ActiveX object, other)
+ //
+ parseDOM: function (string) {return this.parser.parseFromString(string,"text/xml")},
+ parseMS: function (string) {return (this.parser.loadXML(string) ? this.parser : null)},
+ parseDIV: function (string) {
+ this.div.innerHTML =
+ "<div>"+string.replace(/<([a-z]+)([^>]*)\/>/g,"<$1$2></$1>")+"</div>";
+ var doc = this.div.firstChild;
+ this.div.innerHTML = "";
+ return doc;
+ },
+ parseError: function (string) {return null},
+ createMSParser: function() {
+ var parser = null;
+ var xml = ["MSXML2.DOMDocument.6.0","MSXML2.DOMDocument.5.0",
+ "MSXML2.DOMDocument.4.0","MSXML2.DOMDocument.3.0",
+ "MSXML2.DOMDocument.2.0","Microsoft.XMLDOM"];
+ for (var i = 0, m = xml.length; i < m && !parser; i++) {
+ try {
+ parser = new ActiveXObject(xml[i])
+ } catch (err) {}
+ }
+ return parser;
+ },
+ //
+ // Create the parser using a DOMParser, or other fallback method
+ //
+ createParser: function () {
+ if (window.DOMParser) {
+ this.parser = new DOMParser();
+ return(this.parseDOM);
+ } else if (window.ActiveXObject) {
+ this.parser = this.createMSParser();
+ if (!this.parser) {
+ MathJax.Localization.Try(this.parserCreationError);
+ return(this.parseError);
+ }
+ this.parser.async = false;
+ return(this.parseMS);
+ }
+ this.div = MathJax.Hub.Insert(document.createElement("div"),{
+ style:{visibility:"hidden", overflow:"hidden", height:"1px",
+ position:"absolute", top:0}
+ });
+ if (!document.body.firstChild) {document.body.appendChild(this.div)}
+ else {document.body.insertBefore(this.div,document.body.firstChild)}
+ return(this.parseDIV);
+ },
+ parserCreationError: function () {
+ alert(_("CantCreateXMLParser",
+ "MathJax can't create an XML parser for MathML. Check that\n"+
+ "the 'Script ActiveX controls marked safe for scripting' security\n"+
+ "setting is enabled (use the Internet Options item in the Tools\n"+
+ "menu, and select the Security panel, then press the Custom Level\n"+
+ "button to check this).\n\n"+
+ "MathML equations will not be able to be processed by MathJax."));
+ },
+ //
+ // Initialize the parser object (whichever type is used)
+ //
+ Startup: function () {
+ MML = MathJax.ElementJax.mml;
+ MML.mspace.Augment({mmlSelfClosing: true});
+ MML.none.Augment({mmlSelfClosing: true});
+ MML.mprescripts.Augment({mmlSelfClosing:true});
+ MML.maligngroup.Augment({mmlSelfClosing:true});
+ MML.malignmark.Augment({mmlSelfClosing:true});
+ }
+ });
+
+ //
+ // Add the default pre-filter (for backward compatibility)
+ //
+ MATHML.prefilterHooks.Add(function (data) {
+ data.math = (typeof(data.math) === "string" ?
+ MATHML.prefilterMath(data.math,data.script) :
+ MATHML.prefilterMathML(data.math,data.script));
+ });
+
+ MATHML.Parse.Entity = {
+ ApplyFunction: '\u2061',
+ Backslash: '\u2216',
+ Because: '\u2235',
+ Breve: '\u02D8',
+ Cap: '\u22D2',
+ CenterDot: '\u00B7',
+ CircleDot: '\u2299',
+ CircleMinus: '\u2296',
+ CirclePlus: '\u2295',
+ CircleTimes: '\u2297',
+ Congruent: '\u2261',
+ ContourIntegral: '\u222E',
+ Coproduct: '\u2210',
+ Cross: '\u2A2F',
+ Cup: '\u22D3',
+ CupCap: '\u224D',
+ Dagger: '\u2021',
+ Del: '\u2207',
+ Delta: '\u0394',
+ Diamond: '\u22C4',
+ DifferentialD: '\u2146',
+ DotEqual: '\u2250',
+ DoubleDot: '\u00A8',
+ DoubleRightTee: '\u22A8',
+ DoubleVerticalBar: '\u2225',
+ DownArrow: '\u2193',
+ DownLeftVector: '\u21BD',
+ DownRightVector: '\u21C1',
+ DownTee: '\u22A4',
+ Downarrow: '\u21D3',
+ Element: '\u2208',
+ EqualTilde: '\u2242',
+ Equilibrium: '\u21CC',
+ Exists: '\u2203',
+ ExponentialE: '\u2147',
+ FilledVerySmallSquare: '\u25AA',
+ ForAll: '\u2200',
+ Gamma: '\u0393',
+ Gg: '\u22D9',
+ GreaterEqual: '\u2265',
+ GreaterEqualLess: '\u22DB',
+ GreaterFullEqual: '\u2267',
+ GreaterLess: '\u2277',
+ GreaterSlantEqual: '\u2A7E',
+ GreaterTilde: '\u2273',
+ Hacek: '\u02C7',
+ Hat: '\u005E',
+ HumpDownHump: '\u224E',
+ HumpEqual: '\u224F',
+ Im: '\u2111',
+ ImaginaryI: '\u2148',
+ Integral: '\u222B',
+ Intersection: '\u22C2',
+ InvisibleComma: '\u2063',
+ InvisibleTimes: '\u2062',
+ Lambda: '\u039B',
+ Larr: '\u219E',
+ LeftAngleBracket: '\u27E8',
+ LeftArrow: '\u2190',
+ LeftArrowRightArrow: '\u21C6',
+ LeftCeiling: '\u2308',
+ LeftDownVector: '\u21C3',
+ LeftFloor: '\u230A',
+ LeftRightArrow: '\u2194',
+ LeftTee: '\u22A3',
+ LeftTriangle: '\u22B2',
+ LeftTriangleEqual: '\u22B4',
+ LeftUpVector: '\u21BF',
+ LeftVector: '\u21BC',
+ Leftarrow: '\u21D0',
+ Leftrightarrow: '\u21D4',
+ LessEqualGreater: '\u22DA',
+ LessFullEqual: '\u2266',
+ LessGreater: '\u2276',
+ LessSlantEqual: '\u2A7D',
+ LessTilde: '\u2272',
+ Ll: '\u22D8',
+ Lleftarrow: '\u21DA',
+ LongLeftArrow: '\u27F5',
+ LongLeftRightArrow: '\u27F7',
+ LongRightArrow: '\u27F6',
+ Longleftarrow: '\u27F8',
+ Longleftrightarrow: '\u27FA',
+ Longrightarrow: '\u27F9',
+ Lsh: '\u21B0',
+ MinusPlus: '\u2213',
+ NestedGreaterGreater: '\u226B',
+ NestedLessLess: '\u226A',
+ NotDoubleVerticalBar: '\u2226',
+ NotElement: '\u2209',
+ NotEqual: '\u2260',
+ NotExists: '\u2204',
+ NotGreater: '\u226F',
+ NotGreaterEqual: '\u2271',
+ NotLeftTriangle: '\u22EA',
+ NotLeftTriangleEqual: '\u22EC',
+ NotLess: '\u226E',
+ NotLessEqual: '\u2270',
+ NotPrecedes: '\u2280',
+ NotPrecedesSlantEqual: '\u22E0',
+ NotRightTriangle: '\u22EB',
+ NotRightTriangleEqual: '\u22ED',
+ NotSubsetEqual: '\u2288',
+ NotSucceeds: '\u2281',
+ NotSucceedsSlantEqual: '\u22E1',
+ NotSupersetEqual: '\u2289',
+ NotTilde: '\u2241',
+ NotVerticalBar: '\u2224',
+ Omega: '\u03A9',
+ OverBar: '\u203E',
+ OverBrace: '\u23DE',
+ PartialD: '\u2202',
+ Phi: '\u03A6',
+ Pi: '\u03A0',
+ PlusMinus: '\u00B1',
+ Precedes: '\u227A',
+ PrecedesEqual: '\u2AAF',
+ PrecedesSlantEqual: '\u227C',
+ PrecedesTilde: '\u227E',
+ Product: '\u220F',
+ Proportional: '\u221D',
+ Psi: '\u03A8',
+ Rarr: '\u21A0',
+ Re: '\u211C',
+ ReverseEquilibrium: '\u21CB',
+ RightAngleBracket: '\u27E9',
+ RightArrow: '\u2192',
+ RightArrowLeftArrow: '\u21C4',
+ RightCeiling: '\u2309',
+ RightDownVector: '\u21C2',
+ RightFloor: '\u230B',
+ RightTee: '\u22A2',
+ RightTeeArrow: '\u21A6',
+ RightTriangle: '\u22B3',
+ RightTriangleEqual: '\u22B5',
+ RightUpVector: '\u21BE',
+ RightVector: '\u21C0',
+ Rightarrow: '\u21D2',
+ Rrightarrow: '\u21DB',
+ Rsh: '\u21B1',
+ Sigma: '\u03A3',
+ SmallCircle: '\u2218',
+ Sqrt: '\u221A',
+ Square: '\u25A1',
+ SquareIntersection: '\u2293',
+ SquareSubset: '\u228F',
+ SquareSubsetEqual: '\u2291',
+ SquareSuperset: '\u2290',
+ SquareSupersetEqual: '\u2292',
+ SquareUnion: '\u2294',
+ Star: '\u22C6',
+ Subset: '\u22D0',
+ SubsetEqual: '\u2286',
+ Succeeds: '\u227B',
+ SucceedsEqual: '\u2AB0',
+ SucceedsSlantEqual: '\u227D',
+ SucceedsTilde: '\u227F',
+ SuchThat: '\u220B',
+ Sum: '\u2211',
+ Superset: '\u2283',
+ SupersetEqual: '\u2287',
+ Supset: '\u22D1',
+ Therefore: '\u2234',
+ Theta: '\u0398',
+ Tilde: '\u223C',
+ TildeEqual: '\u2243',
+ TildeFullEqual: '\u2245',
+ TildeTilde: '\u2248',
+ UnderBar: '\u005F',
+ UnderBrace: '\u23DF',
+ Union: '\u22C3',
+ UnionPlus: '\u228E',
+ UpArrow: '\u2191',
+ UpDownArrow: '\u2195',
+ UpTee: '\u22A5',
+ Uparrow: '\u21D1',
+ Updownarrow: '\u21D5',
+ Upsilon: '\u03A5',
+ Vdash: '\u22A9',
+ Vee: '\u22C1',
+ VerticalBar: '\u2223',
+ VerticalTilde: '\u2240',
+ Vvdash: '\u22AA',
+ Wedge: '\u22C0',
+ Xi: '\u039E',
+ acute: '\u00B4',
+ aleph: '\u2135',
+ alpha: '\u03B1',
+ amalg: '\u2A3F',
+ and: '\u2227',
+ ang: '\u2220',
+ angmsd: '\u2221',
+ angsph: '\u2222',
+ ape: '\u224A',
+ backprime: '\u2035',
+ backsim: '\u223D',
+ backsimeq: '\u22CD',
+ beta: '\u03B2',
+ beth: '\u2136',
+ between: '\u226C',
+ bigcirc: '\u25EF',
+ bigodot: '\u2A00',
+ bigoplus: '\u2A01',
+ bigotimes: '\u2A02',
+ bigsqcup: '\u2A06',
+ bigstar: '\u2605',
+ bigtriangledown: '\u25BD',
+ bigtriangleup: '\u25B3',
+ biguplus: '\u2A04',
+ blacklozenge: '\u29EB',
+ blacktriangle: '\u25B4',
+ blacktriangledown: '\u25BE',
+ blacktriangleleft: '\u25C2',
+ bowtie: '\u22C8',
+ boxdl: '\u2510',
+ boxdr: '\u250C',
+ boxminus: '\u229F',
+ boxplus: '\u229E',
+ boxtimes: '\u22A0',
+ boxul: '\u2518',
+ boxur: '\u2514',
+ bsol: '\u005C',
+ bull: '\u2022',
+ cap: '\u2229',
+ check: '\u2713',
+ chi: '\u03C7',
+ circ: '\u02C6',
+ circeq: '\u2257',
+ circlearrowleft: '\u21BA',
+ circlearrowright: '\u21BB',
+ circledR: '\u00AE',
+ circledS: '\u24C8',
+ circledast: '\u229B',
+ circledcirc: '\u229A',
+ circleddash: '\u229D',
+ clubs: '\u2663',
+ colon: '\u003A',
+ comp: '\u2201',
+ ctdot: '\u22EF',
+ cuepr: '\u22DE',
+ cuesc: '\u22DF',
+ cularr: '\u21B6',
+ cup: '\u222A',
+ curarr: '\u21B7',
+ curlyvee: '\u22CE',
+ curlywedge: '\u22CF',
+ dagger: '\u2020',
+ daleth: '\u2138',
+ ddarr: '\u21CA',
+ deg: '\u00B0',
+ delta: '\u03B4',
+ digamma: '\u03DD',
+ div: '\u00F7',
+ divideontimes: '\u22C7',
+ dot: '\u02D9',
+ doteqdot: '\u2251',
+ dotplus: '\u2214',
+ dotsquare: '\u22A1',
+ dtdot: '\u22F1',
+ ecir: '\u2256',
+ efDot: '\u2252',
+ egs: '\u2A96',
+ ell: '\u2113',
+ els: '\u2A95',
+ empty: '\u2205',
+ epsi: '\u03B5',
+ epsiv: '\u03F5',
+ erDot: '\u2253',
+ eta: '\u03B7',
+ eth: '\u00F0',
+ flat: '\u266D',
+ fork: '\u22D4',
+ frown: '\u2322',
+ gEl: '\u2A8C',
+ gamma: '\u03B3',
+ gap: '\u2A86',
+ gimel: '\u2137',
+ gnE: '\u2269',
+ gnap: '\u2A8A',
+ gne: '\u2A88',
+ gnsim: '\u22E7',
+ gt: '\u003E',
+ gtdot: '\u22D7',
+ harrw: '\u21AD',
+ hbar: '\u210F',
+ hellip: '\u2026',
+ hookleftarrow: '\u21A9',
+ hookrightarrow: '\u21AA',
+ imath: '\u0131',
+ infin: '\u221E',
+ intcal: '\u22BA',
+ iota: '\u03B9',
+ jmath: '\u0237',
+ kappa: '\u03BA',
+ kappav: '\u03F0',
+ lEg: '\u2A8B',
+ lambda: '\u03BB',
+ lap: '\u2A85',
+ larrlp: '\u21AB',
+ larrtl: '\u21A2',
+ lbrace: '\u007B',
+ lbrack: '\u005B',
+ le: '\u2264',
+ leftleftarrows: '\u21C7',
+ leftthreetimes: '\u22CB',
+ lessdot: '\u22D6',
+ lmoust: '\u23B0',
+ lnE: '\u2268',
+ lnap: '\u2A89',
+ lne: '\u2A87',
+ lnsim: '\u22E6',
+ longmapsto: '\u27FC',
+ looparrowright: '\u21AC',
+ lowast: '\u2217',
+ loz: '\u25CA',
+ lt: '\u003C',
+ ltimes: '\u22C9',
+ ltri: '\u25C3',
+ macr: '\u00AF',
+ malt: '\u2720',
+ mho: '\u2127',
+ mu: '\u03BC',
+ multimap: '\u22B8',
+ nLeftarrow: '\u21CD',
+ nLeftrightarrow: '\u21CE',
+ nRightarrow: '\u21CF',
+ nVDash: '\u22AF',
+ nVdash: '\u22AE',
+ natur: '\u266E',
+ nearr: '\u2197',
+ nharr: '\u21AE',
+ nlarr: '\u219A',
+ not: '\u00AC',
+ nrarr: '\u219B',
+ nu: '\u03BD',
+ nvDash: '\u22AD',
+ nvdash: '\u22AC',
+ nwarr: '\u2196',
+ omega: '\u03C9',
+ omicron: '\u03BF',
+ or: '\u2228',
+ osol: '\u2298',
+ period: '\u002E',
+ phi: '\u03C6',
+ phiv: '\u03D5',
+ pi: '\u03C0',
+ piv: '\u03D6',
+ prap: '\u2AB7',
+ precnapprox: '\u2AB9',
+ precneqq: '\u2AB5',
+ precnsim: '\u22E8',
+ prime: '\u2032',
+ psi: '\u03C8',
+ rarrtl: '\u21A3',
+ rbrace: '\u007D',
+ rbrack: '\u005D',
+ rho: '\u03C1',
+ rhov: '\u03F1',
+ rightrightarrows: '\u21C9',
+ rightthreetimes: '\u22CC',
+ ring: '\u02DA',
+ rmoust: '\u23B1',
+ rtimes: '\u22CA',
+ rtri: '\u25B9',
+ scap: '\u2AB8',
+ scnE: '\u2AB6',
+ scnap: '\u2ABA',
+ scnsim: '\u22E9',
+ sdot: '\u22C5',
+ searr: '\u2198',
+ sect: '\u00A7',
+ sharp: '\u266F',
+ sigma: '\u03C3',
+ sigmav: '\u03C2',
+ simne: '\u2246',
+ smile: '\u2323',
+ spades: '\u2660',
+ sub: '\u2282',
+ subE: '\u2AC5',
+ subnE: '\u2ACB',
+ subne: '\u228A',
+ supE: '\u2AC6',
+ supnE: '\u2ACC',
+ supne: '\u228B',
+ swarr: '\u2199',
+ tau: '\u03C4',
+ theta: '\u03B8',
+ thetav: '\u03D1',
+ tilde: '\u02DC',
+ times: '\u00D7',
+ triangle: '\u25B5',
+ triangleq: '\u225C',
+ upsi: '\u03C5',
+ upuparrows: '\u21C8',
+ veebar: '\u22BB',
+ vellip: '\u22EE',
+ weierp: '\u2118',
+ xi: '\u03BE',
+ yen: '\u00A5',
+ zeta: '\u03B6',
+ zigrarr: '\u21DD'
+ };
+
+ MATHML.loadComplete("jax.js");
+
+})(MathJax.InputJax.MathML,MathJax.Hub.Browser);
+// @license-end
diff --git a/js/mathjax/jax/input/TeX/config.js b/js/mathjax/jax/input/TeX/config.js
new file mode 100644
index 0000000..76e751f
--- /dev/null
+++ b/js/mathjax/jax/input/TeX/config.js
@@ -0,0 +1,56 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/input/TeX/config.js
+ *
+ * Initializes the TeX InputJax (the main definition is in
+ * MathJax/jax/input/TeX/jax.js, which is loaded when needed).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2009-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.InputJax.TeX = MathJax.InputJax({
+ id: "TeX",
+ version: "2.7.9",
+ directory: MathJax.InputJax.directory + "/TeX",
+ extensionDir: MathJax.InputJax.extensionDir + "/TeX",
+
+ config: {
+ TagSide: "right",
+ TagIndent: "0.8em",
+ MultLineWidth: "85%",
+
+ equationNumbers: {
+ autoNumber: "none", // "AMS" for standard AMS numbering,
+ // or "all" for all displayed equations
+ formatNumber: function (n) {return n},
+ formatTag: function (n) {return '('+n+')'},
+ formatID: function (n) {return 'mjx-eqn-'+String(n).replace(/\s/g,"_")},
+ formatURL: function (id,base) {return base+'#'+encodeURIComponent(id)},
+ useLabelIds: true
+ }
+ },
+
+ resetEquationNumbers: function () {} // filled in by AMSmath extension
+});
+MathJax.InputJax.TeX.Register("math/tex");
+
+MathJax.InputJax.TeX.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/input/TeX/jax.js b/js/mathjax/jax/input/TeX/jax.js
new file mode 100644
index 0000000..9c36d31
--- /dev/null
+++ b/js/mathjax/jax/input/TeX/jax.js
@@ -0,0 +1,2373 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/input/TeX/jax.js
+ *
+ * Implements the TeX InputJax that reads mathematics in
+ * TeX and LaTeX format and converts it to the MML ElementJax
+ * internal format.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2009-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function (TEX,HUB,AJAX) {
+ var MML, NBSP = "\u00A0";
+
+ var _ = function (id) {
+ return MathJax.Localization._.apply(MathJax.Localization,
+ [["TeX", id]].concat([].slice.call(arguments,1)));
+ };
+
+ var isArray = MathJax.Object.isArray;
+
+ var STACK = MathJax.Object.Subclass({
+ Init: function (env,inner) {
+ this.global = {isInner: inner};
+ this.data = [STACKITEM.start(this.global)];
+ if (env) {this.data[0].env = env}
+ this.env = this.data[0].env;
+ },
+ Push: function () {
+ var i, m, item, top;
+ for (i = 0, m = arguments.length; i < m; i++) {
+ item = arguments[i]; if (!item) continue;
+ if (item instanceof MML.mbase) {item = STACKITEM.mml(item)}
+ item.global = this.global;
+ top = (this.data.length ? this.Top().checkItem(item) : true);
+ if (top instanceof Array) {this.Pop(); this.Push.apply(this,top)}
+ else if (top instanceof STACKITEM) {this.Pop(); this.Push(top)}
+ else if (top) {
+ this.data.push(item);
+ if (item.env) {
+ if (item.copyEnv !== false) {
+ for (var id in this.env)
+ {if (this.env.hasOwnProperty(id)) {item.env[id] = this.env[id]}}
+ }
+ this.env = item.env;
+ } else {item.env = this.env}
+ }
+ }
+ },
+ Pop: function () {
+ var item = this.data.pop(); if (!item.isOpen) {delete item.env}
+ this.env = (this.data.length ? this.Top().env : {});
+ return item;
+ },
+ Top: function (n) {
+ if (n == null) {n = 1}
+ if (this.data.length < n) {return null}
+ return this.data[this.data.length-n];
+ },
+ Prev: function (noPop) {
+ var top = this.Top();
+ if (noPop) {return top.data[top.data.length-1]}
+ else {return top.Pop()}
+ },
+ toString: function () {return "stack[\n "+this.data.join("\n ")+"\n]"}
+ });
+
+ var STACKITEM = STACK.Item = MathJax.Object.Subclass({
+ type: "base",
+ endError: /*_()*/ ["ExtraOpenMissingClose","Extra open brace or missing close brace"],
+ closeError: /*_()*/ ["ExtraCloseMissingOpen","Extra close brace or missing open brace"],
+ rightError: /*_()*/ ["MissingLeftExtraRight","Missing \\left or extra \\right"],
+ Init: function () {
+ if (this.isOpen) {this.env = {}}
+ this.data = [];
+ this.Push.apply(this,arguments);
+ },
+ Push: function () {this.data.push.apply(this.data,arguments)},
+ Pop: function () {return this.data.pop()},
+ mmlData: function (inferred,forceRow) {
+ if (inferred == null) {inferred = true}
+ if (this.data.length === 1 && !forceRow) {return this.data[0]}
+ return MML.mrow.apply(MML,this.data).With((inferred ? {inferred: true}: {}));
+ },
+ checkItem: function (item) {
+ if (item.type === "over" && this.isOpen) {item.num = this.mmlData(false); this.data = []}
+ if (item.type === "cell" && this.isOpen) {
+ if (item.linebreak) {return false}
+ TEX.Error(["Misplaced","Misplaced %1",item.name]);
+ }
+ if (item.isClose && this[item.type+"Error"]) {TEX.Error(this[item.type+"Error"])}
+ if (!item.isNotStack) {return true}
+ this.Push(item.data[0]); return false;
+ },
+ With: function (def) {
+ for (var id in def) {if (def.hasOwnProperty(id)) {this[id] = def[id]}}
+ return this;
+ },
+ toString: function () {return this.type+"["+this.data.join("; ")+"]"}
+ });
+
+ STACKITEM.start = STACKITEM.Subclass({
+ type: "start", isOpen: true,
+ Init: function (global) {
+ this.SUPER(arguments).Init.call(this);
+ this.global = global;
+ },
+ checkItem: function (item) {
+ if (item.type === "stop") {return STACKITEM.mml(this.mmlData())}
+ return this.SUPER(arguments).checkItem.call(this,item);
+ }
+ });
+
+ STACKITEM.stop = STACKITEM.Subclass({
+ type: "stop", isClose: true
+ });
+
+ STACKITEM.open = STACKITEM.Subclass({
+ type: "open", isOpen: true,
+ stopError: /*_()*/ ["ExtraOpenMissingClose","Extra open brace or missing close brace"],
+ checkItem: function (item) {
+ if (item.type === "close") {
+ var mml = this.mmlData();
+ return STACKITEM.mml(MML.TeXAtom(mml)); // TeXAtom make it an ORD to prevent spacing (FIXME: should be another way)
+ }
+ return this.SUPER(arguments).checkItem.call(this,item);
+ }
+ });
+
+ STACKITEM.close = STACKITEM.Subclass({
+ type: "close", isClose: true
+ });
+
+ STACKITEM.prime = STACKITEM.Subclass({
+ type: "prime",
+ checkItem: function (item) {
+ if (this.data[0].type !== "msubsup")
+ {return [MML.msup(this.data[0],this.data[1]),item]}
+ this.data[0].SetData(this.data[0].sup,this.data[1]);
+ return [this.data[0],item];
+ }
+ });
+
+ STACKITEM.subsup = STACKITEM.Subclass({
+ type: "subsup",
+ stopError: /*_()*/ ["MissingScript","Missing superscript or subscript argument"],
+ supError: /*_()*/ ["MissingOpenForSup","Missing open brace for superscript"],
+ subError: /*_()*/ ["MissingOpenForSub","Missing open brace for subscript"],
+ checkItem: function (item) {
+ if (item.type === "open" || item.type === "left") {return true}
+ if (item.type === "mml") {
+ if (this.primes) {
+ if (this.position !== 2) {this.data[0].SetData(2,this.primes)}
+ else {item.data[0] = MML.mrow(this.primes.With({variantForm:true}),item.data[0])}
+ }
+ this.data[0].SetData(this.position,item.data[0]);
+ if (this.movesupsub != null) {this.data[0].movesupsub = this.movesupsub}
+ return STACKITEM.mml(this.data[0]);
+ }
+ if (this.SUPER(arguments).checkItem.call(this,item))
+ {TEX.Error(this[["","subError","supError"][this.position]])}
+ },
+ Pop: function () {}
+ });
+
+ STACKITEM.over = STACKITEM.Subclass({
+ type: "over", isClose: true, name: "\\over",
+ checkItem: function (item,stack) {
+ if (item.type === "over")
+ {TEX.Error(["AmbiguousUseOf","Ambiguous use of %1",item.name])}
+ if (item.isClose) {
+ var mml = MML.mfrac(this.num,this.mmlData(false));
+ if (this.thickness != null) {mml.linethickness = this.thickness}
+ if (this.open || this.close) {
+ mml.texWithDelims = true;
+ mml = TEX.fixedFence(this.open,mml,this.close);
+ }
+ return [STACKITEM.mml(mml), item];
+ }
+ return this.SUPER(arguments).checkItem.call(this,item);
+ },
+ toString: function () {return "over["+this.num+" / "+this.data.join("; ")+"]"}
+ });
+
+ STACKITEM.left = STACKITEM.Subclass({
+ type: "left", isOpen: true, delim: '(',
+ stopError: /*_()*/ ["ExtraLeftMissingRight", "Extra \\left or missing \\right"],
+ checkItem: function (item) {
+ if (item.type === "right")
+ {return STACKITEM.mml(TEX.fenced(this.delim,this.mmlData(),item.delim))}
+ return this.SUPER(arguments).checkItem.call(this,item);
+ }
+ });
+
+ STACKITEM.right = STACKITEM.Subclass({
+ type: "right", isClose: true, delim: ')'
+ });
+
+ STACKITEM.begin = STACKITEM.Subclass({
+ type: "begin", isOpen: true,
+ checkItem: function (item) {
+ if (item.type === "end") {
+ if (item.name !== this.name)
+ {TEX.Error(["EnvBadEnd","\\begin{%1} ended with \\end{%2}",this.name,item.name])}
+ if (!this.end) {return STACKITEM.mml(this.mmlData())}
+ return this.parse[this.end].call(this.parse,this,this.data);
+ }
+ if (item.type === "stop")
+ {TEX.Error(["EnvMissingEnd","Missing \\end{%1}",this.name])}
+ return this.SUPER(arguments).checkItem.call(this,item);
+ }
+ });
+
+ STACKITEM.end = STACKITEM.Subclass({
+ type: "end", isClose: true
+ });
+
+ STACKITEM.style = STACKITEM.Subclass({
+ type: "style",
+ checkItem: function (item) {
+ if (!item.isClose) {return this.SUPER(arguments).checkItem.call(this,item)}
+ var mml = MML.mstyle.apply(MML,this.data).With(this.styles);
+ return [STACKITEM.mml(mml),item];
+ }
+ });
+
+ STACKITEM.position = STACKITEM.Subclass({
+ type: "position",
+ checkItem: function (item) {
+ if (item.isClose) {TEX.Error(["MissingBoxFor","Missing box for %1",this.name])}
+ if (item.isNotStack) {
+ var mml = item.mmlData();
+ switch (this.move) {
+ case 'vertical':
+ mml = MML.mpadded(mml).With({height: this.dh, depth: this.dd, voffset: this.dh});
+ return [STACKITEM.mml(mml)];
+ case 'horizontal':
+ return [STACKITEM.mml(this.left),item,STACKITEM.mml(this.right)];
+ }
+ }
+ return this.SUPER(arguments).checkItem.call(this,item);
+ }
+ });
+
+ STACKITEM.array = STACKITEM.Subclass({
+ type: "array", isOpen: true, copyEnv: false, arraydef: {},
+ Init: function () {
+ this.table = []; this.row = []; this.frame = []; this.hfill = [];
+ this.SUPER(arguments).Init.apply(this,arguments);
+ },
+ checkItem: function (item) {
+ if (item.isClose && item.type !== "over") {
+ if (item.isEntry) {this.EndEntry(); this.clearEnv(); return false}
+ if (item.isCR) {this.EndEntry(); this.EndRow(); this.clearEnv(); return false}
+ this.EndTable(); this.clearEnv();
+ var scriptlevel = this.arraydef.scriptlevel; delete this.arraydef.scriptlevel;
+ var mml = MML.mtable.apply(MML,this.table).With(this.arraydef);
+ if (this.frame.length === 4) {
+ mml.frame = (this.frame.dashed ? "dashed" : "solid");
+ } else if (this.frame.length) {
+ mml.hasFrame = true;
+ if (this.arraydef.rowlines) {this.arraydef.rowlines = this.arraydef.rowlines.replace(/none( none)+$/,"none")}
+ mml = MML.menclose(mml).With({notation: this.frame.join(" "), isFrame: true});
+ if ((this.arraydef.columnlines||"none") != "none" ||
+ (this.arraydef.rowlines||"none") != "none") {mml.padding = 0} // HTML-CSS jax implements this
+ }
+ if (scriptlevel) {mml = MML.mstyle(mml).With({scriptlevel: scriptlevel})}
+ if (this.open || this.close) {mml = TEX.fenced(this.open,mml,this.close)}
+ mml = STACKITEM.mml(mml);
+ if (this.requireClose) {
+ if (item.type === 'close') {return mml}
+ TEX.Error(["MissingCloseBrace","Missing close brace"]);
+ }
+ return [mml,item];
+ }
+ return this.SUPER(arguments).checkItem.call(this,item);
+ },
+ EndEntry: function () {
+ var mtd = MML.mtd.apply(MML,this.data);
+ if (this.hfill.length) {
+ if (this.hfill[0] === 0) mtd.columnalign = "right";
+ if (this.hfill[this.hfill.length-1] === this.data.length)
+ mtd.columnalign = (mtd.columnalign ? "center" : "left");
+ }
+ this.row.push(mtd); this.data = []; this.hfill = [];
+ },
+ EndRow: function () {
+ var mtr = MML.mtr;
+ if (this.isNumbered && this.row.length === 3) {
+ this.row.unshift(this.row.pop()); // move equation number to first position
+ mtr = MML.mlabeledtr;
+ }
+ this.table.push(mtr.apply(MML,this.row)); this.row = [];
+ },
+ EndTable: function () {
+ if (this.data.length || this.row.length) {this.EndEntry(); this.EndRow()}
+ this.checkLines();
+ },
+ checkLines: function () {
+ if (this.arraydef.rowlines) {
+ var lines = this.arraydef.rowlines.split(/ /);
+ if (lines.length === this.table.length) {
+ this.frame.push("bottom"); lines.pop();
+ this.arraydef.rowlines = lines.join(' ');
+ } else if (lines.length < this.table.length-1) {
+ this.arraydef.rowlines += " none";
+ }
+ }
+ if (this.rowspacing) {
+ var rows = this.arraydef.rowspacing.split(/ /);
+ while (rows.length < this.table.length) {rows.push(this.rowspacing+"em")}
+ this.arraydef.rowspacing = rows.join(' ');
+ }
+ },
+ clearEnv: function () {
+ for (var id in this.env) {if (this.env.hasOwnProperty(id)) {delete this.env[id]}}
+ }
+ });
+
+ STACKITEM.cell = STACKITEM.Subclass({
+ type: "cell", isClose: true
+ });
+
+ STACKITEM.mml = STACKITEM.Subclass({
+ type: "mml", isNotStack: true,
+ Add: function () {this.data.push.apply(this.data,arguments); return this}
+ });
+
+ STACKITEM.fn = STACKITEM.Subclass({
+ type: "fn",
+ checkItem: function (item) {
+ if (this.data[0]) {
+ if (item.isOpen) {return true}
+ if (item.type !== "fn") {
+ if (item.type !== "mml" || !item.data[0]) {return [this.data[0],item]}
+ if (item.data[0].isa(MML.mspace)) {return [this.data[0],item]}
+ var mml = item.data[0]; if (mml.isEmbellished()) {mml = mml.CoreMO()}
+ if ([0,0,1,1,0,1,1,0,0,0][mml.Get("texClass")]) {return [this.data[0],item]}
+ }
+ return [this.data[0],MML.mo(MML.entity("#x2061")).With({texClass:MML.TEXCLASS.NONE}),item];
+ }
+ return this.SUPER(arguments).checkItem.apply(this,arguments);
+ }
+ });
+
+ STACKITEM.not = STACKITEM.Subclass({
+ type: "not",
+ checkItem: function (item) {
+ var mml, c;
+ if (item.type === "open" || item.type === "left") {return true}
+ if (item.type === "mml" && item.data[0].type.match(/^(mo|mi|mtext)$/)) {
+ mml = item.data[0], c = mml.data.join("");
+ if (c.length === 1 && !mml.movesupsub && mml.data.length === 1) {
+ c = STACKITEM.not.remap[c.charCodeAt(0)];
+ if (c) {mml.SetData(0,MML.chars(String.fromCharCode(c)))}
+ else {mml.Append(MML.chars("\u0338"))}
+ return item;
+ }
+ }
+ // \mathrel{\rlap{\notChar}}
+ mml = MML.mpadded(MML.mtext("\u29F8")).With({width:0});
+ mml = MML.TeXAtom(mml).With({texClass:MML.TEXCLASS.REL});
+ return [mml,item];
+ }
+ });
+ STACKITEM.not.remap = {
+ 0x2190:0x219A, 0x2192:0x219B, 0x2194:0x21AE,
+ 0x21D0:0x21CD, 0x21D2:0x21CF, 0x21D4:0x21CE,
+ 0x2208:0x2209, 0x220B:0x220C, 0x2223:0x2224, 0x2225:0x2226,
+ 0x223C:0x2241, 0x007E:0x2241, 0x2243:0x2244, 0x2245:0x2247,
+ 0x2248:0x2249, 0x224D:0x226D, 0x003D:0x2260, 0x2261:0x2262,
+ 0x003C:0x226E, 0x003E:0x226F, 0x2264:0x2270, 0x2265:0x2271,
+ 0x2272:0x2274, 0x2273:0x2275, 0x2276:0x2278, 0x2277:0x2279,
+ 0x227A:0x2280, 0x227B:0x2281, 0x2282:0x2284, 0x2283:0x2285,
+ 0x2286:0x2288, 0x2287:0x2289, 0x22A2:0x22AC, 0x22A8:0x22AD,
+ 0x22A9:0x22AE, 0x22AB:0x22AF, 0x227C:0x22E0, 0x227D:0x22E1,
+ 0x2291:0x22E2, 0x2292:0x22E3, 0x22B2:0x22EA, 0x22B3:0x22EB,
+ 0x22B4:0x22EC, 0x22B5:0x22ED, 0x2203:0x2204
+ };
+
+ STACKITEM.dots = STACKITEM.Subclass({
+ type: "dots",
+ checkItem: function (item) {
+ if (item.type === "open" || item.type === "left") {return true}
+ var dots = this.ldots;
+ if (item.type === "mml" && item.data[0].isEmbellished()) {
+ var tclass = item.data[0].CoreMO().Get("texClass");
+ if (tclass === MML.TEXCLASS.BIN || tclass === MML.TEXCLASS.REL) {dots = this.cdots}
+ }
+ return [dots,item];
+ }
+ });
+
+
+ var TEXDEF = {
+ //
+ // Add new definitions without overriding user-defined ones
+ //
+ Add: function (src,dst,nouser) {
+ if (!dst) {dst = this}
+ for (var id in src) {if (src.hasOwnProperty(id)) {
+ if (typeof src[id] === 'object' && !isArray(src[id]) &&
+ (typeof dst[id] === 'object' || typeof dst[id] === 'function'))
+ {this.Add(src[id],dst[id],src[id],nouser)}
+ else if (!dst[id] || !dst[id].isUser || !nouser) {dst[id] = src[id]}
+ }}
+ return dst;
+ }
+ };
+ var STARTUP = function () {
+ MML = MathJax.ElementJax.mml;
+ HUB.Insert(TEXDEF,{
+
+ // patterns for letters and numbers
+ letter: /[a-z]/i,
+ digit: /[0-9.]/,
+ number: /^(?:[0-9]+(?:\{,\}[0-9]{3})*(?:\.[0-9]*)*|\.[0-9]+)/,
+
+ special: {
+ '\\': 'ControlSequence',
+ '{': 'Open',
+ '}': 'Close',
+ '~': 'Tilde',
+ '^': 'Superscript',
+ '_': 'Subscript',
+ ' ': 'Space',
+ "\t": 'Space',
+ "\r": 'Space',
+ "\n": 'Space',
+ "'": 'Prime',
+ '%': 'Comment',
+ '&': 'Entry',
+ '#': 'Hash',
+ '\u00A0': 'Space',
+ '\u2019': 'Prime'
+ },
+
+ remap: {
+ '-': '2212',
+ '*': '2217',
+ '`': '2018' // map ` to back quote
+ },
+
+ mathchar0mi: {
+ // Lower-case greek
+ alpha: '03B1',
+ beta: '03B2',
+ gamma: '03B3',
+ delta: '03B4',
+ epsilon: '03F5',
+ zeta: '03B6',
+ eta: '03B7',
+ theta: '03B8',
+ iota: '03B9',
+ kappa: '03BA',
+ lambda: '03BB',
+ mu: '03BC',
+ nu: '03BD',
+ xi: '03BE',
+ omicron: '03BF', // added for completeness
+ pi: '03C0',
+ rho: '03C1',
+ sigma: '03C3',
+ tau: '03C4',
+ upsilon: '03C5',
+ phi: '03D5',
+ chi: '03C7',
+ psi: '03C8',
+ omega: '03C9',
+ varepsilon: '03B5',
+ vartheta: '03D1',
+ varpi: '03D6',
+ varrho: '03F1',
+ varsigma: '03C2',
+ varphi: '03C6',
+
+ // Ord symbols
+ S: ['00A7',{mathvariant: MML.VARIANT.NORMAL}],
+ aleph: ['2135',{mathvariant: MML.VARIANT.NORMAL}],
+ hbar: ['210F',{variantForm:true}],
+ imath: '0131',
+ jmath: '0237',
+ ell: '2113',
+ wp: ['2118',{mathvariant: MML.VARIANT.NORMAL}],
+ Re: ['211C',{mathvariant: MML.VARIANT.NORMAL}],
+ Im: ['2111',{mathvariant: MML.VARIANT.NORMAL}],
+ partial: ['2202',{mathvariant: MML.VARIANT.NORMAL}],
+ infty: ['221E',{mathvariant: MML.VARIANT.NORMAL}],
+ prime: ['2032',{mathvariant: MML.VARIANT.NORMAL, variantForm:true}],
+ emptyset: ['2205',{mathvariant: MML.VARIANT.NORMAL}],
+ nabla: ['2207',{mathvariant: MML.VARIANT.NORMAL}],
+ top: ['22A4',{mathvariant: MML.VARIANT.NORMAL}],
+ bot: ['22A5',{mathvariant: MML.VARIANT.NORMAL}],
+ angle: ['2220',{mathvariant: MML.VARIANT.NORMAL}],
+ triangle: ['25B3',{mathvariant: MML.VARIANT.NORMAL}],
+ backslash: ['2216',{mathvariant: MML.VARIANT.NORMAL, variantForm:true}],
+ forall: ['2200',{mathvariant: MML.VARIANT.NORMAL}],
+ exists: ['2203',{mathvariant: MML.VARIANT.NORMAL}],
+ neg: ['00AC',{mathvariant: MML.VARIANT.NORMAL}],
+ lnot: ['00AC',{mathvariant: MML.VARIANT.NORMAL}],
+ flat: ['266D',{mathvariant: MML.VARIANT.NORMAL}],
+ natural: ['266E',{mathvariant: MML.VARIANT.NORMAL}],
+ sharp: ['266F',{mathvariant: MML.VARIANT.NORMAL}],
+ clubsuit: ['2663',{mathvariant: MML.VARIANT.NORMAL}],
+ diamondsuit: ['2662',{mathvariant: MML.VARIANT.NORMAL}],
+ heartsuit: ['2661',{mathvariant: MML.VARIANT.NORMAL}],
+ spadesuit: ['2660',{mathvariant: MML.VARIANT.NORMAL}]
+ },
+
+ mathchar0mo: {
+ surd: '221A',
+
+ // big ops
+ coprod: ['2210',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigvee: ['22C1',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigwedge: ['22C0',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ biguplus: ['2A04',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigcap: ['22C2',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigcup: ['22C3',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ 'int': ['222B',{texClass: MML.TEXCLASS.OP}],
+ intop: ['222B',{texClass: MML.TEXCLASS.OP, movesupsub:true, movablelimits:true}],
+ iint: ['222C',{texClass: MML.TEXCLASS.OP}],
+ iiint: ['222D',{texClass: MML.TEXCLASS.OP}],
+ prod: ['220F',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ sum: ['2211',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigotimes: ['2A02',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigoplus: ['2A01',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ bigodot: ['2A00',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ oint: ['222E',{texClass: MML.TEXCLASS.OP}],
+ bigsqcup: ['2A06',{texClass: MML.TEXCLASS.OP, movesupsub:true}],
+ smallint: ['222B',{largeop:false}],
+
+ // binary operations
+ triangleleft: '25C3',
+ triangleright: '25B9',
+ bigtriangleup: '25B3',
+ bigtriangledown: '25BD',
+ wedge: '2227',
+ land: '2227',
+ vee: '2228',
+ lor: '2228',
+ cap: '2229',
+ cup: '222A',
+ ddagger: '2021',
+ dagger: '2020',
+ sqcap: '2293',
+ sqcup: '2294',
+ uplus: '228E',
+ amalg: '2A3F',
+ diamond: '22C4',
+ bullet: '2219',
+ wr: '2240',
+ div: '00F7',
+ odot: ['2299',{largeop: false}],
+ oslash: ['2298',{largeop: false}],
+ otimes: ['2297',{largeop: false}],
+ ominus: ['2296',{largeop: false}],
+ oplus: ['2295',{largeop: false}],
+ mp: '2213',
+ pm: '00B1',
+ circ: '2218',
+ bigcirc: '25EF',
+ setminus: ['2216',{variantForm:true}],
+ cdot: '22C5',
+ ast: '2217',
+ times: '00D7',
+ star: '22C6',
+
+ // Relations
+ propto: '221D',
+ sqsubseteq: '2291',
+ sqsupseteq: '2292',
+ parallel: '2225',
+ mid: '2223',
+ dashv: '22A3',
+ vdash: '22A2',
+ leq: '2264',
+ le: '2264',
+ geq: '2265',
+ ge: '2265',
+ lt: '003C',
+ gt: '003E',
+ succ: '227B',
+ prec: '227A',
+ approx: '2248',
+ succeq: '2AB0', // or '227C',
+ preceq: '2AAF', // or '227D',
+ supset: '2283',
+ subset: '2282',
+ supseteq: '2287',
+ subseteq: '2286',
+ 'in': '2208',
+ ni: '220B',
+ notin: '2209',
+ owns: '220B',
+ gg: '226B',
+ ll: '226A',
+ sim: '223C',
+ simeq: '2243',
+ perp: '22A5',
+ equiv: '2261',
+ asymp: '224D',
+ smile: '2323',
+ frown: '2322',
+ ne: '2260',
+ neq: '2260',
+ cong: '2245',
+ doteq: '2250',
+ bowtie: '22C8',
+ models: '22A8',
+
+ notChar: '29F8',
+
+
+ // Arrows
+ Leftrightarrow: '21D4',
+ Leftarrow: '21D0',
+ Rightarrow: '21D2',
+ leftrightarrow: '2194',
+ leftarrow: '2190',
+ gets: '2190',
+ rightarrow: '2192',
+ to: '2192',
+ mapsto: '21A6',
+ leftharpoonup: '21BC',
+ leftharpoondown: '21BD',
+ rightharpoonup: '21C0',
+ rightharpoondown: '21C1',
+ nearrow: '2197',
+ searrow: '2198',
+ nwarrow: '2196',
+ swarrow: '2199',
+ rightleftharpoons: '21CC',
+ hookrightarrow: '21AA',
+ hookleftarrow: '21A9',
+ longleftarrow: '27F5',
+ Longleftarrow: '27F8',
+ longrightarrow: '27F6',
+ Longrightarrow: '27F9',
+ Longleftrightarrow: '27FA',
+ longleftrightarrow: '27F7',
+ longmapsto: '27FC',
+
+
+ // Misc.
+ ldots: '2026',
+ cdots: '22EF',
+ vdots: '22EE',
+ ddots: '22F1',
+ dotsc: '2026', // dots with commas
+ dotsb: '22EF', // dots with binary ops and relations
+ dotsm: '22EF', // dots with multiplication
+ dotsi: '22EF', // dots with integrals
+ dotso: '2026', // other dots
+
+ ldotp: ['002E', {texClass: MML.TEXCLASS.PUNCT}],
+ cdotp: ['22C5', {texClass: MML.TEXCLASS.PUNCT}],
+ colon: ['003A', {texClass: MML.TEXCLASS.PUNCT}]
+ },
+
+ mathchar7: {
+ Gamma: '0393',
+ Delta: '0394',
+ Theta: '0398',
+ Lambda: '039B',
+ Xi: '039E',
+ Pi: '03A0',
+ Sigma: '03A3',
+ Upsilon: '03A5',
+ Phi: '03A6',
+ Psi: '03A8',
+ Omega: '03A9',
+
+ '_': '005F',
+ '#': '0023',
+ '$': '0024',
+ '%': '0025',
+ '&': '0026',
+ And: '0026'
+ },
+
+ delimiter: {
+ '(': '(',
+ ')': ')',
+ '[': '[',
+ ']': ']',
+ '<': '27E8',
+ '>': '27E9',
+ '\\lt': '27E8',
+ '\\gt': '27E9',
+ '/': '/',
+ '|': ['|',{texClass:MML.TEXCLASS.ORD}],
+ '.': '',
+ '\\\\': '\\',
+ '\\lmoustache': '23B0', // non-standard
+ '\\rmoustache': '23B1', // non-standard
+ '\\lgroup': '27EE', // non-standard
+ '\\rgroup': '27EF', // non-standard
+ '\\arrowvert': '23D0',
+ '\\Arrowvert': '2016',
+ '\\bracevert': '23AA', // non-standard
+ '\\Vert': ['2016',{texClass:MML.TEXCLASS.ORD}],
+ '\\|': ['2016',{texClass:MML.TEXCLASS.ORD}],
+ '\\vert': ['|',{texClass:MML.TEXCLASS.ORD}],
+ '\\uparrow': '2191',
+ '\\downarrow': '2193',
+ '\\updownarrow': '2195',
+ '\\Uparrow': '21D1',
+ '\\Downarrow': '21D3',
+ '\\Updownarrow': '21D5',
+ '\\backslash': '\\',
+ '\\rangle': '27E9',
+ '\\langle': '27E8',
+ '\\rbrace': '}',
+ '\\lbrace': '{',
+ '\\}': '}',
+ '\\{': '{',
+ '\\rceil': '2309',
+ '\\lceil': '2308',
+ '\\rfloor': '230B',
+ '\\lfloor': '230A',
+ '\\lbrack': '[',
+ '\\rbrack': ']'
+ },
+
+ macros: {
+ displaystyle: ['SetStyle','D',true,0],
+ textstyle: ['SetStyle','T',false,0],
+ scriptstyle: ['SetStyle','S',false,1],
+ scriptscriptstyle: ['SetStyle','SS',false,2],
+
+ rm: ['SetFont',MML.VARIANT.NORMAL],
+ mit: ['SetFont',MML.VARIANT.ITALIC],
+ oldstyle: ['SetFont',MML.VARIANT.OLDSTYLE],
+ cal: ['SetFont',MML.VARIANT.CALIGRAPHIC],
+ it: ['SetFont',"-tex-mathit"], // needs special handling
+ bf: ['SetFont',MML.VARIANT.BOLD],
+ bbFont: ['SetFont',MML.VARIANT.DOUBLESTRUCK],
+ scr: ['SetFont',MML.VARIANT.SCRIPT],
+ frak: ['SetFont',MML.VARIANT.FRAKTUR],
+ sf: ['SetFont',MML.VARIANT.SANSSERIF],
+ tt: ['SetFont',MML.VARIANT.MONOSPACE],
+
+// font:
+
+ tiny: ['SetSize',0.5],
+ Tiny: ['SetSize',0.6], // non-standard
+ scriptsize: ['SetSize',0.7],
+ small: ['SetSize',0.85],
+ normalsize: ['SetSize',1.0],
+ large: ['SetSize',1.2],
+ Large: ['SetSize',1.44],
+ LARGE: ['SetSize',1.73],
+ huge: ['SetSize',2.07],
+ Huge: ['SetSize',2.49],
+
+ arcsin: ['NamedFn'],
+ arccos: ['NamedFn'],
+ arctan: ['NamedFn'],
+ arg: ['NamedFn'],
+ cos: ['NamedFn'],
+ cosh: ['NamedFn'],
+ cot: ['NamedFn'],
+ coth: ['NamedFn'],
+ csc: ['NamedFn'],
+ deg: ['NamedFn'],
+ det: 'NamedOp',
+ dim: ['NamedFn'],
+ exp: ['NamedFn'],
+ gcd: 'NamedOp',
+ hom: ['NamedFn'],
+ inf: 'NamedOp',
+ ker: ['NamedFn'],
+ lg: ['NamedFn'],
+ lim: 'NamedOp',
+ liminf: ['NamedOp','lim&thinsp;inf'],
+ limsup: ['NamedOp','lim&thinsp;sup'],
+ ln: ['NamedFn'],
+ log: ['NamedFn'],
+ max: 'NamedOp',
+ min: 'NamedOp',
+ Pr: 'NamedOp',
+ sec: ['NamedFn'],
+ sin: ['NamedFn'],
+ sinh: ['NamedFn'],
+ sup: 'NamedOp',
+ tan: ['NamedFn'],
+ tanh: ['NamedFn'],
+
+ limits: ['Limits',1],
+ nolimits: ['Limits',0],
+
+ overline: ['UnderOver','00AF',null,1],
+ underline: ['UnderOver','005F'],
+ overbrace: ['UnderOver','23DE',1],
+ underbrace: ['UnderOver','23DF',1],
+ overparen: ['UnderOver','23DC'],
+ underparen: ['UnderOver','23DD'],
+ overrightarrow: ['UnderOver','2192'],
+ underrightarrow: ['UnderOver','2192'],
+ overleftarrow: ['UnderOver','2190'],
+ underleftarrow: ['UnderOver','2190'],
+ overleftrightarrow: ['UnderOver','2194'],
+ underleftrightarrow: ['UnderOver','2194'],
+
+ overset: 'Overset',
+ underset: 'Underset',
+ stackrel: ['Macro','\\mathrel{\\mathop{#2}\\limits^{#1}}',2],
+
+ over: 'Over',
+ overwithdelims: 'Over',
+ atop: 'Over',
+ atopwithdelims: 'Over',
+ above: 'Over',
+ abovewithdelims: 'Over',
+ brace: ['Over','{','}'],
+ brack: ['Over','[',']'],
+ choose: ['Over','(',')'],
+
+ frac: 'Frac',
+ sqrt: 'Sqrt',
+ root: 'Root',
+ uproot: ['MoveRoot','upRoot'],
+ leftroot: ['MoveRoot','leftRoot'],
+
+ left: 'LeftRight',
+ right: 'LeftRight',
+ middle: 'Middle',
+
+ llap: 'Lap',
+ rlap: 'Lap',
+ raise: 'RaiseLower',
+ lower: 'RaiseLower',
+ moveleft: 'MoveLeftRight',
+ moveright: 'MoveLeftRight',
+
+ ',': ['Spacer',MML.LENGTH.THINMATHSPACE],
+ ':': ['Spacer',MML.LENGTH.MEDIUMMATHSPACE], // for LaTeX
+ '>': ['Spacer',MML.LENGTH.MEDIUMMATHSPACE],
+ ';': ['Spacer',MML.LENGTH.THICKMATHSPACE],
+ '!': ['Spacer',MML.LENGTH.NEGATIVETHINMATHSPACE],
+ enspace: ['Spacer',".5em"],
+ quad: ['Spacer',"1em"],
+ qquad: ['Spacer',"2em"],
+ thinspace: ['Spacer',MML.LENGTH.THINMATHSPACE],
+ negthinspace: ['Spacer',MML.LENGTH.NEGATIVETHINMATHSPACE],
+
+ hskip: 'Hskip',
+ hspace: 'Hskip',
+ kern: 'Hskip',
+ mskip: 'Hskip',
+ mspace: 'Hskip',
+ mkern: 'Hskip',
+ rule: 'rule',
+ Rule: ['Rule'],
+ Space: ['Rule','blank'],
+
+ big: ['MakeBig',MML.TEXCLASS.ORD,0.85],
+ Big: ['MakeBig',MML.TEXCLASS.ORD,1.15],
+ bigg: ['MakeBig',MML.TEXCLASS.ORD,1.45],
+ Bigg: ['MakeBig',MML.TEXCLASS.ORD,1.75],
+ bigl: ['MakeBig',MML.TEXCLASS.OPEN,0.85],
+ Bigl: ['MakeBig',MML.TEXCLASS.OPEN,1.15],
+ biggl: ['MakeBig',MML.TEXCLASS.OPEN,1.45],
+ Biggl: ['MakeBig',MML.TEXCLASS.OPEN,1.75],
+ bigr: ['MakeBig',MML.TEXCLASS.CLOSE,0.85],
+ Bigr: ['MakeBig',MML.TEXCLASS.CLOSE,1.15],
+ biggr: ['MakeBig',MML.TEXCLASS.CLOSE,1.45],
+ Biggr: ['MakeBig',MML.TEXCLASS.CLOSE,1.75],
+ bigm: ['MakeBig',MML.TEXCLASS.REL,0.85],
+ Bigm: ['MakeBig',MML.TEXCLASS.REL,1.15],
+ biggm: ['MakeBig',MML.TEXCLASS.REL,1.45],
+ Biggm: ['MakeBig',MML.TEXCLASS.REL,1.75],
+
+ mathord: ['TeXAtom',MML.TEXCLASS.ORD],
+ mathop: ['TeXAtom',MML.TEXCLASS.OP],
+ mathopen: ['TeXAtom',MML.TEXCLASS.OPEN],
+ mathclose: ['TeXAtom',MML.TEXCLASS.CLOSE],
+ mathbin: ['TeXAtom',MML.TEXCLASS.BIN],
+ mathrel: ['TeXAtom',MML.TEXCLASS.REL],
+ mathpunct: ['TeXAtom',MML.TEXCLASS.PUNCT],
+ mathinner: ['TeXAtom',MML.TEXCLASS.INNER],
+
+ vcenter: ['TeXAtom',MML.TEXCLASS.VCENTER],
+
+ mathchoice: ['Extension','mathchoice'],
+ buildrel: 'BuildRel',
+
+ hbox: ['HBox',0],
+ text: 'HBox',
+ mbox: ['HBox',0],
+ fbox: 'FBox',
+
+ strut: 'Strut',
+ mathstrut: ['Macro','\\vphantom{(}'],
+ phantom: 'Phantom',
+ vphantom: ['Phantom',1,0],
+ hphantom: ['Phantom',0,1],
+ smash: 'Smash',
+
+ acute: ['Accent', "00B4"], // or 0301 or 02CA
+ grave: ['Accent', "0060"], // or 0300 or 02CB
+ ddot: ['Accent', "00A8"], // or 0308
+ tilde: ['Accent', "007E"], // or 0303 or 02DC
+ bar: ['Accent', "00AF"], // or 0304 or 02C9
+ breve: ['Accent', "02D8"], // or 0306
+ check: ['Accent', "02C7"], // or 030C
+ hat: ['Accent', "005E"], // or 0302 or 02C6
+ vec: ['Accent', "2192"], // or 20D7
+ dot: ['Accent', "02D9"], // or 0307
+ widetilde: ['Accent', "007E",1], // or 0303 or 02DC
+ widehat: ['Accent', "005E",1], // or 0302 or 02C6
+
+ matrix: 'Matrix',
+ array: 'Matrix',
+ pmatrix: ['Matrix','(',')'],
+ cases: ['Matrix','{','',"left left",null,".1em",null,true],
+ eqalign: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D'],
+ displaylines: ['Matrix',null,null,"center",null,".5em",'D'],
+ cr: 'Cr',
+ '\\': 'CrLaTeX',
+ newline: ['CrLaTeX',true],
+ hline: ['HLine','solid'],
+ hdashline: ['HLine','dashed'],
+// noalign: 'HandleNoAlign',
+ eqalignno: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D',null,"right"],
+ leqalignno: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D',null,"left"],
+ hfill: 'HFill',
+ hfil: 'HFill', // \hfil treated as \hfill for now
+ hfilll: 'HFill', // \hfilll treated as \hfill for now
+
+ // TeX substitution macros
+ bmod: ['Macro','\\mmlToken{mo}[lspace="thickmathspace" rspace="thickmathspace"]{mod}'],
+ pmod: ['Macro','\\pod{\\mmlToken{mi}{mod}\\kern 6mu #1}',1],
+ mod: ['Macro','\\mathchoice{\\kern18mu}{\\kern12mu}{\\kern12mu}{\\kern12mu}\\mmlToken{mi}{mod}\\,\\,#1',1],
+ pod: ['Macro','\\mathchoice{\\kern18mu}{\\kern8mu}{\\kern8mu}{\\kern8mu}(#1)',1],
+ iff: ['Macro','\\;\\Longleftrightarrow\\;'],
+ skew: ['Macro','{{#2{#3\\mkern#1mu}\\mkern-#1mu}{}}',3],
+ mathcal: ['Macro','{\\cal #1}',1],
+ mathscr: ['Macro','{\\scr #1}',1],
+ mathrm: ['Macro','{\\rm #1}',1],
+ mathbf: ['Macro','{\\bf #1}',1],
+ mathbb: ['Macro','{\\bbFont #1}',1],
+ Bbb: ['Macro','{\\bbFont #1}',1],
+ mathit: ['Macro','{\\it #1}',1],
+ mathfrak: ['Macro','{\\frak #1}',1],
+ mathsf: ['Macro','{\\sf #1}',1],
+ mathtt: ['Macro','{\\tt #1}',1],
+ textrm: ['Macro','\\mathord{\\rm\\text{#1}}',1],
+ textit: ['Macro','\\mathord{\\it\\text{#1}}',1],
+ textbf: ['Macro','\\mathord{\\bf\\text{#1}}',1],
+ textsf: ['Macro','\\mathord{\\sf\\text{#1}}',1],
+ texttt: ['Macro','\\mathord{\\tt\\text{#1}}',1],
+ pmb: ['Macro','\\rlap{#1}\\kern1px{#1}',1],
+ TeX: ['Macro','T\\kern-.14em\\lower.5ex{E}\\kern-.115em X'],
+ LaTeX: ['Macro','L\\kern-.325em\\raise.21em{\\scriptstyle{A}}\\kern-.17em\\TeX'],
+ ' ': ['Macro','\\text{ }'],
+
+ // Specially handled
+ not: 'Not',
+ dots: 'Dots',
+ space: 'Tilde',
+ '\u00A0': 'Tilde',
+
+
+ // LaTeX
+ begin: 'BeginEnd',
+ end: 'BeginEnd',
+
+ newcommand: ['Extension','newcommand'],
+ renewcommand: ['Extension','newcommand'],
+ newenvironment: ['Extension','newcommand'],
+ renewenvironment: ['Extension','newcommand'],
+ def: ['Extension','newcommand'],
+ 'let': ['Extension','newcommand'],
+
+ verb: ['Extension','verb'],
+
+ boldsymbol: ['Extension','boldsymbol'],
+
+ tag: ['Extension','AMSmath'],
+ notag: ['Extension','AMSmath'],
+ label: ['Extension','AMSmath'],
+ ref: ['Extension','AMSmath'],
+ eqref: ['Extension','AMSmath'],
+ nonumber: ['Macro','\\notag'],
+
+ // Extensions to TeX
+ unicode: ['Extension','unicode'],
+ color: 'Color',
+
+ href: ['Extension','HTML'],
+ 'class': ['Extension','HTML'],
+ style: ['Extension','HTML'],
+ cssId: ['Extension','HTML'],
+ bbox: ['Extension','bbox'],
+
+ mmlToken: 'MmlToken',
+
+ require: 'Require'
+
+ },
+
+ environment: {
+ array: ['AlignedArray'],
+ matrix: ['Array',null,null,null,'c'],
+ pmatrix: ['Array',null,'(',')','c'],
+ bmatrix: ['Array',null,'[',']','c'],
+ Bmatrix: ['Array',null,'\\{','\\}','c'],
+ vmatrix: ['Array',null,'\\vert','\\vert','c'],
+ Vmatrix: ['Array',null,'\\Vert','\\Vert','c'],
+ cases: ['Array',null,'\\{','.','ll',null,".2em",'T'],
+
+ equation: [null,'Equation'],
+ 'equation*': [null,'Equation'],
+
+ eqnarray: ['ExtensionEnv',null,'AMSmath'],
+ 'eqnarray*': ['ExtensionEnv',null,'AMSmath'],
+
+ align: ['ExtensionEnv',null,'AMSmath'],
+ 'align*': ['ExtensionEnv',null,'AMSmath'],
+ aligned: ['ExtensionEnv',null,'AMSmath'],
+ multline: ['ExtensionEnv',null,'AMSmath'],
+ 'multline*': ['ExtensionEnv',null,'AMSmath'],
+ split: ['ExtensionEnv',null,'AMSmath'],
+ gather: ['ExtensionEnv',null,'AMSmath'],
+ 'gather*': ['ExtensionEnv',null,'AMSmath'],
+ gathered: ['ExtensionEnv',null,'AMSmath'],
+ alignat: ['ExtensionEnv',null,'AMSmath'],
+ 'alignat*': ['ExtensionEnv',null,'AMSmath'],
+ alignedat: ['ExtensionEnv',null,'AMSmath']
+ },
+
+ p_height: 1.2 / .85 // cmex10 height plus depth over .85
+
+ });
+
+ //
+ // Add macros defined in the configuration
+ //
+ if (this.config.Macros) {
+ var MACROS = this.config.Macros;
+ for (var id in MACROS) {if (MACROS.hasOwnProperty(id)) {
+ if (typeof(MACROS[id]) === "string") {TEXDEF.macros[id] = ['Macro',MACROS[id]]}
+ else {TEXDEF.macros[id] = ["Macro"].concat(MACROS[id])}
+ TEXDEF.macros[id].isUser = true;
+ }}
+ }
+ };
+
+ /************************************************************************/
+ /*
+ * The TeX Parser
+ */
+
+ var PARSE = MathJax.Object.Subclass({
+ Init: function (string,env) {
+ this.string = string; this.i = 0; this.macroCount = 0;
+ var ENV; if (env) {ENV = {}; for (var id in env) {if (env.hasOwnProperty(id)) {ENV[id] = env[id]}}}
+ this.stack = TEX.Stack(ENV,!!env);
+ this.Parse(); this.Push(STACKITEM.stop());
+ },
+ Parse: function () {
+ var c, n;
+ while (this.i < this.string.length) {
+ c = this.string.charAt(this.i++); n = c.charCodeAt(0);
+ if (n >= 0xD800 && n < 0xDC00) {c += this.string.charAt(this.i++)}
+ if (TEXDEF.special.hasOwnProperty(c)) {this[TEXDEF.special[c]](c)}
+ else if (TEXDEF.letter.test(c)) {this.Variable(c)}
+ else if (TEXDEF.digit.test(c)) {this.Number(c)}
+ else {this.Other(c)}
+ }
+ },
+ Push: function () {this.stack.Push.apply(this.stack,arguments)},
+ mml: function () {
+ if (this.stack.Top().type !== "mml") {return null}
+ return this.stack.Top().data[0];
+ },
+ mmlToken: function (token) {return token}, // used by boldsymbol extension
+
+ /************************************************************************/
+ /*
+ * Handle various token classes
+ */
+
+ /*
+ * Lookup a control-sequence and process it
+ */
+ ControlSequence: function (c) {
+ var name = this.GetCS(), macro = this.csFindMacro(name);
+ if (macro) {
+ if (!isArray(macro)) {macro = [macro]}
+ var fn = macro[0]; if (!(fn instanceof Function)) {fn = this[fn]}
+ fn.apply(this,[c+name].concat(macro.slice(1)));
+ } else if (TEXDEF.mathchar0mi.hasOwnProperty(name)) {this.csMathchar0mi(name,TEXDEF.mathchar0mi[name])}
+ else if (TEXDEF.mathchar0mo.hasOwnProperty(name)) {this.csMathchar0mo(name,TEXDEF.mathchar0mo[name])}
+ else if (TEXDEF.mathchar7.hasOwnProperty(name)) {this.csMathchar7(name,TEXDEF.mathchar7[name])}
+ else if (TEXDEF.delimiter.hasOwnProperty("\\"+name)) {this.csDelimiter(name,TEXDEF.delimiter["\\"+name])}
+ else {this.csUndefined(c+name)}
+ },
+ //
+ // Look up a macro in the macros list
+ // (overridden in begingroup extension)
+ //
+ csFindMacro: function (name) {
+ return (TEXDEF.macros.hasOwnProperty(name) ? TEXDEF.macros[name] : null);
+ },
+ //
+ // Handle normal mathchar (as an mi)
+ //
+ csMathchar0mi: function (name,mchar) {
+ var def = {mathvariant: MML.VARIANT.ITALIC};
+ if (isArray(mchar)) {def = mchar[1]; mchar = mchar[0]}
+ this.Push(this.mmlToken(MML.mi(MML.entity("#x"+mchar)).With(def)));
+ },
+ //
+ // Handle normal mathchar (as an mo)
+ //
+ csMathchar0mo: function (name,mchar) {
+ var def = {stretchy: false};
+ if (isArray(mchar)) {def = mchar[1]; def.stretchy = false; mchar = mchar[0]}
+ this.Push(this.mmlToken(MML.mo(MML.entity("#x"+mchar)).With(def)));
+ },
+ //
+ // Handle mathchar in current family
+ //
+ csMathchar7: function (name,mchar) {
+ var def = {mathvariant: MML.VARIANT.NORMAL};
+ if (isArray(mchar)) {def = mchar[1]; mchar = mchar[0]}
+ if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
+ this.Push(this.mmlToken(MML.mi(MML.entity("#x"+mchar)).With(def)));
+ },
+ //
+ // Handle delimiter
+ //
+ csDelimiter: function (name,delim) {
+ var def = {};
+ if (isArray(delim)) {def = delim[1]; delim = delim[0]}
+ if (delim.length === 4) {delim = MML.entity('#x'+delim)} else {delim = MML.chars(delim)}
+ this.Push(this.mmlToken(MML.mo(delim).With({fence: false, stretchy: false}).With(def)));
+ },
+ //
+ // Handle undefined control sequence
+ // (overridden in noUndefined extension)
+ //
+ csUndefined: function (name) {
+ TEX.Error(["UndefinedControlSequence","Undefined control sequence %1",name]);
+ },
+
+ /*
+ * Handle a variable (a single letter)
+ */
+ Variable: function (c) {
+ var def = {}; if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
+ this.Push(this.mmlToken(MML.mi(MML.chars(c)).With(def)));
+ },
+
+ /*
+ * Determine the extent of a number (pattern may need work)
+ */
+ Number: function (c) {
+ var mml, n = this.string.slice(this.i-1).match(TEXDEF.number);
+ if (n) {mml = MML.mn(n[0].replace(/[{}]/g,"")); this.i += n[0].length - 1}
+ else {mml = MML.mo(MML.chars(c))}
+ if (this.stack.env.font) {mml.mathvariant = this.stack.env.font}
+ this.Push(this.mmlToken(mml));
+ },
+
+ /*
+ * Handle { and }
+ */
+ Open: function (c) {this.Push(STACKITEM.open())},
+ Close: function (c) {this.Push(STACKITEM.close())},
+
+ /*
+ * Handle tilde and spaces
+ */
+ Tilde: function (c) {this.Push(MML.mtext(MML.chars(NBSP)))},
+ Space: function (c) {},
+
+ /*
+ * Handle ^, _, and '
+ */
+ Superscript: function (c) {
+ if (this.GetNext().match(/\d/)) // don't treat numbers as a unit
+ {this.string = this.string.substr(0,this.i+1)+" "+this.string.substr(this.i+1)}
+ var primes, base, top = this.stack.Top();
+ if (top.type === "prime") {base = top.data[0]; primes = top.data[1]; this.stack.Pop()}
+ else {base = this.stack.Prev(); if (!base) {base = MML.mi("")}}
+ if (base.isEmbellishedWrapper) {base = base.data[0].data[0]}
+ var movesupsub = base.movesupsub, position = base.sup;
+ if ((base.type === "msubsup" && base.data[base.sup]) ||
+ (base.type === "munderover" && base.data[base.over] && !base.subsupOK))
+ {TEX.Error(["DoubleExponent","Double exponent: use braces to clarify"])}
+ if (base.type !== "msubsup") {
+ if (movesupsub) {
+ if (base.type !== "munderover" || base.data[base.over]) {
+ if (base.movablelimits && base.isa(MML.mi)) {base = this.mi2mo(base)}
+ base = MML.munderover(base,null,null).With({movesupsub:true})
+ }
+ position = base.over;
+ } else {
+ base = MML.msubsup(base,null,null);
+ position = base.sup;
+ }
+ }
+ this.Push(STACKITEM.subsup(base).With({
+ position: position, primes: primes, movesupsub: movesupsub
+ }));
+ },
+ Subscript: function (c) {
+ if (this.GetNext().match(/\d/)) // don't treat numbers as a unit
+ {this.string = this.string.substr(0,this.i+1)+" "+this.string.substr(this.i+1)}
+ var primes, base, top = this.stack.Top();
+ if (top.type === "prime") {base = top.data[0]; primes = top.data[1]; this.stack.Pop()}
+ else {base = this.stack.Prev(); if (!base) {base = MML.mi("")}}
+ if (base.isEmbellishedWrapper) {base = base.data[0].data[0]}
+ var movesupsub = base.movesupsub, position = base.sub;
+ if ((base.type === "msubsup" && base.data[base.sub]) ||
+ (base.type === "munderover" && base.data[base.under] && !base.subsupOK))
+ {TEX.Error(["DoubleSubscripts","Double subscripts: use braces to clarify"])}
+ if (base.type !== "msubsup") {
+ if (movesupsub) {
+ if (base.type !== "munderover" || base.data[base.under]) {
+ if (base.movablelimits && base.isa(MML.mi)) {base = this.mi2mo(base)}
+ base = MML.munderover(base,null,null).With({movesupsub:true})
+ }
+ position = base.under;
+ } else {
+ base = MML.msubsup(base,null,null);
+ position = base.sub;
+ }
+ }
+ this.Push(STACKITEM.subsup(base).With({
+ position: position, primes: primes, movesupsub: movesupsub
+ }));
+ },
+ PRIME: "\u2032", SMARTQUOTE: "\u2019",
+ Prime: function (c) {
+ var base = this.stack.Prev(); if (!base) {base = MML.mi()}
+ if (base.type === "msubsup" && base.data[base.sup]) {
+ TEX.Error(["DoubleExponentPrime",
+ "Prime causes double exponent: use braces to clarify"]);
+ }
+ var sup = ""; this.i--;
+ do {sup += this.PRIME; this.i++, c = this.GetNext()}
+ while (c === "'" || c === this.SMARTQUOTE);
+ sup = ["","\u2032","\u2033","\u2034","\u2057"][sup.length] || sup;
+ this.Push(STACKITEM.prime(base,this.mmlToken(MML.mo(sup))));
+ },
+ mi2mo: function (mi) {
+ var mo = MML.mo(); mo.Append.apply(mo,mi.data); var id;
+ for (id in mo.defaults)
+ {if (mo.defaults.hasOwnProperty(id) && mi[id] != null) {mo[id] = mi[id]}}
+ for (id in MML.copyAttributes)
+ {if (MML.copyAttributes.hasOwnProperty(id) && mi[id] != null) {mo[id] = mi[id]}}
+ mo.lspace = mo.rspace = "0"; // prevent mo from having space in NativeMML
+ mo.useMMLspacing &= ~(mo.SPACE_ATTR.lspace | mo.SPACE_ATTR.rspace); // don't count these explicit settings
+ return mo;
+ },
+
+ /*
+ * Handle comments
+ */
+ Comment: function (c) {
+ while (this.i < this.string.length && this.string.charAt(this.i) != "\n") {this.i++}
+ },
+
+ /*
+ * Handle hash marks outside of definitions
+ */
+ Hash: function (c) {
+ TEX.Error(["CantUseHash1",
+ "You can't use 'macro parameter character #' in math mode"]);
+ },
+
+ /*
+ * Handle other characters (as <mo> elements)
+ */
+ Other: function (c) {
+ var def, mo;
+ if (this.stack.env.font) {def = {mathvariant: this.stack.env.font}}
+ if (TEXDEF.remap.hasOwnProperty(c)) {
+ c = TEXDEF.remap[c];
+ if (isArray(c)) {def = c[1]; c = c[0]}
+ mo = MML.mo(MML.entity('#x'+c)).With(def);
+ } else {
+ mo = MML.mo(c).With(def);
+ }
+ if (mo.autoDefault("stretchy",true)) {mo.stretchy = false}
+ if (mo.autoDefault("texClass",true) == "") {mo = MML.TeXAtom(mo)}
+ this.Push(this.mmlToken(mo));
+ },
+
+ /************************************************************************/
+ /*
+ * Macros
+ */
+
+ SetFont: function (name,font) {this.stack.env.font = font},
+ SetStyle: function (name,texStyle,style,level) {
+ this.stack.env.style = texStyle; this.stack.env.level = level;
+ this.Push(STACKITEM.style().With({styles: {displaystyle: style, scriptlevel: level}}));
+ },
+ SetSize: function (name,size) {
+ this.stack.env.size = size;
+ this.Push(STACKITEM.style().With({styles: {mathsize: size+"em"}})); // convert to absolute?
+ },
+
+ Color: function (name) {
+ var color = this.GetArgument(name);
+ var old = this.stack.env.color; this.stack.env.color = color;
+ var math = this.ParseArg(name);
+ if (old) {this.stack.env.color = old} else {delete this.stack.env.color}
+ this.Push(MML.mstyle(math).With({mathcolor: color}));
+ },
+
+ Spacer: function (name,space) {
+ this.Push(MML.mspace().With({width: space, mathsize: MML.SIZE.NORMAL, scriptlevel:0}));
+ },
+
+ LeftRight: function (name) {
+ this.Push(STACKITEM[name.substr(1)]().With({delim: this.GetDelimiter(name)}));
+ },
+
+ Middle: function (name) {
+ var delim = this.GetDelimiter(name);
+ this.Push(MML.TeXAtom().With({texClass:MML.TEXCLASS.CLOSE}));
+ if (this.stack.Top().type !== "left")
+ {TEX.Error(["MisplacedMiddle","%1 must be within \\left and \\right",name])}
+ this.Push(MML.mo(delim).With({stretchy:true}));
+ this.Push(MML.TeXAtom().With({texClass:MML.TEXCLASS.OPEN}));
+ },
+
+ NamedFn: function (name,id) {
+ if (!id) {id = name.substr(1)};
+ var mml = MML.mi(id).With({texClass: MML.TEXCLASS.OP});
+ this.Push(STACKITEM.fn(this.mmlToken(mml)));
+ },
+ NamedOp: function (name,id) {
+ if (!id) {id = name.substr(1)};
+ id = id.replace(/&thinsp;/,"\u2006");
+ var mml = MML.mo(id).With({
+ movablelimits: true,
+ movesupsub: true,
+ form: MML.FORM.PREFIX,
+ texClass: MML.TEXCLASS.OP
+ });
+ this.Push(this.mmlToken(mml));
+ },
+ Limits: function (name,limits) {
+ var op = this.stack.Prev("nopop");
+ if (!op || (op.Get("texClass") !== MML.TEXCLASS.OP && op.movesupsub == null))
+ {TEX.Error(["MisplacedLimits","%1 is allowed only on operators",name])}
+ var top = this.stack.Top();
+ if (op.type === "munderover" && !limits) {
+ op = top.data[top.data.length-1] = MML.msubsup.apply(MML.subsup,op.data);
+ } else if (op.type === "msubsup" && limits) {
+ op = top.data[top.data.length-1] = MML.munderover.apply(MML.underover,op.data);
+ }
+ op.movesupsub = (limits ? true : false);
+ op.Core().movablelimits = false;
+ if (op.movablelimits) op.movablelimits = false;
+ },
+
+ Over: function (name,open,close) {
+ var mml = STACKITEM.over().With({name: name});
+ if (open || close) {
+ mml.open = open; mml.close = close;
+ } else if (name.match(/withdelims$/)) {
+ mml.open = this.GetDelimiter(name);
+ mml.close = this.GetDelimiter(name);
+ }
+ if (name.match(/^\\above/)) {mml.thickness = this.GetDimen(name)}
+ else if (name.match(/^\\atop/) || open || close) {mml.thickness = 0}
+ this.Push(mml);
+ },
+
+ Frac: function (name) {
+ var num = this.ParseArg(name);
+ var den = this.ParseArg(name);
+ this.Push(MML.mfrac(num,den));
+ },
+
+ Sqrt: function (name) {
+ var n = this.GetBrackets(name), arg = this.GetArgument(name);
+ if (arg === "\\frac") {arg += "{"+this.GetArgument(arg)+"}{"+this.GetArgument(arg)+"}"}
+ var mml = TEX.Parse(arg,this.stack.env).mml();
+ if (!n) {mml = MML.msqrt.apply(MML,mml.array())}
+ else {mml = MML.mroot(mml,this.parseRoot(n))}
+ this.Push(mml);
+ },
+ Root: function (name) {
+ var n = this.GetUpTo(name,"\\of");
+ var arg = this.ParseArg(name);
+ this.Push(MML.mroot(arg,this.parseRoot(n)));
+ },
+ parseRoot: function (n) {
+ var env = this.stack.env, inRoot = env.inRoot; env.inRoot = true;
+ var parser = TEX.Parse(n,env); n = parser.mml(); var global = parser.stack.global;
+ if (global.leftRoot || global.upRoot) {
+ n = MML.mpadded(n);
+ if (global.leftRoot) {n.width = global.leftRoot}
+ if (global.upRoot) {n.voffset = global.upRoot; n.height = global.upRoot}
+ }
+ env.inRoot = inRoot;
+ return n;
+ },
+ MoveRoot: function (name,id) {
+ if (!this.stack.env.inRoot)
+ {TEX.Error(["MisplacedMoveRoot","%1 can appear only within a root",name])}
+ if (this.stack.global[id])
+ {TEX.Error(["MultipleMoveRoot","Multiple use of %1",name])}
+ var n = this.GetArgument(name);
+ if (!n.match(/-?[0-9]+/))
+ {TEX.Error(["IntegerArg","The argument to %1 must be an integer",name])}
+ n = (n/15)+"em";
+ if (n.substr(0,1) !== "-") {n = "+"+n}
+ this.stack.global[id] = n;
+ },
+
+ Accent: function (name,accent,stretchy) {
+ var c = this.ParseArg(name);
+ var def = {accent: true}; if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
+ var mml = this.mmlToken(MML.mo(MML.entity("#x"+accent)).With(def));
+ mml.stretchy = (stretchy ? true : false);
+ var mo = (c.isEmbellished() ? c.CoreMO() : c);
+ if (mo.isa(MML.mo)) mo.movablelimits = false;
+ this.Push(MML.TeXAtom(MML.munderover(c,null,mml).With({accent: true})));
+ },
+
+ UnderOver: function (name,c,stack,noaccent) {
+ var pos = {o: "over", u: "under"}[name.charAt(1)];
+ var base = this.ParseArg(name);
+ if (base.Get("movablelimits")) {base.movablelimits = false}
+ if (base.isa(MML.munderover) && base.isEmbellished()) {
+ base.Core().With({lspace:0,rspace:0}); // get spacing right for NativeMML
+ base = MML.mrow(MML.mo().With({rspace:0}),base); // add an empty <mi> so it's not embellished any more
+ }
+ var mml = MML.munderover(base,null,null);
+ mml.SetData(
+ mml[pos],
+ this.mmlToken(MML.mo(MML.entity("#x"+c)).With({stretchy:true, accent:!noaccent}))
+ );
+ if (stack) {mml = MML.TeXAtom(mml).With({texClass:MML.TEXCLASS.OP, movesupsub:true})}
+ this.Push(mml.With({subsupOK:true}));
+ },
+
+ Overset: function (name) {
+ var top = this.ParseArg(name), base = this.ParseArg(name);
+ base.movablelimits = false;
+ this.Push(MML.mover(base,top));
+ },
+ Underset: function (name) {
+ var bot = this.ParseArg(name), base = this.ParseArg(name);
+ base.movablelimits = false;
+ this.Push(MML.munder(base,bot));
+ },
+
+ TeXAtom: function (name,mclass) {
+ var def = {texClass: mclass}, mml;
+ if (mclass == MML.TEXCLASS.OP) {
+ def.movesupsub = def.movablelimits = true;
+ var arg = this.GetArgument(name);
+ var match = arg.match(/^\s*\\rm\s+([a-zA-Z0-9 ]+)$/);
+ if (match) {
+ def.mathvariant = MML.VARIANT.NORMAL;
+ mml = STACKITEM.fn(this.mmlToken(MML.mi(match[1]).With(def)));
+ } else {
+ mml = STACKITEM.fn(MML.TeXAtom(TEX.Parse(arg,this.stack.env).mml()).With(def));
+ }
+ } else {mml = MML.TeXAtom(this.ParseArg(name)).With(def)}
+ this.Push(mml);
+ },
+
+ MmlToken: function (name) {
+ var type = this.GetArgument(name),
+ attr = this.GetBrackets(name,"").replace(/^\s+/,""),
+ data = this.GetArgument(name),
+ def = {attrNames:[]}, match;
+ if (!MML[type] || !MML[type].prototype.isToken)
+ {TEX.Error(["NotMathMLToken","%1 is not a token element",type])}
+ while (attr !== "") {
+ match = attr.match(/^([a-z]+)\s*=\s*('[^']*'|"[^"]*"|[^ ,]*)\s*,?\s*/i);
+ if (!match)
+ {TEX.Error(["InvalidMathMLAttr","Invalid MathML attribute: %1",attr])}
+ if (MML[type].prototype.defaults[match[1]] == null && !this.MmlTokenAllow[match[1]]) {
+ TEX.Error(["UnknownAttrForElement",
+ "%1 is not a recognized attribute for %2",
+ match[1],type]);
+ }
+ var value = this.MmlFilterAttribute(match[1],match[2].replace(/^(['"])(.*)\1$/,"$2"));
+ if (value) {
+ if (value.toLowerCase() === "true") {value = true}
+ else if (value.toLowerCase() === "false") {value = false}
+ def[match[1]] = value;
+ def.attrNames.push(match[1]);
+ }
+ attr = attr.substr(match[0].length);
+ }
+ this.Push(this.mmlToken(MML[type](data).With(def)));
+ },
+ MmlFilterAttribute: function (name,value) {return value},
+ MmlTokenAllow: {
+ fontfamily:1, fontsize:1, fontweight:1, fontstyle:1,
+ color:1, background:1,
+ id:1, "class":1, href:1, style:1
+ },
+
+ Strut: function (name) {
+ this.Push(MML.mpadded(MML.mrow()).With({height: "8.6pt", depth: "3pt", width: 0}));
+ },
+
+ Phantom: function (name,v,h) {
+ var mml = this.ParseArg(name);
+ if (v || h) {
+ mml = MML.mpadded(mml);
+ if (h) {mml.height = mml.depth = 0}
+ if (v) {mml.width = 0}
+ }
+ this.Push(MML.TeXAtom(MML.mphantom(mml)));
+ },
+
+ Smash: function (name) {
+ var bt = this.trimSpaces(this.GetBrackets(name,""));
+ var smash = MML.mpadded(this.ParseArg(name));
+ switch (bt) {
+ case "b": smash.depth = 0; break;
+ case "t": smash.height = 0; break;
+ default: smash.height = smash.depth = 0;
+ }
+ this.Push(MML.TeXAtom(smash));
+ },
+
+ Lap: function (name) {
+ var mml = MML.mpadded(this.ParseArg(name)).With({width: 0});
+ if (name === "\\llap") {mml.lspace = "-1width"}
+ this.Push(MML.TeXAtom(mml));
+ },
+
+ RaiseLower: function (name) {
+ var h = this.GetDimen(name);
+ var item = STACKITEM.position().With({name: name, move: 'vertical'});
+ if (h.charAt(0) === '-') {h = h.slice(1); name = {raise: "\\lower", lower: "\\raise"}[name.substr(1)]}
+ if (name === "\\lower") {item.dh = '-'+h; item.dd = '+'+h} else {item.dh = '+'+h; item.dd = '-'+h}
+ this.Push(item);
+ },
+
+ MoveLeftRight: function (name) {
+ var h = this.GetDimen(name);
+ var nh = (h.charAt(0) === '-' ? h.slice(1) : '-'+h);
+ if (name === "\\moveleft") {var tmp = h; h = nh; nh = tmp}
+ this.Push(STACKITEM.position().With({
+ name: name, move: 'horizontal',
+ left: MML.mspace().With({width: h, mathsize: MML.SIZE.NORMAL}),
+ right: MML.mspace().With({width: nh, mathsize: MML.SIZE.NORMAL})
+ }));
+ },
+
+ Hskip: function (name) {
+ this.Push(MML.mspace().With({width: this.GetDimen(name), mathsize: MML.SIZE.NORMAL}));
+ },
+
+ Rule: function (name,style) {
+ var w = this.GetDimen(name),
+ h = this.GetDimen(name),
+ d = this.GetDimen(name);
+ var def = {width:w, height:h, depth:d};
+ if (style !== 'blank') {
+ def.mathbackground = (this.stack.env.color || "black");
+ }
+ this.Push(MML.mspace().With(def));
+ },
+ rule: function (name) {
+ var v = this.GetBrackets(name),
+ w = this.GetDimen(name),
+ h = this.GetDimen(name);
+ var mml = MML.mspace().With({
+ width: w, height:h,
+ mathbackground: (this.stack.env.color || "black")
+ });
+ if (v) {
+ mml = MML.mpadded(mml).With({voffset: v});
+ if (v.match(/^\-/)) {
+ mml.height = v;
+ mml.depth = '+' + v.substr(1);
+ } else {
+ mml.height = '+' + v;
+ }
+ }
+ this.Push(mml);
+ },
+
+ MakeBig: function (name,mclass,size) {
+ size *= TEXDEF.p_height;
+ size = String(size).replace(/(\.\d\d\d).+/,'$1')+"em";
+ var delim = this.GetDelimiter(name,true);
+ this.Push(MML.mstyle(MML.TeXAtom(MML.mo(delim).With({
+ minsize: size, maxsize: size,
+ fence: true, stretchy: true, symmetric: true
+ })).With({texClass: mclass})).With({scriptlevel: 0}));
+ },
+
+ BuildRel: function (name) {
+ var top = this.ParseUpTo(name,"\\over");
+ var bot = this.ParseArg(name);
+ this.Push(MML.TeXAtom(MML.munderover(bot,null,top)).With({texClass: MML.TEXCLASS.REL}));
+ },
+
+ HBox: function (name,style) {
+ this.Push.apply(this,this.InternalMath(this.GetArgument(name),style));
+ },
+
+ FBox: function (name) {
+ this.Push(MML.menclose.apply(MML,this.InternalMath(this.GetArgument(name))).With({notation:"box"}));
+ },
+
+ Not: function (name) {
+ this.Push(STACKITEM.not());
+ },
+
+ Dots: function (name) {
+ this.Push(STACKITEM.dots().With({
+ ldots: this.mmlToken(MML.mo(MML.entity("#x2026")).With({stretchy:false})),
+ cdots: this.mmlToken(MML.mo(MML.entity("#x22EF")).With({stretchy:false}))
+ }));
+ },
+
+ Require: function (name) {
+ var file = this.GetArgument(name)
+ .replace(/.*\//,"") // remove any leading path
+ .replace(/[^a-z0-9_.-]/ig,""); // remove illegal characters
+ this.Extension(null,file);
+ },
+
+ Extension: function (name,file,array) {
+ if (name && !typeof(name) === "string") {name = name.name}
+ file = TEX.extensionDir+"/"+file;
+ if (!file.match(/\.js$/)) {file += ".js"}
+ if (!AJAX.loaded[AJAX.fileURL(file)]) {
+ if (name != null) {delete TEXDEF[array || 'macros'][name.replace(/^\\/,"")]}
+ HUB.RestartAfter(AJAX.Require(file));
+ }
+ },
+
+ Macro: function (name,macro,argcount,def) {
+ if (argcount) {
+ var args = [];
+ if (def != null) {
+ var optional = this.GetBrackets(name);
+ args.push(optional == null ? def : optional);
+ }
+ for (var i = args.length; i < argcount; i++) {args.push(this.GetArgument(name))}
+ macro = this.SubstituteArgs(args,macro);
+ }
+ this.string = this.AddArgs(macro,this.string.slice(this.i));
+ this.i = 0;
+ if (++this.macroCount > TEX.config.MAXMACROS) {
+ TEX.Error(["MaxMacroSub1",
+ "MathJax maximum macro substitution count exceeded; " +
+ "is there a recursive macro call?"]);
+ }
+ },
+
+ Matrix: function (name,open,close,align,spacing,vspacing,style,cases,numbered) {
+ var c = this.GetNext();
+ if (c === "")
+ {TEX.Error(["MissingArgFor","Missing argument for %1",name])}
+ if (c === "{") {this.i++} else {this.string = c+"}"+this.string.slice(this.i+1); this.i = 0}
+ var array = STACKITEM.array().With({
+ requireClose: true,
+ arraydef: {
+ rowspacing: (vspacing||"4pt"),
+ columnspacing: (spacing||"1em")
+ }
+ });
+ if (cases) {array.isCases = true}
+ if (numbered) {array.isNumbered = true; array.arraydef.side = numbered}
+ if (open || close) {array.open = open; array.close = close}
+ if (style === "D") {array.arraydef.displaystyle = true}
+ if (align != null) {array.arraydef.columnalign = align}
+ this.Push(array);
+ },
+
+ Entry: function (name) {
+ this.Push(STACKITEM.cell().With({isEntry: true, name: name}));
+ if (this.stack.Top().isCases) {
+ //
+ // Make second column be in \text{...} (unless it is already
+ // in a \text{...}, for backward compatibility).
+ //
+ var string = this.string;
+ var braces = 0, close = -1, i = this.i, m = string.length;
+ //
+ // Look through the string character by character...
+ //
+ while (i < m) {
+ var c = string.charAt(i);
+ if (c === "{") {
+ //
+ // Increase the nested brace count and go on
+ //
+ braces++;
+ i++;
+ } else if (c === "}") {
+ //
+ // If there are too many close braces, just end (we will get an
+ // error message later when the rest of the string is parsed)
+ // Otherwise
+ // decrease the nested brace count,
+ // if it is now zero and we haven't already marked the end of the
+ // first brace group, record the position (use to check for \text{} later)
+ // go on to the next character.
+ //
+ if (braces === 0) {
+ m = 0;
+ } else {
+ braces--;
+ if (braces === 0 && close < 0) {
+ close = i - this.i;
+ }
+ i++;
+ }
+ } else if (c === "&" && braces === 0) {
+ //
+ // Extra alignment tabs are not allowed in cases
+ //
+ TEX.Error(["ExtraAlignTab","Extra alignment tab in \\cases text"]);
+ } else if (c === "\\") {
+ //
+ // If the macro is \cr or \\, end the search, otherwise skip the macro
+ // (multi-letter names don't matter, as we will skip the rest of the
+ // characters in the main loop)
+ //
+ if (string.substr(i).match(/^((\\cr)[^a-zA-Z]|\\\\)/)) {m = 0} else {i += 2}
+ } else {
+ //
+ // Go on to the next character
+ //
+ i++;
+ }
+ }
+ //
+ // Check if the second column text is already in \text{},
+ // If not, process the second column as text and continue parsing from there,
+ // (otherwise process the second column as normal, since it is in \text{}
+ //
+ var text = string.substr(this.i,i-this.i);
+ if (!text.match(/^\s*\\text[^a-zA-Z]/) || close !== text.replace(/\s+$/,'').length - 1) {
+ this.Push.apply(this,this.InternalMath(text,0));
+ this.i = i;
+ }
+ }
+ },
+
+ Cr: function (name) {
+ this.Push(STACKITEM.cell().With({isCR: true, name: name}));
+ },
+
+ CrLaTeX: function (name, nobrackets) {
+ var n;
+ if (!nobrackets && this.string.charAt(this.i) === "[") {
+ n = this.GetBrackets(name,"").replace(/ /g,"").replace(/,/,".");
+ if (n && !this.matchDimen(n)) {
+ TEX.Error(["BracketMustBeDimension",
+ "Bracket argument to %1 must be a dimension",name]);
+ }
+ }
+ this.Push(STACKITEM.cell().With({isCR: true, name: name, linebreak: true}));
+ var top = this.stack.Top();
+ if (top.isa(STACKITEM.array)) {
+ if (n && top.arraydef.rowspacing) {
+ var rows = top.arraydef.rowspacing.split(/ /);
+ if (!top.rowspacing) {top.rowspacing = this.dimen2em(rows[0])}
+ while (rows.length < top.table.length) {rows.push(this.Em(top.rowspacing))}
+ rows[top.table.length-1] = this.Em(Math.max(0,top.rowspacing+this.dimen2em(n)));
+ top.arraydef.rowspacing = rows.join(' ');
+ }
+ } else {
+ if (n) {this.Push(MML.mspace().With({depth:n}))}
+ this.Push(MML.mspace().With({linebreak:MML.LINEBREAK.NEWLINE}));
+ }
+ },
+ emPerInch: 7.2,
+ pxPerInch: 72,
+ matchDimen: function (dim) {
+ return dim.match(/^(-?(?:\.\d+|\d+(?:\.\d*)?))(px|pt|em|ex|mu|pc|in|mm|cm)$/);
+ },
+ dimen2em: function (dim) {
+ var match = this.matchDimen(dim);
+ var m = parseFloat(match[1]||"1"), unit = match[2];
+ if (unit === "em") {return m}
+ if (unit === "ex") {return m * .43}
+ if (unit === "pt") {return m / 10} // 10 pt to an em
+ if (unit === "pc") {return m * 1.2} // 12 pt to a pc
+ if (unit === "px") {return m * this.emPerInch / this.pxPerInch}
+ if (unit === "in") {return m * this.emPerInch}
+ if (unit === "cm") {return m * this.emPerInch / 2.54} // 2.54 cm to an inch
+ if (unit === "mm") {return m * this.emPerInch / 25.4} // 10 mm to a cm
+ if (unit === "mu") {return m / 18}
+ return 0;
+ },
+ Em: function (m) {
+ if (Math.abs(m) < .0006) {return "0em"}
+ return m.toFixed(3).replace(/\.?0+$/,"") + "em";
+ },
+
+ HLine: function (name,style) {
+ if (style == null) {style = "solid"}
+ var top = this.stack.Top();
+ if (!top.isa(STACKITEM.array) || top.data.length)
+ {TEX.Error(["Misplaced","Misplaced %1",name])}
+ if (top.table.length == 0) {
+ top.frame.push("top");
+ } else {
+ var lines = (top.arraydef.rowlines ? top.arraydef.rowlines.split(/ /) : []);
+ while (lines.length < top.table.length) {lines.push("none")}
+ lines[top.table.length-1] = style;
+ top.arraydef.rowlines = lines.join(' ');
+ }
+ },
+
+ HFill: function (name) {
+ var top = this.stack.Top();
+ if (top.isa(STACKITEM.array)) top.hfill.push(top.data.length);
+ else TEX.Error(["UnsupportedHFill","Unsupported use of %1",name]);
+ },
+
+
+
+ /************************************************************************/
+ /*
+ * LaTeX environments
+ */
+
+ BeginEnd: function (name) {
+ var env = this.GetArgument(name), isEnd = false;
+ if (env.match(/^\\end\\/)) {isEnd = true; env = env.substr(5)} // special \end{} for \newenvironment environments
+ if (env.match(/\\/i)) {TEX.Error(["InvalidEnv","Invalid environment name '%1'",env])}
+ var cmd = this.envFindName(env);
+ if (!cmd) {TEX.Error(["UnknownEnv","Unknown environment '%1'",env])}
+ if (!isArray(cmd)) {cmd = [cmd]}
+ var end = (isArray(cmd[1]) ? cmd[1][0] : cmd[1]);
+ var mml = STACKITEM.begin().With({name: env, end: end, parse:this});
+ if (name === "\\end") {
+ if (!isEnd && isArray(cmd[1]) && this[cmd[1][1]]) {
+ mml = this[cmd[1][1]].apply(this,[mml].concat(cmd.slice(2)));
+ } else {
+ mml = STACKITEM.end().With({name: env});
+ }
+ } else {
+ if (++this.macroCount > TEX.config.MAXMACROS) {
+ TEX.Error(["MaxMacroSub2",
+ "MathJax maximum substitution count exceeded; " +
+ "is there a recursive latex environment?"]);
+ }
+ if (cmd[0] && this[cmd[0]]) {mml = this[cmd[0]].apply(this,[mml].concat(cmd.slice(2)))}
+ }
+ this.Push(mml);
+ },
+ envFindName: function (name) {
+ return (TEXDEF.environment.hasOwnProperty(name) ? TEXDEF.environment[name] : null);
+ },
+
+ Equation: function (begin,row) {return row},
+
+ ExtensionEnv: function (begin,file) {this.Extension(begin.name,file,"environment")},
+
+ Array: function (begin,open,close,align,spacing,vspacing,style,raggedHeight) {
+ if (!align) {align = this.GetArgument("\\begin{"+begin.name+"}")}
+ var lines = ("c"+align).replace(/[^clr|:]/g,'').replace(/[^|:]([|:])+/g,'$1');
+ align = align.replace(/[^clr]/g,'').split('').join(' ');
+ align = align.replace(/l/g,'left').replace(/r/g,'right').replace(/c/g,'center');
+ var array = STACKITEM.array().With({
+ arraydef: {
+ columnalign: align,
+ columnspacing: (spacing||"1em"),
+ rowspacing: (vspacing||"4pt")
+ }
+ });
+ if (lines.match(/[|:]/)) {
+ if (lines.charAt(0).match(/[|:]/)) {array.frame.push("left"); array.frame.dashed = lines.charAt(0) === ":"}
+ if (lines.charAt(lines.length-1).match(/[|:]/)) {array.frame.push("right")}
+ lines = lines.substr(1,lines.length-2);
+ array.arraydef.columnlines =
+ lines.split('').join(' ').replace(/[^|: ]/g,'none').replace(/\|/g,'solid').replace(/:/g,'dashed');
+ }
+ if (open) {array.open = this.convertDelimiter(open)}
+ if (close) {array.close = this.convertDelimiter(close)}
+ if (style === "D") {array.arraydef.displaystyle = true}
+ else if (style) {array.arraydef.displaystyle = false}
+ if (style === "S") {array.arraydef.scriptlevel = 1} // FIXME: should use mstyle?
+ if (raggedHeight) {array.arraydef.useHeight = false}
+ this.Push(begin);
+ return array;
+ },
+
+ AlignedArray: function (begin) {
+ var align = this.GetBrackets("\\begin{"+begin.name+"}");
+ return this.setArrayAlign(this.Array.apply(this,arguments),align);
+ },
+ setArrayAlign: function (array,align) {
+ align = this.trimSpaces(align||"");
+ if (align === "t") {array.arraydef.align = "baseline 1"}
+ else if (align === "b") {array.arraydef.align = "baseline -1"}
+ else if (align === "c") {array.arraydef.align = "center"}
+ else if (align) {array.arraydef.align = align} // FIXME: should be an error?
+ return array;
+ },
+
+ /************************************************************************/
+ /*
+ * String handling routines
+ */
+
+ /*
+ * Convert delimiter to character
+ */
+ convertDelimiter: function (c) {
+ if (c) {c = (TEXDEF.delimiter.hasOwnProperty(c) ? TEXDEF.delimiter[c] : null)}
+ if (c == null) {return null}
+ if (isArray(c)) {c = c[0]}
+ if (c.length === 4) {c = String.fromCharCode(parseInt(c,16))}
+ return c;
+ },
+
+ /*
+ * Trim spaces from a string
+ */
+ trimSpaces: function (text) {
+ if (typeof(text) != 'string') {return text}
+ var TEXT = text.replace(/^\s+|\s+$/g,'');
+ if (TEXT.match(/\\$/) && text.match(/ $/)) TEXT += " ";
+ return TEXT;
+ },
+
+ /*
+ * Check if the next character is a space
+ */
+ nextIsSpace: function () {
+ return this.string.charAt(this.i).match(/\s/);
+ },
+
+ /*
+ * Get the next non-space character
+ */
+ GetNext: function () {
+ while (this.nextIsSpace()) {this.i++}
+ return this.string.charAt(this.i);
+ },
+
+ /*
+ * Get and return a control-sequence name
+ */
+ GetCS: function () {
+ var CS = this.string.slice(this.i).match(/^([a-z]+|.) ?/i);
+ if (CS) {this.i += CS[1].length; return CS[1]} else {this.i++; return " "}
+ },
+
+ /*
+ * Get and return a TeX argument (either a single character or control sequence,
+ * or the contents of the next set of braces).
+ */
+ GetArgument: function (name,noneOK) {
+ switch (this.GetNext()) {
+ case "":
+ if (!noneOK) {TEX.Error(["MissingArgFor","Missing argument for %1",name])}
+ return null;
+ case '}':
+ if (!noneOK) {
+ TEX.Error(["ExtraCloseMissingOpen",
+ "Extra close brace or missing open brace"]);
+ }
+ return null;
+ case '\\':
+ this.i++; return "\\"+this.GetCS();
+ case '{':
+ var j = ++this.i, parens = 1;
+ while (this.i < this.string.length) {
+ switch (this.string.charAt(this.i++)) {
+ case '\\': this.i++; break;
+ case '{': parens++; break;
+ case '}':
+ if (--parens == 0) {return this.string.slice(j,this.i-1)}
+ break;
+ }
+ }
+ TEX.Error(["MissingCloseBrace","Missing close brace"]);
+ break;
+ }
+ return this.string.charAt(this.i++);
+ },
+
+ /*
+ * Get an optional LaTeX argument in brackets
+ */
+ GetBrackets: function (name,def) {
+ if (this.GetNext() != '[') {return def};
+ var j = ++this.i, parens = 0;
+ while (this.i < this.string.length) {
+ switch (this.string.charAt(this.i++)) {
+ case '{': parens++; break;
+ case '\\': this.i++; break;
+ case '}':
+ if (parens-- <= 0) {
+ TEX.Error(["ExtraCloseLooking",
+ "Extra close brace while looking for %1","']'"]);
+ }
+ break;
+ case ']':
+ if (parens == 0) {return this.string.slice(j,this.i-1)}
+ break;
+ }
+ }
+ TEX.Error(["MissingCloseBracket",
+ "Couldn't find closing ']' for argument to %1",name]);
+ },
+
+ /*
+ * Get the name of a delimiter (check it in the delimiter list).
+ */
+ GetDelimiter: function (name,braceOK) {
+ while (this.nextIsSpace()) {this.i++}
+ var c = this.string.charAt(this.i); this.i++;
+ if (this.i <= this.string.length) {
+ if (c == "\\") {
+ c += this.GetCS(name);
+ } else if (c === "{" && braceOK) {
+ this.i--;
+ c = this.GetArgument(name).replace(/^\s+/,'').replace(/\s+$/,'');
+ }
+ if (TEXDEF.delimiter.hasOwnProperty(c)) {return this.convertDelimiter(c)}
+ }
+ TEX.Error(["MissingOrUnrecognizedDelim",
+ "Missing or unrecognized delimiter for %1",name]);
+ },
+
+ /*
+ * Get a dimension (including its units).
+ */
+ GetDimen: function (name) {
+ var dimen;
+ if (this.nextIsSpace()) {this.i++}
+ if (this.string.charAt(this.i) == '{') {
+ dimen = this.GetArgument(name);
+ if (dimen.match(/^\s*([-+]?([.,]\d+|\d+([.,]\d*)?))\s*(pt|em|ex|mu|px|mm|cm|in|pc)\s*$/))
+ {return dimen.replace(/ /g,"").replace(/,/,".")}
+ } else {
+ dimen = this.string.slice(this.i);
+ var match = dimen.match(/^\s*(([-+]?([.,]\d+|\d+([.,]\d*)?))\s*(pt|em|ex|mu|px|mm|cm|in|pc)) ?/);
+ if (match) {
+ this.i += match[0].length;
+ return match[1].replace(/ /g,"").replace(/,/,".");
+ }
+ }
+ TEX.Error(["MissingDimOrUnits",
+ "Missing dimension or its units for %1",name]);
+ },
+
+ /*
+ * Get everything up to the given control sequence (token)
+ */
+ GetUpTo: function (name,token) {
+ while (this.nextIsSpace()) {this.i++}
+ var j = this.i, k, c, parens = 0;
+ while (this.i < this.string.length) {
+ k = this.i; c = this.string.charAt(this.i++);
+ switch (c) {
+ case '\\': c += this.GetCS(); break;
+ case '{': parens++; break;
+ case '}':
+ if (parens == 0) {
+ TEX.Error(["ExtraCloseLooking",
+ "Extra close brace while looking for %1",token])
+ }
+ parens--;
+ break;
+ }
+ if (parens == 0 && c == token) {return this.string.slice(j,k)}
+ }
+ TEX.Error(["TokenNotFoundForCommand",
+ "Couldn't find %1 for %2",token,name]);
+ },
+
+ /*
+ * Parse various substrings
+ */
+ ParseArg: function (name) {return TEX.Parse(this.GetArgument(name),this.stack.env).mml()},
+ ParseUpTo: function (name,token) {return TEX.Parse(this.GetUpTo(name,token),this.stack.env).mml()},
+
+ /*
+ * Break up a string into text and math blocks
+ */
+ InternalMath: function (text,level) {
+ var def = (this.stack.env.font ? {mathvariant: this.stack.env.font} : {});
+ var mml = [], i = 0, k = 0, c, match = '', braces = 0;
+ if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {
+ while (i < text.length) {
+ c = text.charAt(i++);
+ if (c === '$') {
+ if (match === '$' && braces === 0) {
+ mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-1),{}).mml()));
+ match = ''; k = i;
+ } else if (match === '') {
+ if (k < i-1) mml.push(this.InternalText(text.slice(k,i-1),def));
+ match = '$'; k = i;
+ }
+ } else if (c === '{' && match !== '') {
+ braces++;
+ } else if (c === '}') {
+ if (match === '}' && braces === 0) {
+ mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i),{}).mml().With(def)));
+ match = ''; k = i;
+ } else if (match !== '') {
+ if (braces) braces--;
+ }
+ } else if (c === '\\') {
+ if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
+ var len = RegExp["$&"].length;
+ if (k < i-1) mml.push(this.InternalText(text.slice(k,i-1),def));
+ match = '}'; k = i-1; i += len;
+ } else {
+ c = text.charAt(i++);
+ if (c === '(' && match === '') {
+ if (k < i-2) mml.push(this.InternalText(text.slice(k,i-2),def));
+ match = ')'; k = i;
+ } else if (c === ')' && match === ')' && braces === 0) {
+ mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-2),{}).mml()));
+ match = ''; k = i;
+ } else if (c.match(/[${}\\]/) && match === '') {
+ i--; text = text.substr(0,i-1) + text.substr(i); // remove \ from \$, \{, \}, or \\
+ }
+ }
+ }
+ }
+ if (match !== '') TEX.Error(["MathNotTerminated","Math not terminated in text box"]);
+ }
+ if (k < text.length) mml.push(this.InternalText(text.slice(k),def));
+ if (level != null) {
+ mml = [MML.mstyle.apply(MML,mml).With({displaystyle:false,scriptlevel:level})];
+ } else if (mml.length > 1) {
+ mml = [MML.mrow.apply(MML,mml)];
+ }
+ return mml;
+ },
+ InternalText: function (text,def) {
+ text = text.replace(/^\s+/,NBSP).replace(/\s+$/,NBSP);
+ return MML.mtext(MML.chars(text)).With(def);
+ },
+
+ /*
+ * Routines to set the macro and environment definitions
+ * (overridden by begingroup to make localized versions)
+ */
+ setDef: function (name,value) {value.isUser = true; TEXDEF.macros[name] = value},
+ setEnv: function (name,value) {value.isUser = true; TEXDEF.environment[name] = value},
+
+ /*
+ * Replace macro parameters with their values
+ */
+ SubstituteArgs: function (args,string) {
+ var text = ''; var newstring = ''; var c; var i = 0;
+ while (i < string.length) {
+ c = string.charAt(i++);
+ if (c === "\\") {text += c + string.charAt(i++)}
+ else if (c === '#') {
+ c = string.charAt(i++);
+ if (c === '#') {text += c} else {
+ if (!c.match(/[1-9]/) || c > args.length) {
+ TEX.Error(["IllegalMacroParam",
+ "Illegal macro parameter reference"]);
+ }
+ newstring = this.AddArgs(this.AddArgs(newstring,text),args[c-1]);
+ text = '';
+ }
+ } else {text += c}
+ }
+ return this.AddArgs(newstring,text);
+ },
+
+ /*
+ * Make sure that macros are followed by a space if their names
+ * could accidentally be continued into the following text.
+ */
+ AddArgs: function (s1,s2) {
+ if (s2.match(/^[a-z]/i) && s1.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i)) {s1 += ' '}
+ if (s1.length + s2.length > TEX.config.MAXBUFFER) {
+ TEX.Error(["MaxBufferSize",
+ "MathJax internal buffer size exceeded; is there a recursive macro call?"]);
+ }
+ return s1+s2;
+ }
+
+ });
+
+ /************************************************************************/
+
+ TEX.Augment({
+ Stack: STACK, Parse: PARSE, Definitions: TEXDEF, Startup: STARTUP,
+
+ config: {
+ MAXMACROS: 10000, // maximum number of macro substitutions per equation
+ MAXBUFFER: 5*1024 // maximum size of TeX string to process
+ },
+
+ sourceMenuTitle: /*_(MathMenu)*/ ["TeXCommands","TeX Commands"],
+ annotationEncoding: "application/x-tex",
+
+ prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run before processing TeX
+ postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run after processing TeX
+
+ //
+ // Check if AMSmath extension must be loaded and push
+ // it on the extensions array, if needed
+ //
+ Config: function () {
+ this.SUPER(arguments).Config.apply(this,arguments);
+ if (this.config.equationNumbers.autoNumber !== "none") {
+ if (!this.config.extensions) {this.config.extensions = []}
+ this.config.extensions.push("AMSmath.js");
+ }
+ },
+
+ //
+ // Convert TeX to ElementJax
+ //
+ Translate: function (script) {
+ var mml, isError = false, math = MathJax.HTML.getScript(script);
+ var display = (script.type.replace(/\n/g," ").match(/(;|\s|\n)mode\s*=\s*display(;|\s|\n|$)/) != null);
+ var data = {math:math, display:display, script:script};
+ var callback = this.prefilterHooks.Execute(data); if (callback) return callback;
+ math = data.math;
+ try {
+ mml = TEX.Parse(math).mml();
+ } catch(err) {
+ if (!err.texError) {throw err}
+ mml = this.formatError(err,math,display,script);
+ isError = true;
+ }
+ if (mml.isa(MML.mtable) && mml.displaystyle === "inherit") mml.displaystyle = display; // for tagged equations
+ if (mml.inferred) {mml = MML.apply(MathJax.ElementJax,mml.data)} else {mml = MML(mml)}
+ if (display) {mml.root.display = "block"}
+ if (isError) {mml.texError = true}
+ data.math = mml;
+ return this.postfilterHooks.Execute(data) || data.math;
+ },
+ prefilterMath: function (math,displaystyle,script) {
+ return math;
+ },
+ postfilterMath: function (math,displaystyle,script) {
+ this.combineRelations(math.root);
+ return math;
+ },
+ formatError: function (err,math,display,script) {
+ var message = err.message.replace(/\n.*/,"");
+ HUB.signal.Post(["TeX Jax - parse error",message,math,display,script]);
+ return MML.Error(message);
+ },
+
+ //
+ // Produce an error and stop processing this equation
+ //
+ Error: function (message) {
+ //
+ // Translate message if it is ["id","message",args]
+ //
+ if (isArray(message)) {message = _.apply(_,message)}
+ throw HUB.Insert(Error(message),{texError: true});
+ },
+
+ //
+ // Add a user-defined macro to the macro list
+ //
+ Macro: function (name,def,argn) {
+ TEXDEF.macros[name] = ['Macro'].concat([].slice.call(arguments,1));
+ TEXDEF.macros[name].isUser = true;
+ },
+
+ /*
+ * Create an mrow that has stretchy delimiters at either end, as needed
+ */
+ fenced: function (open,mml,close) {
+ var mrow = MML.mrow().With({open:open, close:close, texClass:MML.TEXCLASS.INNER});
+ mrow.Append(
+ MML.mo(open).With({fence:true, stretchy:true, symmetric:true, texClass:MML.TEXCLASS.OPEN})
+ );
+ if (mml.type === "mrow" && mml.inferred) {
+ mrow.Append.apply(mrow, mml.data);
+ } else {
+ mrow.Append(mml);
+ }
+ mrow.Append(
+ MML.mo(close).With({fence:true, stretchy:true, symmetric:true, texClass:MML.TEXCLASS.CLOSE})
+ );
+ return mrow;
+ },
+ /*
+ * Create an mrow that has \mathchoice using \bigg and \big for the delimiters
+ */
+ fixedFence: function (open,mml,close) {
+ var mrow = MML.mrow().With({open:open, close:close, texClass:MML.TEXCLASS.ORD});
+ if (open) {mrow.Append(this.mathPalette(open,"l"))}
+ if (mml.type === "mrow") {mrow.Append.apply(mrow,mml.data)} else {mrow.Append(mml)}
+ if (close) {mrow.Append(this.mathPalette(close,"r"))}
+ return mrow;
+ },
+ mathPalette: function (fence,side) {
+ if (fence === '{' || fence === '}') {fence = "\\"+fence}
+ var D = '{\\bigg'+side+' '+fence+'}', T = '{\\big'+side+' '+fence+'}';
+ return TEX.Parse('\\mathchoice'+D+T+T+T,{}).mml();
+ },
+
+ //
+ // Combine adjacent <mo> elements that are relations
+ // (since MathML treats the spacing very differently)
+ //
+ combineRelations: function (mml) {
+ var i, m, m1, m2;
+ for (i = 0, m = mml.data.length; i < m; i++) {
+ if (mml.data[i]) {
+ if (mml.isa(MML.mrow)) {
+ while (i+1 < m && (m1 = mml.data[i]) && (m2 = mml.data[i+1]) &&
+ m1.isa(MML.mo) && m2.isa(MML.mo) &&
+ m1.Get("texClass") === MML.TEXCLASS.REL &&
+ m2.Get("texClass") === MML.TEXCLASS.REL) {
+ if (m1.variantForm == m2.variantForm &&
+ m1.Get("mathvariant") == m2.Get("mathvariant") && m1.style == m2.style &&
+ m1["class"] == m2["class"] && !m1.id && !m2.id) {
+ m1.Append.apply(m1,m2.data);
+ mml.data.splice(i+1,1); m--;
+ } else {
+ m1.rspace = m2.lspace = "0pt"; i++;
+ }
+ }
+ }
+ if (!mml.data[i].isToken) {this.combineRelations(mml.data[i])}
+ }
+ }
+ }
+ });
+
+ //
+ // Add the default filters
+ //
+ TEX.prefilterHooks.Add(function (data) {
+ data.math = TEX.prefilterMath(data.math,data.display,data.script);
+ });
+ TEX.postfilterHooks.Add(function (data) {
+ data.math = TEX.postfilterMath(data.math,data.display,data.script);
+ });
+
+ TEX.loadComplete("jax.js");
+
+})(MathJax.InputJax.TeX,MathJax.Hub,MathJax.Ajax);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/annotation-xml.js b/js/mathjax/jax/output/CommonHTML/autoload/annotation-xml.js
new file mode 100644
index 0000000..39acf24
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/annotation-xml.js
@@ -0,0 +1,62 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/annotation-xm;l.js
+ *
+ * Implements the CommonHTML output for <annotation-xml> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CHTML = MathJax.OutputJax.CommonHTML;
+
+ MML["annotation-xml"].Augment({
+ toCommonHTML: function (node) {
+ var encoding = this.Get("encoding");
+ node = this.CHTMLdefaultNode(node,{childOptions:{encoding:encoding}});
+ if (this.CHTML.rscale !== 1) this.CHTML.rescale(1/this.CHTML.rscale);
+ return node;
+ }
+ });
+
+ MML.xml.Augment({
+ toCommonHTML: function (node,options) {
+ var bbox = this.CHTML = CHTML.BBOX.zero();
+ for (var i = 0, m = this.data.length; i < m; i++)
+ {node.appendChild(this.data[i].cloneNode(true))}
+ //
+ // Warning: causes reflow
+ //
+ var w = node.offsetWidth, h = node.offsetHeight;
+ var strut = CHTML.addElement(node,"mjx-hd-test",{style:{height:h+"px"}});
+ bbox.d = bbox.b = (node.offsetHeight - h)/CHTML.em;
+ bbox.w = bbox.r = w/CHTML.em; bbox.h = bbox.t = h/CHTML.em - bbox.d;
+ node.removeChild(strut);
+ }
+ });
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML annotation-xml Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/annotation-xml.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/maction.js b/js/mathjax/jax/output/CommonHTML/autoload/maction.js
new file mode 100644
index 0000000..3fdb393
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/maction.js
@@ -0,0 +1,180 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/maction.js
+ *
+ * Implements the CommonHTML output for <maction> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CHTML = MathJax.OutputJax.CommonHTML;
+
+ var currentTip, hover, clear;
+
+ //
+ // Add configuration for tooltips
+ //
+ var CONFIG = CHTML.config.tooltip = MathJax.Hub.Insert({
+ delayPost: 600, delayClear: 600,
+ offsetX: 10, offsetY: 5
+ },CHTML.config.tooltip||{});
+
+
+ MML.maction.Augment({
+ CHTMLtooltip: CHTML.addElement(document.body,"div",{id:"MathJax_CHTML_Tooltip"}),
+
+ toCommonHTML: function (node) {
+ var selected = this.Get("selection");
+ node = this.CHTMLcreateNode(node);
+ this.CHTML = CHTML.BBOX.empty();
+ this.CHTMLhandleStyle(node);
+ this.CHTMLhandleScale(node);
+ this.CHTMLaddChild(node,selected-1,{});
+ this.CHTML.clean();
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+
+ var type = this.Get("actiontype");
+ if (this.CHTMLaction[type] && this.CHTMLaction.hasOwnProperty(type))
+ this.CHTMLaction[type].call(this,node,selected);
+
+ return node;
+ },
+ CHTMLcoreNode: function (node) {return this.CHTMLchildNode(node,0)},
+
+ //
+ // Implementations for the various actions
+ //
+ CHTMLaction: {
+ toggle: function (node,selection) {
+ this.selection = selection;
+ node.onclick = MathJax.Callback(["CHTMLclick",this,CHTML.jax]);
+ node.style.cursor = "pointer";
+ },
+
+ statusline: function (node,selection) {
+ node.onmouseover = MathJax.Callback(["CHTMLsetStatus",this]);
+ node.onmouseout = MathJax.Callback(["CHTMLclearStatus",this]);
+ node.onmouseover.autoReset = node.onmouseout.autoReset = true;
+ },
+
+ tooltip: function(node,selection) {
+ if (this.data[1] && this.data[1].isToken) {
+ node.title = node.alt = this.data[1].data.join("");
+ } else {
+ node.onmouseover = MathJax.Callback(["CHTMLtooltipOver",this,CHTML.jax]);
+ node.onmouseout = MathJax.Callback(["CHTMLtooltipOut",this,CHTML.jax]);
+ node.onmouseover.autoReset = node.onmouseout.autoReset = true;
+ }
+ }
+ },
+
+ //
+ // Handle a click on the maction element
+ // (remove the original rendering and rerender)
+ //
+ CHTMLclick: function (jax,event) {
+ this.selection++;
+ if (this.selection > this.data.length) this.selection = 1;
+ var hover = !!jax.hover;
+ jax.Update();
+ if (hover) {
+ var span = document.getElementById(jax.inputID+"-Span");
+ MathJax.Extension.MathEvents.Hover.Hover(jax,span);
+ }
+ return MathJax.Extension.MathEvents.Event.False(event);
+ },
+
+ //
+ // Set/Clear the window status message
+ //
+ CHTMLsetStatus: function (event) {
+ // FIXME: Do something better with non-token elements
+ this.messageID = MathJax.Message.Set
+ ((this.data[1] && this.data[1].isToken) ?
+ this.data[1].data.join("") : this.data[1].toString());
+ },
+ CHTMLclearStatus: function (event) {
+ if (this.messageID) MathJax.Message.Clear(this.messageID,0);
+ delete this.messageID;
+ },
+
+ //
+ // Handle tooltips
+ //
+ CHTMLtooltipOver: function (jax,event) {
+ if (!event) event = window.event;
+ if (clear) {clearTimeout(clear); clear = null}
+ if (hover) clearTimeout(hover);
+ var x = event.pageX; var y = event.pageY;
+ if (x == null) {
+ x = event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
+ y = event.clientY + document.body.scrollTop + document.documentElement.scrollTop;
+ }
+ var callback = MathJax.Callback(["CHTMLtooltipPost",this,jax,x+CONFIG.offsetX,y+CONFIG.offsetY])
+ hover = setTimeout(callback,CONFIG.delayPost);
+ },
+ CHTMLtooltipOut: function (jax,event) {
+ if (hover) {clearTimeout(hover); hover = null}
+ if (clear) clearTimeout(clear);
+ var callback = MathJax.Callback(["CHTMLtooltipClear",this,80]);
+ clear = setTimeout(callback,CONFIG.delayClear);
+ },
+ CHTMLtooltipPost: function (jax,x,y) {
+ hover = null; if (clear) {clearTimeout(clear); clear = null}
+ var tip = this.CHTMLtooltip;
+ tip.style.display = "block"; tip.style.opacity = "";
+// tip.style.filter = CHTML.config.styles["#MathJax_CHTML_Tooltip"].filter;
+ if (this === currentTip) return;
+ tip.style.left = x+"px"; tip.style.top = y+"px";
+ tip.innerHTML = '<span class="mjx-chtml"><span class="mjx-math"></span></span>';
+ CHTML.getMetrics(jax);
+ try {this.data[1].toCommonHTML(tip.firstChild.firstChild)} catch(err) {
+ if (!err.restart) throw err;
+ tip.style.display = "none";
+ MathJax.Callback.After(["CHTMLtooltipPost",this,jax,x,y],err.restart);
+ return;
+ }
+ currentTip = this;
+ },
+ CHTMLtooltipClear: function (n) {
+ var tip = this.CHTMLtooltip;
+ if (n <= 0) {
+ tip.style.display = "none";
+ tip.style.opacity = tip.style.filter = "";
+ clear = null;
+ } else {
+ tip.style.opacity = n/100;
+ tip.style.filter = "alpha(opacity="+n+")";
+ clear = setTimeout(MathJax.Callback(["CHTMLtooltipClear",this,n-20]),50);
+ }
+ }
+ });
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML maction Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/maction.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/menclose.js b/js/mathjax/jax/output/CommonHTML/autoload/menclose.js
new file mode 100644
index 0000000..5ba5b02
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/menclose.js
@@ -0,0 +1,332 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/menclose.js
+ *
+ * Implements the CommonHTML output for <menclose> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CHTML = MathJax.OutputJax.CommonHTML;
+
+ var SVGNS = "http://www.w3.org/2000/svg";
+ var ARROWX = 4, ARROWDX = 1, ARROWY = 2;
+
+ MML.menclose.Augment({
+ toCommonHTML: function (node) {
+ var values = this.getValues("notation","thickness","padding");
+ if (values.thickness == null) values.thickness = ".075em";
+ if (values.padding == null) values.padding = ".2em";
+ //
+ // Get DOM nodes
+ //
+ node = this.CHTMLdefaultNode(node,{childNodes:"mjx-box", forceChild:true});
+ var child = node.firstChild, cbox = this.CHTMLbboxFor(0);
+ //
+ // Get the padding and rule thickness
+ //
+ var p = this.CHTMLlength2em(values.padding,1/CHTML.em); // padding for enclosure
+ var t = this.CHTMLlength2em(values.thickness,1/CHTML.em); // thickness of lines
+ t = Math.max(1,Math.round(t*CHTML.em))/CHTML.em;
+ var SOLID = CHTML.Px(t)+" solid";
+ var bb = {L:p, R:p, T:p, B:p, H:cbox.h+p, D:cbox.d+p, W:cbox.w+2*p};
+ child.style.padding = CHTML.Em(p);
+ //
+ // Eliminate duplicate notations.
+ //
+ var notations = MathJax.Hub.SplitList(values.notation), notation = {};
+ for (var i = 0, m = notations.length; i < m; i++) notation[notations[i]] = true;
+ if (notation[MML.NOTATION.UPDIAGONALARROW]) delete notation[MML.NOTATION.UPDIAGONALSTRIKE];
+ //
+ // Add the needed notations
+ //
+ for (var n in notation) {
+ if (notation.hasOwnProperty(n)) {
+ if (this.CHTMLnotation[n] && this.CHTMLnotation.hasOwnProperty(n))
+ this.CHTMLnotation[n].call(this,child,cbox,bb,p,t,SOLID);
+ }
+ }
+ //
+ // Adjust the bounding box
+ //
+ var BBOX = this.CHTML;
+ BBOX.w += bb.L + bb.R; BBOX.r += BBOX.L; if (BBOX.w > BBOX.r) BBOX.r = BBOX.w;
+ BBOX.h += bb.T; if (BBOX.h > BBOX.t) BBOX.t = BBOX.h;
+ BBOX.d += bb.B; if (BBOX.d > BBOX.b) BBOX.b = BBOX.d;
+
+ return node;
+ },
+ //
+ // The various notations and their implementations
+ //
+ CHTMLnotation: {
+
+ /********************************************************/
+
+ box: function (child,cbox,bb,p,t,SOLID) {
+ p -= t;
+ child.style.padding = CHTML.Em(p);
+ child.style.border = SOLID;
+ },
+
+ /********************************************************/
+
+ roundedbox: function (child,cbox,bb,p,t,SOLID) {
+ var r = Math.min(cbox.w,cbox.h+cbox.d+2*p)/4;
+ CHTML.addElement(child.parentNode,"mjx-box",{
+ style: {
+ padding:CHTML.Em(p-t), border:SOLID, "border-radius":CHTML.Em(r),
+ height:CHTML.Em(cbox.h+cbox.d), "vertical-align":CHTML.Em(-bb.D),
+ width:CHTML.Em(cbox.w), "margin-left":CHTML.Em(-bb.W)
+ }
+ });
+ },
+
+ /********************************************************/
+
+ circle: function (child,cbox,bb,p,t,SOLID) {
+ var H = bb.H, D = bb.D, W = bb.W;
+ var svg = this.CHTMLsvg(child,bb,t);
+ this.CHTMLsvgElement(svg.firstChild,"ellipse",{
+ rx:CHTML.Px(W/2-t/2), ry:CHTML.Px((H+D)/2-t/2),
+ cx:CHTML.Px(W/2), cy:CHTML.Px((H+D)/2)
+ });
+ this.CHTMLsvgViewBox(svg);
+ },
+
+ /********************************************************/
+
+ left: function (child,cbox,bb,p,t,SOLID) {
+ child.style.borderLeft = SOLID;
+ child.style.paddingLeft = CHTML.Em(p-t);
+ },
+
+ /********************************************************/
+
+ right: function (child,cbox,bb,p,t,SOLID) {
+ child.style.borderRight = SOLID;
+ child.style.paddingRight = CHTML.Em(p-t);
+ },
+
+ /********************************************************/
+
+ top: function (child,cbox,bb,p,t,SOLID) {
+ child.style.borderTop = SOLID;
+ child.style.paddingTop = CHTML.Em(p-t);
+ },
+
+ /********************************************************/
+
+ bottom: function (child,cbox,bb,p,t,SOLID) {
+ child.style.borderBottom = SOLID;
+ child.style.paddingBottom = CHTML.Em(p-t);
+ },
+
+ /********************************************************/
+
+ actuarial: function (child,cbox,bb,p,t,SOLID) {
+ child.style.borderTop = child.style.borderRight = SOLID;
+ child.style.paddingTop = child.style.paddingRight = CHTML.Em(p-t);
+ },
+
+ /********************************************************/
+
+ madruwb: function (child,cbox,bb,p,t,SOLID) {
+ child.style.borderBottom = child.style.borderRight = SOLID;
+ child.style.paddingBottom = child.style.paddingRight = CHTML.Em(p-t);
+ },
+
+ /********************************************************/
+
+ verticalstrike: function (child,cbox,bb,p,t,SOLID) {
+ CHTML.addElement(child.parentNode,"mjx-box",{
+ style: {
+ "border-left":SOLID,
+ height:CHTML.Em(bb.H+bb.D), "vertical-align":CHTML.Em(-bb.D),
+ width:CHTML.Em(cbox.w/2+p-t/2), "margin-left":CHTML.Em(-cbox.w/2-p-t/2)
+ }
+ });
+ },
+
+ /********************************************************/
+
+ horizontalstrike: function (child,cbox,bb,p,t,SOLID) {
+ CHTML.addElement(child.parentNode,"mjx-box",{
+ style: {
+ "border-top":SOLID,
+ height:CHTML.Em((bb.H+bb.D)/2-t/2), "vertical-align":CHTML.Em(-bb.D),
+ width:CHTML.Em(bb.W), "margin-left":CHTML.Em(-bb.W)
+ }
+ });
+ },
+
+ /********************************************************/
+
+ updiagonalstrike: function (child,cbox,bb,p,t,SOLID) {
+ var H = bb.H, D = bb.D, W = bb.W;
+ var svg = this.CHTMLsvg(child,bb,t);
+ this.CHTMLsvgElement(svg.firstChild,"line",{
+ x1:CHTML.Px(t/2), y1:CHTML.Px(H+D-t), x2:CHTML.Px(W-t), y2:CHTML.Px(t/2)
+ });
+ this.CHTMLsvgViewBox(svg);
+ },
+
+ /********************************************************/
+
+ downdiagonalstrike: function (child,cbox,bb,p,t,SOLID) {
+ var H = bb.H, D = bb.D, W = bb.W;
+ var svg = this.CHTMLsvg(child,bb,t);
+ this.CHTMLsvgElement(svg.firstChild,"line",{
+ x1:CHTML.Px(t/2), y1:CHTML.Px(t/2), x2:CHTML.Px(W-t), y2:CHTML.Px(H+D-t)
+ });
+ this.CHTMLsvgViewBox(svg);
+ },
+
+ /********************************************************/
+
+ updiagonalarrow: function (child,cbox,bb,p,t,SOLID) {
+ var H = bb.H + bb.D - t, W = bb.W - t/2;
+ var a = Math.atan2(H,W)*(-180/Math.PI).toFixed(3);
+ var R = Math.sqrt(H*H + W*W);
+ var svg = this.CHTMLsvg(child,bb,t);
+ var g = this.CHTMLsvgElement(svg.firstChild,"g",{
+ fill:"currentColor",
+ transform:"translate("+this.CHTMLpx(t/2)+" "+this.CHTMLpx(H+t/2)+") rotate("+a+")"
+ });
+ var x = t * ARROWX, dx = t * ARROWDX, y = t * ARROWY;
+ this.CHTMLsvgElement(g,"line",{
+ x1:CHTML.Px(t/2), y1:0, x2:CHTML.Px(R-x), y2:0
+ });
+ this.CHTMLsvgElement(g,"path",{
+ d: "M "+this.CHTMLpx(R-x)+",0 " +
+ "L "+this.CHTMLpx(R-x-dx)+","+this.CHTMLpx(y) +
+ "L "+this.CHTMLpx(R)+",0 " +
+ "L "+this.CHTMLpx(R-x-dx)+","+this.CHTMLpx(-y),
+ stroke:"none"
+ });
+ this.CHTMLsvgViewBox(svg);
+ },
+
+ /********************************************************/
+
+ phasorangle: function (child,cbox,bb,p,t,SOLID) {
+ var P = p, H = bb.H, D = bb.D;
+ p = (H+D)/2;
+ var W = bb.W + p - P; bb.W = W; bb.L = p;
+ child.style.margin = "0 0 0 "+CHTML.Em(p-P);
+ var svg = this.CHTMLsvg(child,bb,t);
+ this.CHTMLsvgElement(svg.firstChild,"path",{
+ d: "M "+this.CHTMLpx(p)+",1 " +
+ "L 1,"+this.CHTMLpx(H+D-t)+" L "+this.CHTMLpx(W)+","+this.CHTMLpx(H+D-t)
+ });
+ this.CHTMLsvgViewBox(svg);
+ },
+
+ /********************************************************/
+
+ longdiv: function (child,cbox,bb,p,t,SOLID) {
+ bb.W += 1.5*p; bb.L += 1.5*p;
+ var H = bb.H, D = bb.D, W = bb.W;
+ child.style.margin = "0 0 0 "+CHTML.Em(1.5*p);
+ var svg = this.CHTMLsvg(child,bb,t);
+ this.CHTMLsvgElement(svg.firstChild,"path",{
+ d: "M "+this.CHTMLpx(W)+",1 L 1,1 "+
+ "a"+this.CHTMLpx(p)+","+this.CHTMLpx((H+D)/2-t/2)+" 0 0,1 1,"+this.CHTMLpx(H+D-1.5*t)
+ });
+ this.CHTMLsvgViewBox(svg);
+ },
+
+ /********************************************************/
+
+ radical: function (child,cbox,bb,p,t,SOLID) {
+ bb.W += 1.5*p; bb.L += 1.5*p;
+ var H = bb.H, D = bb.D, W = bb.W;
+ child.style.margin = "0 0 0 "+CHTML.Em(1.5*p);
+ var svg = this.CHTMLsvg(child,bb,t);
+ this.CHTMLsvgElement(svg.firstChild,"path",{
+ d: "M 1,"+this.CHTMLpx(.6*(H+D)) +
+ " L "+this.CHTMLpx(p)+","+this.CHTMLpx(H+D) +
+ " L "+this.CHTMLpx(2*p)+",1 L "+this.CHTMLpx(W)+",1"
+ });
+ this.CHTMLsvgViewBox(svg);
+ }
+
+ /********************************************************/
+
+ },
+
+ //
+ // Pixels with no "px"
+ //
+ CHTMLpx: function (m) {
+ m *= CHTML.em;
+ if (Math.abs(m) < .1) return "0";
+ return m.toFixed(1).replace(/\.0$/,"");
+ },
+
+ //
+ // Create the SVG element and position it over the
+ // contents
+ //
+ CHTMLsvg: function (node,bbox,t) {
+ var svg = document.createElementNS(SVGNS,"svg");
+ if (svg.style) {
+ svg.style.width = CHTML.Em(bbox.W);
+ svg.style.height = CHTML.Em(bbox.H+bbox.D);
+ svg.style.verticalAlign = CHTML.Em(-bbox.D);
+ svg.style.marginLeft = CHTML.Em(-bbox.W);
+ }
+ var g = this.CHTMLsvgElement(svg,"g",{"stroke-width":CHTML.Px(t)});
+ if (this.CHTML.scale !== 1) {
+ g.setAttribute('transform', 'scale('+this.CHTML.scale+')');
+ }
+ node.parentNode.appendChild(svg);
+ return svg;
+ },
+ //
+ CHTMLsvgViewBox: function (svg) {
+ var bbox = svg.getBBox();
+ svg.setAttribute('viewBox', [bbox.x, bbox.y, bbox.width, bbox.height].join(' '));
+ },
+ //
+ // Add an SVG element to the given svg node
+ //
+ CHTMLsvgElement: function (svg,type,def) {
+ var obj = document.createElementNS(SVGNS,type); obj.isMathJax = true;
+ if (def) {for (var id in def) {if (def.hasOwnProperty(id)) {obj.setAttributeNS(null,id,def[id].toString())}}}
+ svg.appendChild(obj);
+ return obj;
+ }
+ });
+
+ //
+ // Just use default toCommonHTML for EI8
+ //
+ if (!document.createElementNS) delete MML.menclose.prototype.toCommonHTML;
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML menclose Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/menclose.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/mglyph.js b/js/mathjax/jax/output/CommonHTML/autoload/mglyph.js
new file mode 100644
index 0000000..3f1f269
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/mglyph.js
@@ -0,0 +1,96 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/mglyph.js
+ *
+ * Implements the CommonHTML output for <mglyph> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CHTML = MathJax.OutputJax.CommonHTML,
+ LOCALE = MathJax.Localization;
+
+ MML.mglyph.Augment({
+ toCommonHTML: function (node,options) {
+ var values = this.getValues("src","width","height","valign","alt");
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLhandleScale(node);
+ if (values.src === "") {
+ var index = this.Get("index");
+ this.CHTMLgetVariant();
+ if (index && this.CHTMLvariant.style)
+ this.CHTMLhandleText(node,String.fromCharCode(index),this.CHTMLvariant);
+ } else {
+ var bbox = this.CHTML;
+ if (!bbox.img) bbox.img = MML.mglyph.GLYPH[values.src];
+ if (!bbox.img) {
+ bbox.img = MML.mglyph.GLYPH[values.src] = {img: new Image(), status: "pending"};
+ bbox.img.img.onload = MathJax.Callback(["CHTMLimgLoaded",this]);
+ bbox.img.img.onerror = MathJax.Callback(["CHTMLimgError",this]);
+ bbox.img.img.src = values.src;
+ MathJax.Hub.RestartAfter(bbox.img.img.onload);
+ }
+ if (bbox.img.status !== "OK") {
+ var err = MML.Error(LOCALE._(["MathML","BadMglyph"],"Bad mglyph: %1",values.src));
+ err.data[0].data[0].mathsize = "75%";
+ this.Append(err); err.toCommonHTML(node); this.data.pop();
+ bbox.combine(err.CHTML,0,0,1);
+ } else {
+ var img = CHTML.addElement(node,"img",{
+ isMathJax:true, src:values.src, alt:values.alt, title:values.alt
+ });
+ var w = values.width, h = values.height;
+ var W = bbox.img.img.width/CHTML.em, H = bbox.img.img.height/CHTML.em;
+ var WW = W, HH = H;
+ if (w !== "") {W = this.CHTMLlength2em(w,WW); H = (WW ? W/WW * HH : 0)}
+ if (h !== "") {H = this.CHTMLlength2em(h,HH); if (w === "") W = (HH ? H/HH * WW : 0)}
+ img.style.width = CHTML.Em(W); bbox.w = bbox.r = W;
+ img.style.height = CHTML.Em(H); bbox.h = bbox.t = H;
+ if (values.valign) {
+ bbox.d = bbox.b = -this.CHTMLlength2em(values.valign,HH);
+ img.style.verticalAlign = CHTML.Em(-bbox.d);
+ bbox.h -= bbox.d; bbox.t = bbox.h;
+ }
+ }
+ }
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ return node;
+ },
+ CHTMLimgLoaded: function (event,status) {
+ if (typeof(event) === "string") status = event;
+ this.CHTML.img.status = (status || "OK");
+ },
+ CHTMLimgError: function () {this.CHTML.img.img.onload("error")}
+ },{
+ GLYPH: {} // global list of all loaded glyphs
+ });
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML mglyph Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/mglyph.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/mmultiscripts.js b/js/mathjax/jax/output/CommonHTML/autoload/mmultiscripts.js
new file mode 100644
index 0000000..e9cce12
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/mmultiscripts.js
@@ -0,0 +1,298 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/mmultiscripts.js
+ *
+ * Implements the CommonHTML output for <mmultiscripts> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CHTML = MathJax.OutputJax.CommonHTML;
+
+ MML.mmultiscripts.Augment({
+ toCommonHTML: function (node,options) {
+ var stretch = (options||{}).stretch;
+ if (!stretch) {
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLgetVariant();
+ this.CHTMLhandleScale(node);
+ }
+ CHTML.BBOX.empty(this.CHTML);
+
+ //
+ // Get base node
+ //
+ var base, bbox;
+ if (stretch) {
+ base = CHTML.getNode(node,"mjx-base");
+ } else {
+ this.CHTMLaddChild(node,0,{type:"mjx-base", noBBox:true, forceChild:true});
+ base = node.firstChild;
+ }
+ bbox = this.CHTMLbboxFor(0);
+ if (bbox.ic) {
+ bbox.R -= bbox.ic; // remove IC (added by mo and mi)
+ if (!stretch) base.style.marginRight = CHTML.Em(-bbox.ic);
+ delta = 1.3*bbox.ic + .05; // make faked IC be closer to expeted results
+ }
+
+ //
+ // Collect scripts into horizontal boxes and add them into the node
+ //
+ var BOX = {}, BBOX = {};
+ this.CHTMLgetScripts(BOX,BBOX,stretch,node);
+ var sub = BOX.sub, sup = BOX.sup, presub = BOX.presub, presup = BOX.presup;
+ var sbox = BBOX.sub, Sbox = BBOX.sup, pbox = BBOX.presub, Pbox = BBOX.presup;
+ if (!stretch) this.CHTMLaddBoxes(node,base,BOX);
+
+ //
+ // Get the initial values for the variables
+ //
+ var values = this.getValues("scriptlevel","scriptsizemultiplier");
+ var sscale = (this.Get("scriptlevel") < 3 ? values.scriptsizemultiplier : 1);
+ var ex = CHTML.TEX.x_height, s = CHTML.TEX.scriptspace;
+ var q = CHTML.TEX.sup_drop * sscale, r = CHTML.TEX.sub_drop * sscale;
+ var u = bbox.h - q, v = bbox.d + r, delta = 0, p;
+ var bmml = this.data[this.base];
+ if (bmml && (bmml.type === "mi" || bmml.type === "mo")) {
+ if (CHTML.isChar(bmml.data.join("")) && bbox.rscale === 1 && !bbox.sH &&
+ !bmml.Get("largeop")) {u = v = 0}
+ }
+ values = this.getValues("displaystyle","subscriptshift","superscriptshift","texprimestyle");
+ values.subscriptshift = (values.subscriptshift === "" ? 0 : this.CHTMLlength2em(values.subscriptshift));
+ values.superscriptshift = (values.superscriptshift === "" ? 0 : this.CHTMLlength2em(values.superscriptshift));
+
+ var dx = (presub ? s+pbox.w : presup ? s+Pbox.w-delta : 0);
+ this.CHTML.combine(bbox,dx,0); var x = this.CHTML.w;
+
+ //
+ // Place the scripts as needed
+ //
+ if (!sup && !presup) {
+ v = Math.max(v,CHTML.TEX.sub1,values.subscriptshift);
+ if (sub) v = Math.max(v,sbox.h-(4/5)*ex);
+ if (presub) v = Math.max(v,pbox.h-(4/5)*ex);
+ if (sub) this.CHTMLplaceSubOnly(sub,sbox,x,v,s);
+ if (presub) this.CHTMLplacePresubOnly(presub,pbox,v,s);
+ } else {
+ if (!sub && !presub) {
+ p = CHTML.TEX[(values.displaystyle ? "sup1" : (values.texprimestyle ? "sup3" : "sup2"))];
+ u = Math.max(u,p,values.superscriptshift);
+ if (sup) u = Math.max(u,Sbox.d+(1/4)*ex);
+ if (presup) u = Math.max(u,Pbox.d+(1/4)*ex);
+ if (sup) this.CHTMLplaceSupOnly(sup,Sbox,x,delta,u,s);
+ if (presup) this.CHTMLplacePresupOnly(presup,Pbox,delta,u,s);
+ } else {
+ v = Math.max(v,CHTML.TEX.sub2);
+ var t = CHTML.TEX.rule_thickness;
+ var h = (sbox||pbox).h, d = (Sbox||Pbox).d;
+ if (presub) h = Math.max(h,pbox.h);
+ if (presup) d = Math.max(d,Pbox.d);
+ if ((u - d) - (h - v) < 3*t) {
+ v = 3*t - u + d + h; q = (4/5)*ex - (u - d);
+ if (q > 0) {u += q; v -= q}
+ }
+ u = Math.max(u,values.superscriptshift);
+ v = Math.max(v,values.subscriptshift);
+ if (sup) {
+ if (sub) {this.CHTMLplaceSubSup(sub,sbox,sup,Sbox,x,delta,u,v,s)}
+ else {this.CHTMLplaceSupOnly(sup,Sbox,x,delta,u,s)}
+ } else if (sub) {this.CHTMLplaceSubOnly(sub,sbox,x,v,s)}
+ if (presup) {
+ if (presub) {this.CHTMLplacePresubPresup(presub,pbox,presup,Pbox,delta,u,v,s)}
+ else {this.CHTMLplacePresupOnly(presup,Pbox,delta,u,s)}
+ } else if (presub) {this.CHTMLplacePresubOnly(presub,pbox,v,s)}
+ }
+ }
+ this.CHTML.clean();
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ return node;
+ },
+ //
+ // Get the subscript, superscript, presubscript, and presuperscript
+ // boxes, with proper spacing, and computer their bounding boxes.
+ //
+ CHTMLgetScripts: function (BOX,BBOX,stretch,node) {
+ if (stretch) {
+ BOX.sub = CHTML.getNode(node,"mjx-sub");
+ BOX.sup = CHTML.getNode(node,"mjx-sup");
+ BOX.presub = CHTML.getNode(node,"mjx-presub");
+ BOX.presup = CHTML.getNode(node,"mjx-presup");
+ BBOX.sub = this.CHTMLbbox.sub;
+ BBOX.sup = this.CHTMLbbox.sup;
+ BBOX.presub = this.CHTMLbbox.presub;
+ BBOX.presup = this.CHTMLbbox.presup;
+ return;
+ }
+ this.CHTMLbbox = BBOX; // save for when stretched
+ var state = {i:1, w:0, BOX:BOX, BBOX:BBOX}, m = this.data.length;
+ var sub = "sub", sup = "sup";
+ while (state.i < m) {
+ if ((this.data[state.i]||{}).type === "mprescripts") {
+ state.i++; state.w = 0;
+ sub = "presub"; sup = "presup";
+ } else {
+ var sbox = this.CHTMLaddScript(sub,state,node);
+ var Sbox = this.CHTMLaddScript(sup,state,node);
+ var w = Math.max((sbox ? sbox.rscale*sbox.w : 0),(Sbox ? Sbox.rscale*Sbox.w : 0));
+ this.CHTMLpadScript(sub,w,sbox,state);
+ this.CHTMLpadScript(sup,w,Sbox,state);
+ state.w += w;
+ }
+ }
+ if (BBOX.sub) BBOX.sub.clean();
+ if (BBOX.sup) BBOX.sup.clean();
+ if (BBOX.presub) BBOX.presub.clean();
+ if (BBOX.presup) BBOX.presup.clean();
+ },
+ //
+ // Add a script to the proper box, creating the box if needed,
+ // and padding the box to account for any <none/> elements.
+ // Return the bounding box for the script for later use.
+ //
+ CHTMLaddScript: function (type,state,node) {
+ var BOX, BBOX, data = this.data[state.i];
+ if (data && data.type !== "none" && data.type !== "mprescripts") {
+ BOX = state.BOX[type];
+ if (!BOX) {
+ //
+ // Add the box to the node temporarily so that it is in the DOM
+ // (so that CHTMLnodeElement() can be used in the toCommonHTML() below).
+ // See issue #1480.
+ //
+ BOX = state.BOX[type] = CHTML.addElement(node,"mjx-"+type);
+ BBOX = state.BBOX[type] = CHTML.BBOX.empty();
+ if (state.w) {
+ BOX.style.paddingLeft = CHTML.Em(state.w);
+ BBOX.w = BBOX.r = state.w; BBOX.x = state.w;
+ }
+ }
+ data.toCommonHTML(BOX);
+ BBOX = data.CHTML;
+ }
+ if (data && data.type !== "mprescripts") state.i++;
+ return BBOX;
+ },
+ //
+ // Add padding to the script box to make match the width of the
+ // super- or subscript that is above or below it, and adjust the
+ // bounding box for the script row. If these are pre-scripts,
+ // right-justify the scripts, otherwise, left-justify them.
+ //
+ CHTMLpadScript: function (type,w,bbox,state) {
+ if (!bbox) bbox = {w:0, fake:1, rscale:1};
+ var BBOX = state.BBOX[type], dx = 0, dw = 0;
+ if (BBOX) {
+ if (bbox.rscale*bbox.w < w) {
+ var BOX = state.BOX[type]; dw = w-bbox.rscale*bbox.w;
+ var space = CHTML.Element("mjx-spacer",{style:{width:CHTML.Em(dw)}});
+ if (type.substr(0,3) === "pre" && !bbox.fake) {
+ BOX.insertBefore(space,BOX.lastChild);
+ dx = dw; dw = 0;
+ } else {
+ BOX.appendChild(space);
+ }
+ }
+ if (bbox.fake) {BBOX.w += dx} else {BBOX.combine(bbox,BBOX.w+dx,0)}
+ BBOX.w += dw;
+ }
+ },
+ //
+ // Add the boxes into the main node, creating stacks when needed
+ //
+ CHTMLaddBoxes: function (node,base,BOX) {
+ var sub = BOX.sub, sup = BOX.sup, presub = BOX.presub, presup = BOX.presup;
+ if (presub && presup) {
+ var prestack = CHTML.Element("mjx-prestack"); node.insertBefore(prestack,base);
+ prestack.appendChild(presup); prestack.appendChild(presub);
+ } else {
+ if (presub) node.insertBefore(presub,base);
+ if (presup) node.insertBefore(presup,base);
+ }
+ if (sub && sup) {
+ var stack = CHTML.addElement(node,"mjx-stack");
+ stack.appendChild(sup); stack.appendChild(sub);
+ } else {
+ if (sub) node.appendChild(sub);
+ if (sup) node.appendChild(sup);
+ }
+ },
+ //
+ // Handle positioning the various scripts
+ //
+ CHTMLplaceSubOnly: function (sub,sbox,x,v,s) {
+ sub.style.verticalAlign = CHTML.Em(-v);
+ sub.style.marginRight = CHTML.Em(s); sbox.w += s;
+ this.CHTML.combine(sbox,x,-v);
+ },
+ CHTMLplaceSupOnly: function (sup,Sbox,x,delta,u,s) {
+ sup.style.verticalAlign = CHTML.Em(u);
+ sup.style.paddingLeft = CHTML.Em(delta);
+ sup.style.paddingRight = CHTML.Em(s); Sbox.w += s;
+ this.CHTML.combine(Sbox,x+delta,u);
+ },
+ CHTMLplaceSubSup: function (sub,sbox,sup,Sbox,x,delta,u,v,s) {
+ sub.style.paddingRight = CHTML.Em(s); sbox.w += s;
+ sup.style.paddingBottom = CHTML.Em(u+v-Sbox.d-sbox.h);
+ sup.style.paddingLeft = CHTML.Em(delta+(Sbox.x||0));
+ sup.style.paddingRight = CHTML.Em(s); Sbox.w += s;
+ sup.parentNode.style.verticalAlign = CHTML.Em(-v);
+ this.CHTML.combine(sbox,x,-v);
+ this.CHTML.combine(Sbox,x+delta,u);
+ },
+ CHTMLplacePresubOnly: function (presub,pbox,v,s) {
+ presub.style.verticalAlign = CHTML.Em(-v);
+ presub.style.marginLeft = CHTML.Em(s);
+ this.CHTML.combine(pbox,s,-v);
+ },
+ CHTMLplacePresupOnly: function (presup,Pbox,delta,u,s) {
+ presup.style.verticalAlign = CHTML.Em(u);
+ presup.style.paddingLeft = CHTML.Em(s);
+ presup.style.paddingRight = CHTML.Em(-delta);
+ this.CHTML.combine(Pbox,s,u);
+ },
+ CHTMLplacePresubPresup: function (presub,pbox,presup,Pbox,delta,u,v,s) {
+ presub.style.paddingLeft = CHTML.Em(s);
+ presup.style.paddingBottom = CHTML.Em(u+v-Pbox.d-pbox.h);
+ presup.style.paddingLeft = CHTML.Em(delta+s+(Pbox.x||0));
+ presup.style.paddingRight = CHTML.Em(-delta);
+ presup.parentNode.style.verticalAlign = CHTML.Em(-v);
+ this.CHTML.combine(pbox,s,-v);
+ this.CHTML.combine(Pbox,s+delta,u);
+ },
+ //
+ // Handle stretchy bases
+ //
+ CHTMLstretchH: MML.mbase.CHTMLstretchH,
+ CHTMLstretchV: MML.mbase.CHTMLstretchV
+ });
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML mmultiscripts Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/mmultiscripts.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/ms.js b/js/mathjax/jax/output/CommonHTML/autoload/ms.js
new file mode 100644
index 0000000..ded30fc
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/ms.js
@@ -0,0 +1,75 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/ms.js
+ *
+ * Implements the CommonHTML output for <ms> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CHTML = MathJax.OutputJax.CommonHTML;
+
+ MML.ms.Augment({
+ toCommonHTML: function (node) {
+ //
+ // Create the node and handle its styles and scaling
+ // Get the variant and an empty bounding box
+ //
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLgetVariant();
+ this.CHTMLhandleScale(node);
+ CHTML.BBOX.empty(this.CHTML);
+ //
+ // Get the quotes to use
+ //
+ var values = this.getValues("lquote","rquote","mathvariant");
+ if (!this.hasValue("lquote") || values.lquote === '"') values.lquote = "\u201C";
+ if (!this.hasValue("rquote") || values.rquote === '"') values.rquote = "\u201D";
+ if (values.lquote === "\u201C" && values.mathvariant === "monospace") values.lquote = '"';
+ if (values.rquote === "\u201D" && values.mathvariant === "monospace") values.rquote = '"';
+ //
+ // Add the left quote, the child nodes, and the right quote
+ //
+ var text = values.lquote+this.data.join("")+values.rquote; // FIXME: handle mglyph?
+ this.CHTMLhandleText(node,text,this.CHTMLvariant);
+ //
+ // Finish the bbox, add any needed space and color
+ //
+ this.CHTML.clean();
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ //
+ // Return the completed node
+ //
+ return node;
+ }
+ });
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML ms Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/ms.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/mtable.js b/js/mathjax/jax/output/CommonHTML/autoload/mtable.js
new file mode 100644
index 0000000..2e8b397
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/mtable.js
@@ -0,0 +1,604 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/mtable.js
+ *
+ * Implements the CommonHTML output for <mtable> elements.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CONFIG = MathJax.Hub.config,
+ CHTML = MathJax.OutputJax.CommonHTML,
+ SPLIT = MathJax.Hub.SplitList;
+
+ var LABEL = -1,
+ BIGDIMEN = 1000000;
+
+ MML.mtable.Augment({
+ toCommonHTML: function (node) {
+ //
+ // Create the table nodes and put them in a table
+ // (so that its bottom is on the baseline, rather than aligned on the top row)
+ //
+ var state = {rows:[], labels:[], labeled: false};
+ node = this.CHTMLdefaultNode(node,{noBBox:true, childOptions:state});
+ var table = CHTML.Element("mjx-table");
+ while (node.firstChild) table.appendChild(node.firstChild);
+ node.appendChild(table);
+ //
+ // Get the table attributes
+ //
+ var values = this.getValues("columnalign","rowalign","columnspacing","rowspacing",
+ "columnwidth","equalcolumns","equalrows",
+ "columnlines","rowlines","frame","framespacing",
+ "align","width","side","minlabelspacing","useHeight");
+ var t = CHTML.TEX.min_rule_thickness/CHTML.em;
+ state.t = CHTML.Px(t*this.CHTML.scale,1);
+ //
+ // Create the table
+ //
+ this.CHTMLgetBoxSizes(values,state);
+ this.CHTMLgetAttributes(values,state);
+ this.CHTMLadjustCells(values,state);
+ if (values.frame) table.style.border = state.t+" "+values.frame;
+ this.CHTMLalignV(values,state,node);
+ this.CHTMLcolumnWidths(values,state,node);
+ this.CHTMLstretchCells(values,state);
+ if (state.labeled) this.CHTMLaddLabels(values,state,node,table);
+ //
+ // Set the bounding box (ignores overlapping outside of the table)
+ //
+ var BBOX = this.CHTML;
+ BBOX.w = BBOX.r = state.R;
+ BBOX.h = BBOX.t = state.T-state.B;
+ BBOX.d = BBOX.b = state.B;
+ if (!values.frame && !BBOX.pwidth) {
+ node.style.padding = "0 "+CHTML.Em(1/6);
+ BBOX.L = BBOX.R = 1/6;
+ }
+ //
+ // Add any needed space and color
+ //
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ //
+ // Return the completed node
+ //
+ return node;
+ },
+ //
+ // Get the natural height, depth, and widths of the rows and columns
+ //
+ CHTMLgetBoxSizes: function (values,state) {
+ var LH = CHTML.FONTDATA.lineH * values.useHeight,
+ LD = CHTML.FONTDATA.lineD * values.useHeight;
+ var H = [], D = [], W = [], J = -1, i, m;
+ for (i = 0, m = this.data.length; i < m; i++) {
+ var row = this.data[i], s = (row.type === "mtr" ? 0 : LABEL);
+ H[i] = LH; D[i] = LD;
+ for (var j = s, M = row.data.length + s; j < M; j++) {
+ if (W[j] == null) {W[j] = -BIGDIMEN; if (j > J) J = j}
+ var cbox = row.data[j-s].CHTML;
+ if (cbox.h > H[i]) H[i] = cbox.h;
+ if (cbox.d > D[i]) D[i] = cbox.d;
+ if (cbox.w > W[j]) W[j] = cbox.w;
+ }
+ }
+ if (values.equalrows) {
+ state.HD = true;
+ var HH = Math.max.apply(Math,H);
+ var DD = Math.max.apply(Math,D);
+ for (i = 0, m = H.length; i < m; i++) {H[i] = HH; D[i] = DD}
+ }
+ state.H = H; state.D = D; state.W = W, state.J = J;
+ },
+ //
+ // Pad the spacing and alignment attributes to match the size of the table
+ //
+ CHTMLgetAttributes: function (values,state) {
+ var CSPACE = SPLIT(values.columnspacing),
+ RSPACE = SPLIT(values.rowspacing),
+ CALIGN = SPLIT(values.columnalign),
+ RALIGN = SPLIT(values.rowalign),
+ CLINES = SPLIT(values.columnlines),
+ RLINES = SPLIT(values.rowlines),
+ CWIDTH = SPLIT(values.columnwidth),
+ RCALIGN = [], i, m, J = state.J, M = state.rows.length-1;
+ for (i = 0, m = CSPACE.length; i < m; i++) CSPACE[i] = this.CHTMLlength2em(CSPACE[i]);
+ for (i = 0, m = RSPACE.length; i < m; i++) RSPACE[i] = this.CHTMLlength2em(RSPACE[i]);
+ while (CSPACE.length < J) CSPACE.push(CSPACE[CSPACE.length-1]);
+ while (CALIGN.length <= J) CALIGN.push(CALIGN[CALIGN.length-1]);
+ while (CLINES.length < J) CLINES.push(CLINES[CLINES.length-1]);
+ while (CWIDTH.length <= J) CWIDTH.push(CWIDTH[CWIDTH.length-1]);
+ while (RSPACE.length < M) RSPACE.push(RSPACE[RSPACE.length-1]);
+ while (RALIGN.length <= M) RALIGN.push(RALIGN[RALIGN.length-1]);
+ while (RLINES.length < M) RLINES.push(RLINES[RLINES.length-1]);
+ CALIGN[LABEL] = (values.side.substr(0,1) === "l" ? "left" : "right");
+ //
+ // Override aligment data based on row-specific attributes
+ //
+ for (i = 0; i <= M; i++) {
+ var row = this.data[i]; RCALIGN[i] = [];
+ if (row.rowalign) RALIGN[i] = row.rowalign;
+ if (row.columnalign) {
+ RCALIGN[i] = SPLIT(row.columnalign);
+ while (RCALIGN[i].length <= J) RCALIGN[i].push(RCALIGN[i][RCALIGN[i].length-1]);
+ }
+ }
+ //
+ // Handle framespacing
+ //
+ var FSPACE = SPLIT(values.framespacing);
+ if (FSPACE.length != 2) FSPACE = SPLIT(this.defaults.framespacing);
+ FSPACE[0] = Math.max(0,this.CHTMLlength2em(FSPACE[0]));
+ FSPACE[1] = Math.max(0,this.CHTMLlength2em(FSPACE[1]));
+ if (values.columnlines.replace(/none/g,"").replace(/ /g,"") !== "" ||
+ values.rowlines.replace(/none/g,"").replace(/ /g,"") !== "") values.fspace = true;
+ //
+ // Pad arrays so that final column can be treated as all the others
+ //
+ if (values.frame === MML.LINES.NONE) delete values.frame; else values.fspace = true;
+ if (values.frame) {
+ FSPACE[0] = Math.max(0,FSPACE[0]);
+ FSPACE[1] = Math.max(0,FSPACE[1]);
+ }
+ if (values.fspace) {
+ CSPACE[J] = FSPACE[0]; RSPACE[M] = FSPACE[1];
+ } else {
+ CSPACE[J] = RSPACE[M] = 0;
+ }
+ CLINES[J] = RLINES[M] = MML.LINES.NONE;
+ //
+ // Save everything in the state
+ //
+ state.CSPACE = CSPACE; state.RSPACE = RSPACE;
+ state.CALIGN = CALIGN; state.RALIGN = RALIGN;
+ state.CLINES = CLINES; state.RLINES = RLINES;
+ state.CWIDTH = CWIDTH; state.RCALIGN = RCALIGN;
+ state.FSPACE = FSPACE;
+ },
+ //
+ // Add styles to cells to handle borders, spacing, alignment, etc.
+ //
+ CHTMLadjustCells: function(values,state) {
+ var ROWS = state.rows,
+ CSPACE = state.CSPACE, CLINES = state.CLINES,
+ RSPACE = state.RSPACE, RLINES = state.RLINES,
+ CALIGN = state.CALIGN, RALIGN = state.RALIGN,
+ RCALIGN = state.RCALIGN;
+ CSPACE[state.J] *= 2; RSPACE[ROWS.length-1] *= 2; // since halved below
+ var T = "0", B, R, L, border, cbox, align, lastB = 0;
+ if (values.fspace) {
+ lastB = state.FSPACE[1];
+ T = CHTML.Em(state.FSPACE[1]);
+ }
+ state.RHD = []; state.RH = [];
+ for (var i = 0, m = ROWS.length; i < m; i++) {
+ var row = ROWS[i], rdata = this.data[i];
+ //
+ // Space and borders between rows
+ //
+ B = RSPACE[i]/2; border = null; L = "0";
+ if (RLINES[i] !== MML.LINES.NONE && RLINES[i] !== "") border = state.t+" "+RLINES[i];
+ if (border || (CLINES[j] !== MML.LINES.NONE && CLINES[j] !== "")) {
+ while (row.length <= state.J) {
+ row.push(CHTML.addElement(row.node,"mjx-mtd",null,[['span']]));
+ }
+ }
+ state.RH[i] = lastB + state.H[i]; // distance to baseline in row
+ lastB = Math.max(0,B);
+ state.RHD[i] = state.RH[i] + lastB + state.D[i]; // total height of row
+ B = CHTML.Em(lastB);
+ //
+ // Frame space for initial cell
+ //
+ if (values.fspace) L = CHTML.Em(state.FSPACE[0]);
+ //
+ // The cells in the row
+ //
+ for (var j = 0, M = row.length; j < M; j++) {
+ var s = (rdata.type === "mtr" ? 0 : LABEL);
+ var mtd = rdata.data[j-s] || {CHTML: CHTML.BBOX.zero()};
+ var cell = row[j].style; cbox = mtd.CHTML;
+ //
+ // Space and borders between columns
+ //
+ R = CSPACE[j]/2;
+ if (CLINES[j] !== MML.LINES.NONE) {
+ cell.borderRight = state.t+" "+CLINES[j];
+ R -= 1/CHTML.em/2;
+ }
+ R = CHTML.Em(Math.max(0,R));
+ cell.padding = T+" "+R+" 0px "+L;
+ if (border) cell.borderBottom = border;
+ L = R;
+ //
+ // Handle vertical alignment
+ //
+ align = (mtd.rowalign||(this.data[i]||{}).rowalign||RALIGN[i]);
+ var H = Math.max(1,cbox.h), D = Math.max(.2,cbox.d),
+ HD = (state.H[i]+state.D[i]) - (H+D),
+ child = row[j].firstChild.style;
+ if (align === MML.ALIGN.TOP) {
+ if (HD) child.marginBottom = CHTML.Em(HD);
+ cell.verticalAlign = "top";
+ } else if (align === MML.ALIGN.BOTTOM) {
+ cell.verticalAlign = "bottom";
+ if (HD) child.marginTop = CHTML.Em(HD);
+ } else if (align === MML.ALIGN.CENTER) {
+ if (HD) child.marginTop = child.marginBottom = CHTML.Em(HD/2);
+ cell.verticalAlign = "middle";
+ } else {
+ if (H !== state.H[i]) child.marginTop = CHTML.Em(state.H[i]-H);
+ }
+ //
+ // Handle horizontal alignment
+ //
+ align = (mtd.columnalign||RCALIGN[i][j]||CALIGN[j]);
+ if (align !== MML.ALIGN.CENTER) cell.textAlign = align;
+ }
+ row.node.style.height = CHTML.Em(state.RHD[i]);
+ T = B;
+ }
+ CSPACE[state.J] /= 2; RSPACE[ROWS.length-1] /= 2; // back to normal
+ },
+ //
+ // Align the table vertically according to the align attribute
+ //
+ CHTMLalignV: function (values,state,node) {
+ var n, M = state.rows.length, H = state.H, D = state.D, RSPACE = state.RSPACE;
+ //
+ // Get alignment type and row number
+ //
+ if (typeof(values.align) !== "string") values.align = String(values.align);
+ if (values.align.match(/(top|bottom|center|baseline|axis)( +(-?\d+))?/)) {
+ n = parseInt(RegExp.$3||"0");
+ values.align = RegExp.$1
+ if (n < 0) n += state.rows.length + 1;
+ if (n > M || n <= 0) n = null;
+ } else {
+ values.align = this.defaults.align;
+ }
+ //
+ // Get table height and baseline offset
+ //
+ var T = 0, B = 0, a = CHTML.TEX.axis_height;
+ if (values.fspace) T += state.FSPACE[1];
+ if (values.frame) {T += 2/CHTML.em; B += 1/CHTML.em}
+ for (var i = 0; i < M; i++) {
+ var h = H[i], d = D[i];
+ T += h + d + RSPACE[i];
+ if (n) {
+ if (i === n-1) {
+ B += ({top:h+d, bottom:0, center:(h+d)/2,
+ baseline:d, axis:a+d})[values.align] + RSPACE[i];
+ }
+ if (i >= n) B += h + d + RSPACE[i];
+ }
+ }
+ if (!n) B = ({top:T, bottom:0, center:T/2, baseline:T/2, axis:T/2-a})[values.align];
+ //
+ // Place the node and save the values
+ //
+ if (B) node.style.verticalAlign = CHTML.Em(-B);
+ state.T = T; state.B = B;
+ },
+ //
+ // Determine column widths and set the styles for the columns
+ //
+ CHTMLcolumnWidths: function (values,state,node) {
+ var CWIDTH = state.CWIDTH, CSPACE = state.CSPACE, J = state.J, j;
+ var WW = 0, setWidths = false, relWidth = values.width.match(/%$/);
+ var i, m, w;
+ //
+ // Handle equal columns by adjusting the CWIDTH array
+ //
+ if (values.width !== "auto" && !relWidth) {
+ WW = Math.max(0,this.CHTMLlength2em(values.width,state.R));
+ setWidths = true;
+ }
+ if (values.equalcolumns) {
+ if (relWidth) {
+ //
+ // Use percent of total (not perfect, but best we can do)
+ //
+ var p = CHTML.Percent(1/(J+1));
+ for (j = 0; j <= J; j++) CWIDTH[j] = p;
+ } else {
+ //
+ // For width = auto, make all widths equal the widest,
+ // otherwise, for specific width, remove intercolumn space
+ // and divide by number of columns to get widest space.
+ //
+ w = Math.max.apply(Math,state.W);
+ if (values.width !== "auto") {
+ var S = (values.fspace ? state.FSPACE[0] + (values.frame ? 2/CHTML.em : 0) : 0);
+ for (j = 0; j <= J; j++) S += CSPACE[j];
+ w = Math.max((WW-S)/(J+1),w);
+ }
+ w = CHTML.Em(w);
+ for (j = 0; j <= J; j++) CWIDTH[j] = w;
+ }
+ setWidths = true;
+ }
+ //
+ // Compute natural table width
+ //
+ var TW = 0; if (values.fspace) TW = state.FSPACE[0];
+ var auto = [], fit = [], percent = [], W = [];
+ var row = state.rows[0];
+ for (j = 0; j <= J; j++) {
+ W[j] = state.W[j];
+ if (CWIDTH[j] === "auto") auto.push(j)
+ else if (CWIDTH[j] === "fit") fit.push(j)
+ else if (CWIDTH[j].match(/%$/)) percent.push(j)
+ else W[j] = this.CHTMLlength2em(CWIDTH[j],W[j]);
+ TW += W[j] + CSPACE[j];
+ if (row[j]) row[j].style.width = CHTML.Em(W[j]);
+ }
+ if (values.frame) TW += 2/CHTML.em;
+ var hasFit = (fit.length > 0);
+ //
+ // Adjust widths of columns
+ //
+ if (setWidths || (relWidth && hasFit)) {
+ if (relWidth) {
+ //
+ // Attach appropriate widths to the columns
+ //
+ for (j = 0; j <= J; j++) {
+ cell = row[j].style;
+ if (CWIDTH[j] === "auto" && !hasFit) cell.width = "";
+ else if (CWIDTH[j] === "fit") cell.width = "";
+ else if (CWIDTH[j].match(/%$/)) cell.width = CWIDTH[j];
+ else cell.minWidth = cell.maxWidth = cell.width;
+ }
+ } else {
+ //
+ // Compute percentage widths
+ //
+ if (WW > TW) {
+ var extra = 0;
+ for (i = 0, m = percent.length; i < m; i++) {
+ j = percent[i];
+ w = Math.max(W[j],this.CHTMLlength2em(CWIDTH[j],WW));
+ extra += w-W[j]; W[j] = w;
+ row[j].style.width = CHTML.Em(w);
+ }
+ TW += extra;
+ }
+ //
+ // Compute "fit" widths
+ //
+ if (!hasFit) fit = auto;
+ if (WW > TW && fit.length) {
+ var dw = (WW - TW) / fit.length;
+ for (i = 0, m = fit.length; i < m; i++) {
+ j = fit[i]; W[j] += dw;
+ row[j].style.width = CHTML.Em(W[j]);
+ }
+ TW = WW;
+ }
+ }
+ }
+ W[LABEL] = state.W[LABEL];
+ state.W = W;
+ state.R = TW;
+ //
+ // Set variable width on DOM nodes
+ //
+ if (relWidth) {
+ node.style.width = this.CHTML.pwidth = "100%";
+ this.CHTML.mwidth = CHTML.Em(TW);
+ node.firstChild.style.width = values.width;
+ node.firstChild.style.margin = "auto";
+ }
+ },
+ //
+ // Stretch any cells that can be stretched
+ //
+ CHTMLstretchCells: function (values,state) {
+ var ROWS = state.rows, H = state.H, D = state.D, W = state.W,
+ J = state.J, M = ROWS.length-1;
+ for (var i = 0; i <= M; i++) {
+ var row = ROWS[i], rdata = this.data[i];
+ var h = H[i], d = D[i];
+ for (var j = 0; j <= J; j++) {
+ var cell = row[j], cdata = rdata.data[j];
+ if (!cdata) continue;
+ if (cdata.CHTML.stretch === "V") cdata.CHTMLstretchV(h,d);
+ else if (cdata.CHTML.stretch === "H") cdata.CHTMLstretchH(cell,W[j]);
+ }
+ }
+ },
+ //
+ // Add labels to a table
+ //
+ CHTMLaddLabels: function (values,state,node,table) {
+ //
+ // Get indentation and alignment
+ //
+ var indent = this.getValues("indentalignfirst","indentshiftfirst","indentalign","indentshift");
+ if (indent.indentalignfirst !== MML.INDENTALIGN.INDENTALIGN) indent.indentalign = indent.indentalignfirst;
+ if (indent.indentalign === MML.INDENTALIGN.AUTO) indent.indentalign = CONFIG.displayAlign;
+ if (indent.indentshiftfirst !== MML.INDENTSHIFT.INDENTSHIFT) indent.indentshift = indent.indentshiftfirst;
+ if (indent.indentshift === "auto") indent.indentshift = "0";
+ var shift = this.CHTMLlength2em(indent.indentshift,CHTML.cwidth);
+ var labelspace = this.CHTMLlength2em(values.minlabelspacing,.8);
+ var labelW = labelspace + state.W[LABEL], labelshift = 0, tw = state.R;
+ var dIndent = this.CHTMLlength2em(CONFIG.displayIndent,CHTML.cwidth);
+ var s = (state.CALIGN[LABEL] === MML.INDENTALIGN.RIGHT ? -1 : 1);
+ if (indent.indentalign === MML.INDENTALIGN.CENTER) {
+ tw += 2 * (labelW - s*(shift + dIndent));
+ shift += dIndent;
+ } else if (state.CALIGN[LABEL] === indent.indentalign) {
+ if (dIndent < 0) {labelshift = s*dIndent; dIndent = 0}
+ shift += s*dIndent; if (labelW > s*shift) shift = s*labelW; shift += labelshift;
+ shift *= s; tw += shift;
+ } else {
+ tw += labelW - s*shift + dIndent;
+ shift -= s*dIndent; shift *= -s;
+ }
+ //
+ // Create boxes for table and labels
+ //
+ var box = CHTML.addElement(node,"mjx-box",{
+ style:{width:"100%","text-align":indent.indentalign}
+ }); box.appendChild(table);
+ var labels = CHTML.Element("mjx-itable");
+ table.style.display = "inline-table"; if (!table.style.width) table.style.width = "auto";
+ labels.style.verticalAlign = "top";
+ table.style.verticalAlign = CHTML.Em(state.T-state.B-state.H[0]);
+ node.style.verticalAlign = "";
+ if (shift) {
+ if (indent.indentalign === MML.INDENTALIGN.CENTER) {
+ table.style.marginLeft = CHTML.Em(shift);
+ table.style.marginRight = CHTML.Em(-shift);
+ } else {
+ var margin = "margin" + (indent.indentalign === MML.INDENTALIGN.RIGHT ? "Right" : "Left");
+ table.style[margin] = CHTML.Em(shift);
+ }
+ }
+ //
+ // Add labels on correct side
+ //
+ if (state.CALIGN[LABEL] === "left") {
+ node.insertBefore(labels,box);
+ labels.style.marginRight = CHTML.Em(-state.W[LABEL]-labelshift);
+ if (labelshift) labels.style.marginLeft = CHTML.Em(labelshift);
+ } else {
+ node.appendChild(labels);
+ labels.style.marginLeft = CHTML.Em(-state.W[LABEL]+labelshift);
+ }
+ //
+ // Vertically align the labels with their rows
+ //
+ var LABELS = state.labels, T = 0;
+ if (values.fspace) T = state.FSPACE[0] + (values.frame ? 1/CHTML.em : 0);
+ for (var i = 0, m = LABELS.length; i < m; i++) {
+ if (LABELS[i] && this.data[i].data[0]) {
+ labels.appendChild(LABELS[i]);
+ var lbox = this.data[i].data[0].CHTML;
+ T = state.RH[i] - Math.max(1,lbox.h);
+ if (T) LABELS[i].firstChild.firstChild.style.marginTop = CHTML.Em(T);
+ LABELS[i].style.height = CHTML.Em(state.RHD[i]);
+ } else {
+ CHTML.addElement(labels,"mjx-label",{style:{height:CHTML.Em(state.RHD[i])}});
+ }
+ }
+ //
+ // Propagate full-width equations, and reserve room for equation plus label
+ //
+ node.style.width = this.CHTML.pwidth = "100%";
+ node.style.minWidth = this.CHTML.mwidth = CHTML.Em(Math.max(0,tw));
+ }
+ });
+
+ MML.mtr.Augment({
+ toCommonHTML: function (node,options) {
+ //
+ // Create the row node
+ //
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLhandleScale(node);
+ //
+ // Add a new row with no label
+ //
+ if (!options) options = {rows:[],labels:[]};
+ var row = []; options.rows.push(row); row.node = node;
+ options.labels.push(null);
+ //
+ // Add the cells to the row
+ //
+ for (var i = 0, m = this.data.length; i < m; i++)
+ row.push(this.CHTMLaddChild(node,i,options));
+ //
+ this.CHTMLhandleColor(node);
+ return node;
+ }
+ });
+ MML.mlabeledtr.Augment({
+ toCommonHTML: function (node,options) {
+ //
+ // Create the row node
+ //
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLhandleScale(node);
+ //
+ // Add a new row, and get the label
+ //
+ if (!options) options = {rows:[],labels:[]};
+ var row = []; options.rows.push(row); row.node = node;
+ var label = CHTML.Element("mjx-label"); options.labels.push(label);
+ this.CHTMLaddChild(label,0,options);
+ if (this.data[0]) options.labeled = true;
+ //
+ // Add the cells to the row
+ //
+ for (var i = 1, m = this.data.length; i < m; i++)
+ row.push(this.CHTMLaddChild(node,i,options));
+ //
+ this.CHTMLhandleColor(node);
+ return node;
+ }
+ });
+ MML.mtd.Augment({
+ toCommonHTML: function (node,options) {
+ node = this.CHTMLdefaultNode(node,options);
+ CHTML.addElement(node.firstChild,"mjx-strut"); // forces height to 1em (we adjust later)
+ //
+ // Determine if this is stretchy or not
+ //
+ if (this.isEmbellished()) {
+ var mo = this.CoreMO(), BBOX = this.CHTML;
+ if (mo.CHTMLcanStretch("Vertical")) BBOX.stretch = "V";
+ else if (mo.CHTMLcanStretch("Horizontal")) BBOX.stretch = "H";
+ if (BBOX.stretch) {
+ var min = mo.Get("minsize",true);
+ if (min) {
+ if (BBOX.stretch === "V") {
+ var HD = BBOX.h + BBOX.d;
+ if (HD) {
+ var r = this.CHTMLlength2em(min,HD)/HD;
+ if (r > 1) {BBOX.h *= r; BBOX.d *= r}
+ }
+ } else {
+ BBOX.w = Math.max(BBOX.w,this.CHTMLlength2em(min,BBOX.w));
+ }
+ }
+ }
+ }
+ return node;
+ }
+ });
+
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML mtable Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/mtable.js");
+});
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/autoload/multiline.js b/js/mathjax/jax/output/CommonHTML/autoload/multiline.js
new file mode 100644
index 0000000..9d54b99
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/autoload/multiline.js
@@ -0,0 +1,799 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/autoload/multiline.js
+ *
+ * Implements the CommonHTML output for <mrow>'s that contain line breaks.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.Hub.Register.StartupHook("CommonHTML Jax Ready",function () {
+ var VERSION = "2.7.9";
+ var MML = MathJax.ElementJax.mml,
+ CONFIG = MathJax.Hub.config,
+ CHTML = MathJax.OutputJax.CommonHTML;
+ //
+ // Fake node used for testing end-of-line potential breakpoint
+ //
+ var MO = MML.mo().With({CHTML: CHTML.BBOX.empty()});
+
+ //
+ // Penalties for the various line breaks
+ //
+ var PENALTY = {
+ newline: 0,
+ nobreak: 1000000,
+ goodbreak: [-200],
+ badbreak: [+200],
+ auto: [0],
+
+ maxwidth: 1.33, // stop looking for breaks after this time the line-break width
+ toobig: 800,
+ nestfactor: 400,
+ spacefactor: -100,
+ spaceoffset: 2,
+ spacelimit: 1, // spaces larger than this get a penalty boost
+ fence: 500,
+ close: 500
+ };
+
+ var ENDVALUES = {linebreakstyle: "after"};
+
+
+ /**************************************************************************/
+
+ MML.mbase.Augment({
+ CHTMLlinebreakPenalty: PENALTY,
+
+ /****************************************************************/
+ //
+ // Handle breaking an mrow into separate lines
+ //
+ CHTMLmultiline: function (node) {
+
+ //
+ // Find the parent element and mark it as multiline
+ //
+ var parent = this;
+ while (parent.inferred || (parent.parent && parent.parent.type === "mrow" &&
+ parent.parent.isEmbellished())) {parent = parent.parent}
+ var isTop = ((parent.type === "math" && parent.Get("display") === "block") ||
+ parent.type === "mtd");
+ parent.isMultiline = true;
+
+ //
+ // Default values for the line-breaking parameters
+ //
+ var VALUES = this.getValues(
+ "linebreak","linebreakstyle","lineleading","linebreakmultchar",
+ "indentalign","indentshift",
+ "indentalignfirst","indentshiftfirst",
+ "indentalignlast","indentshiftlast"
+ );
+ if (VALUES.linebreakstyle === MML.LINEBREAKSTYLE.INFIXLINEBREAKSTYLE)
+ VALUES.linebreakstyle = this.Get("infixlinebreakstyle");
+ VALUES.lineleading = this.CHTMLlength2em(VALUES.lineleading,0.5);
+
+ //
+ // Break the math at its best line breaks
+ //
+ CHTML.BBOX.empty(this.CHTML);
+ var stack = CHTML.addElement(node,"mjx-stack");
+ var state = {
+ BBOX: this.CHTML,
+ n: 0, Y: 0,
+ scale: (this.CHTML.scale||1),
+ isTop: isTop,
+ values: {},
+ VALUES: VALUES
+ },
+ align = this.CHTMLgetAlign(state,{}),
+ shift = this.CHTMLgetShift(state,{},align),
+ start = [],
+ end = {
+ index:[], penalty:PENALTY.nobreak,
+ w:0, W:shift, shift:shift, scanW:shift,
+ nest: 0
+ },
+ broken = false;
+
+ while (this.CHTMLbetterBreak(end,state,true) &&
+ (end.scanW >= CHTML.linebreakWidth || end.penalty === PENALTY.newline)) {
+ this.CHTMLaddLine(stack,start,end.index,state,end.values,broken);
+ start = end.index.slice(0); broken = true;
+ align = this.CHTMLgetAlign(state,end.values);
+ shift = this.CHTMLgetShift(state,end.values,align);
+ end.W = end.shift = end.scanW = shift; end.penalty = PENALTY.nobreak;
+ }
+ state.isLast = true;
+ this.CHTMLaddLine(stack,start,[],state,ENDVALUES,broken);
+
+ if (parent.type === "math") {
+ node.style.width = stack.style.width = this.CHTML.pwidth = "100%";
+ }
+ this.CHTML.mwidth = CHTML.Em(this.CHTML.w);
+ this.CHTML.isMultiline = parent.CHTML.isMultiline = true;
+ stack.style.verticalAlign = CHTML.Em(state.d - this.CHTML.d);
+
+ return node;
+ },
+
+ /****************************************************************/
+ //
+ // Locate the next linebreak that is better than the current one
+ //
+ CHTMLbetterBreak: function (info,state,toplevel) {
+ if (this.isToken) return false; // FIXME: handle breaking of token elements
+ if (this.isEmbellished()) {
+ info.embellished = this;
+ return this.CoreMO().CHTMLbetterBreak(info,state);
+ }
+ if (this.linebreakContainer) return false;
+ //
+ // Get the current breakpoint position and other data
+ //
+ var index = info.index.slice(0), i = info.index.shift(),
+ m = this.data.length, W, w, scanW, broken = (info.index.length > 0), better = false;
+ if (i == null) i = -1; if (!broken) {i++; info.W += info.w; info.w = 0}
+ scanW = info.scanW = info.W; info.nest++;
+ //
+ // Look through the line for breakpoints,
+ // (as long as we are not too far past the breaking width)
+ //
+ while (i < m && (info.scanW < PENALTY.maxwidth*CHTML.linebreakWidth || info.w === 0)) {
+ if (this.data[i]) {
+ if (this.data[i].CHTMLbetterBreak(info,state)) {
+ better = true; index = [i].concat(info.index); W = info.W; w = info.w;
+ if (info.penalty === PENALTY.newline) {
+ info.index = index;
+ if (info.nest) {info.nest--}
+ return true;
+ }
+ }
+ scanW = (broken ? info.scanW : this.CHTMLaddWidth(i,info,scanW));
+ }
+ info.index = []; i++; broken = false;
+ }
+ //
+ // Check if end-of-line is a better breakpoint
+ //
+ if (toplevel && better) {
+ MO.parent = this.parent; MO.inherit = this.inherit;
+ if (MO.CHTMLbetterBreak(info,state)) {better = false; index = info.index}
+ }
+ if (info.nest) {info.nest--}
+ info.index = index;
+ if (better) {info.W = W; info.w = w}
+ return better;
+ },
+ CHTMLaddWidth: function (i,info,scanW) {
+ if (this.data[i]) {
+ var bbox = this.data[i].CHTML;
+ scanW += (bbox.w + (bbox.L||0) + (bbox.R||0)) * (bbox.scale || 1);
+ info.W = info.scanW = scanW; info.w = 0;
+ }
+ return scanW;
+ },
+
+ /****************************************************************/
+ //
+ // Create a new line and move the required elements into it
+ // Position it using proper alignment and indenting
+ //
+ CHTMLaddLine: function (stack,start,end,state,values,broken) {
+ //
+ // Create a box for the line, with empty BBox
+ // fill it with the proper elements,
+ // and clean up the bbox
+ //
+ var block = CHTML.addElement(stack,"mjx-block",{},[["mjx-box"]]), line = block.firstChild;
+ var bbox = state.bbox = CHTML.BBOX.empty();
+ state.first = broken; state.last = true;
+ this.CHTMLmoveLine(start,end,line,state,values);
+ bbox.clean();
+ //
+ // Get the alignment and shift values
+ //
+ var align = this.CHTMLgetAlign(state,values),
+ shift = this.CHTMLgetShift(state,values,align,true);
+ //
+ // Set the Y offset based on previous depth, leading, and current height
+ //
+ var dY = 0;
+ if (state.n > 0) {
+ var LHD = CHTML.FONTDATA.baselineskip;
+ var leading = (state.values.lineleading == null ? state.VALUES : state.values).lineleading * state.scale;
+ var Y = state.Y;
+ state.Y -= Math.max(LHD,state.d + bbox.h + leading);
+ dY = Y - state.Y - state.d - bbox.h;
+ }
+ //
+ // Place the new line
+ //
+ if (shift) line.style.margin = "0 "+CHTML.Em(-shift)+" 0 "+CHTML.Em(shift);
+ if (align !== MML.INDENTALIGN.LEFT) block.style.textAlign = align;
+ if (dY) block.style.paddingTop = CHTML.Em(dY);
+ state.BBOX.combine(bbox,shift,state.Y);
+ //
+ // Save the values needed for the future
+ //
+ state.d = state.bbox.d; state.values = values; state.n++;
+ },
+
+ /****************************************************************/
+ //
+ // Get alignment and shift values from the given data
+ //
+ CHTMLgetAlign: function (state,values) {
+ var cur = values, prev = state.values, def = state.VALUES, align;
+ if (state.n === 0) align = cur.indentalignfirst || prev.indentalignfirst || def.indentalignfirst;
+ else if (state.isLast) align = prev.indentalignlast || def.indentalignlast;
+ else align = prev.indentalign || def.indentalign;
+ if (align === MML.INDENTALIGN.INDENTALIGN) align = prev.indentalign || def.indentalign;
+ if (align === MML.INDENTALIGN.AUTO) align = (state.isTop ? CONFIG.displayAlign : MML.INDENTALIGN.LEFT);
+ return align;
+ },
+ CHTMLgetShift: function (state,values,align,noadjust) {
+ var cur = values, prev = state.values, def = state.VALUES, shift;
+ if (state.n === 0) shift = cur.indentshiftfirst || prev.indentshiftfirst || def.indentshiftfirst;
+ else if (state.isLast) shift = prev.indentshiftlast || def.indentshiftlast;
+ else shift = prev.indentshift || def.indentshift;
+ if (shift === MML.INDENTSHIFT.INDENTSHIFT) shift = prev.indentshift || def.indentshift;
+ if (shift === "auto" || shift === "") shift = "0";
+ shift = this.CHTMLlength2em(shift,CHTML.cwidth);
+ if (state.isTop && CONFIG.displayIndent !== "0") {
+ var indent = this.CHTMLlength2em(CONFIG.displayIndent,CHTML.cwidth);
+ shift += (align === MML.INDENTALIGN.RIGHT ? -indent : indent);
+ }
+ return (align === MML.INDENTALIGN.RIGHT && !noadjust ? -shift : shift);
+ },
+
+ /****************************************************************/
+ //
+ // Move the selected elements into the new line's box,
+ // moving whole items when possible, and parts of ones
+ // that are split by a line break.
+ //
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ var i = start[0], j = end[0];
+ if (i == null) i = -1; if (j == null) j = this.data.length-1;
+ if (i === j && start.length > 1) {
+ //
+ // If starting and ending in the same element move the subpiece to the new line
+ //
+ this.data[i].CHTMLmoveSlice(start.slice(1),end.slice(1),node,state,values,"marginLeft");
+ } else {
+ //
+ // Otherwise, move the remainder of the initial item
+ // and any others up to the last one
+ //
+ var last = state.last; state.last = false;
+ while (i < j) {
+ if (this.data[i]) {
+ if (start.length <= 1) this.data[i].CHTMLmoveNode(node,state,values);
+ else this.data[i].CHTMLmoveSlice(start.slice(1),[],node,state,values,"marginLeft");
+ }
+ i++; state.first = false; start = [];
+ }
+ //
+ // If the last item is complete, move it,
+ // otherwise move the first part of it up to the split
+ //
+ state.last = last;
+ if (this.data[i]) {
+ if (end.length <= 1) this.data[i].CHTMLmoveNode(node,state,values);
+ else this.data[i].CHTMLmoveSlice([],end.slice(1),node,state,values,"marginRight");
+ }
+ }
+ },
+
+ /****************************************************************/
+ //
+ // Split an element and copy the selected items into the new part
+ //
+ CHTMLmoveSlice: function (start,end,node,state,values,margin) {
+ //
+ // Create a new box for the slice of the element
+ // Move the selected portion into the slice
+ // If it is the last slice
+ // Remove the original (now empty) node
+ // Rename the Continue-0 node with the original name (for CHTMLnodeElement)
+ //
+ var slice = this.CHTMLcreateSliceNode(node);
+ this.CHTMLmoveLine(start,end,slice,state,values);
+ if (slice.style[margin]) slice.style[margin] = "";
+ if (this.CHTML.L) {
+ if (margin !== "marginLeft") state.bbox.w += this.CHTML.L;
+ else slice.className = slice.className.replace(/ MJXc-space\d/,"");
+ }
+ if (this.CHTML.R && margin !== "marginRight") state.bbox.w += this.CHTML.R;
+ if (end.length === 0) {
+ node = this.CHTMLnodeElement();
+ if (this.href) node = node.parentNode;
+ node.parentNode.removeChild(node);
+ node.nextMathJaxNode.id = node.id;
+ }
+ return slice;
+ },
+
+ /****************************************************************/
+ //
+ // Create a new node for an element that is split in two
+ // Clone the original and update its ID.
+ // Link the old node to the new one so we can find it later
+ //
+ CHTMLcreateSliceNode: function (node) {
+ var NODE = this.CHTMLnodeElement(), n = 0;
+ if (this.href) NODE = NODE.parentNode;
+ var LAST = NODE; while (LAST.nextMathJaxNode) {LAST = LAST.nextMathJaxNode; n++}
+ var SLICE = NODE.cloneNode(false); LAST.nextMathJaxNode = SLICE; SLICE.nextMathJaxNode = null;
+ SLICE.id += "-MJX-Continue-"+n;
+ return node.appendChild(SLICE);
+ },
+
+ /****************************************************************/
+ //
+ // Move an element from its original node to its new location in
+ // a split element or the new line's node
+ //
+ CHTMLmoveNode: function (line,state,values) {
+ // FIXME: handle linebreakstyle === "duplicate"
+ // FIXME: handle linebreakmultchar
+ if (!(state.first || state.last) ||
+ (state.first && state.values.linebreakstyle === MML.LINEBREAKSTYLE.BEFORE) ||
+ (state.last && values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER)) {
+ //
+ // Move node
+ //
+ var node = this.CHTMLnodeElement();
+ if (this.href) node = node.parentNode;
+ line.appendChild(node);
+ if (this.CHTML.pwidth && !line.style.width) line.style.width = this.CHTML.pwidth;
+ //
+ // If it is last, remove right margin
+ // If it is first, remove left margin
+ //
+ if (state.last) node.style.marginRight = "";
+ if (state.first || state.nextIsFirst) {
+ node.style.marginLeft = ""; this.CHTML.L = 0;
+ node.className = node.className.replace(/ MJXc-space\d/,"");
+ }
+ if (state.first && this.CHTML.w === 0) state.nextIsFirst = true;
+ else delete state.nextIsFirst;
+ //
+ // Update bounding box
+ //
+ state.bbox.combine(this.CHTML,state.bbox.w,0);
+ }
+ }
+ });
+
+ /**************************************************************************/
+
+ MML.mfenced.Augment({
+ CHTMLbetterBreak: function (info,state) {
+ //
+ // Get the current breakpoint position and other data
+ //
+ var index = info.index.slice(0), i = info.index.shift(),
+ m = this.data.length, W, w, scanW, broken = (info.index.length > 0), better = false;
+ if (i == null) i = -1; if (!broken) {i++; info.W += info.w; info.w = 0}
+ scanW = info.scanW = info.W; info.nest++;
+ //
+ // Create indices that include the delimiters and separators
+ //
+ if (!this.dataI) {
+ this.dataI = [];
+ if (this.data.open) this.dataI.push("open");
+ if (m) this.dataI.push(0);
+ for (var j = 1; j < m; j++) {
+ if (this.data["sep"+j]) this.dataI.push("sep"+j);
+ this.dataI.push(j);
+ }
+ if (this.data.close) this.dataI.push("close");
+ }
+ m = this.dataI.length;
+ //
+ // Look through the line for breakpoints, including the open, close, and separators
+ // (as long as we are not too far past the breaking width)
+ //
+ while (i < m && (info.scanW < PENALTY.maxwidth*CHTML.linebreakWidth || info.w === 0)) {
+ var k = this.dataI[i];
+ if (this.data[k]) {
+ if (this.data[k].CHTMLbetterBreak(info,state)) {
+ better = true; index = [i].concat(info.index); W = info.W; w = info.w;
+ if (info.penalty === PENALTY.newline) {
+ info.index = index;
+ if (info.nest) info.nest--;
+ return true;
+ }
+ }
+ scanW = (broken ? info.scanW : this.CHTMLaddWidth(i,info,scanW));
+ }
+ info.index = []; i++; broken = false;
+ }
+ if (info.nest) info.nest--;
+ info.index = index;
+ if (better) {info.W = W; info.w = w}
+ return better;
+ },
+
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ var i = start[0], j = end[0];
+ if (i == null) i = -1; if (j == null) j = this.dataI.length-1;
+ if (i === j && start.length > 1) {
+ //
+ // If starting and ending in the same element move the subpiece to the new line
+ //
+ this.data[this.dataI[i]].CHTMLmoveSlice(start.slice(1),end.slice(1),node,state,values,"marginLeft");
+ } else {
+ //
+ // Otherwise, move the remainder of the initial item
+ // and any others (including open and separators) up to the last one
+ //
+ var last = state.last; state.last = false; var k = this.dataI[i];
+ while (i < j) {
+ if (this.data[k]) {
+ if (start.length <= 1) this.data[k].CHTMLmoveNode(node,state,values);
+ else this.data[k].CHTMLmoveSlice(start.slice(1),[],node,state,values,"marginLeft");
+ }
+ i++; k = this.dataI[i]; state.first = false; start = [];
+ }
+ //
+ // If the last item is complete, move it
+ //
+ state.last = last;
+ if (this.data[k]) {
+ if (end.length <= 1) this.data[k].CHTMLmoveNode(node,state,values);
+ else this.data[k].CHTMLmoveSlice([],end.slice(1),node,state,values,"marginRight");
+ }
+ }
+ }
+
+ });
+
+ /**************************************************************************/
+
+ MML.msubsup.Augment({
+ CHTMLbetterBreak: function (info,state) {
+ if (!this.data[this.base]) {return false}
+ //
+ // Get the current breakpoint position and other data
+ //
+ var index = info.index.slice(0), i = info.index.shift(),
+ W, w, scanW, broken = (info.index.length > 0), better = false;
+ if (!broken) {info.W += info.w; info.w = 0}
+ scanW = info.scanW = info.W;
+ //
+ // Record the width of the base and the super- and subscripts
+ //
+ if (i == null) {
+ this.CHTML.baseW = this.data[this.base].CHTML.w;
+ this.CHTML.dw = this.CHTML.w - this.CHTML.baseW;
+ }
+ //
+ // Check if the base can be broken
+ //
+ if (this.data[this.base].CHTMLbetterBreak(info,state)) {
+ better = true; index = [this.base].concat(info.index); W = info.W; w = info.w;
+ if (info.penalty === PENALTY.newline) better = broken = true;
+ }
+ //
+ // Add in the base if it is unbroken, and add the scripts
+ //
+ if (!broken) this.CHTMLaddWidth(this.base,info,scanW);
+ info.scanW += this.CHTML.dw; info.W = info.scanW;
+ info.index = []; if (better) {info.W = W; info.w = w; info.index = index}
+ return better;
+ },
+
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ //
+ // Move the proper part of the base
+ //
+ if (this.data[this.base]) {
+ var base = CHTML.addElement(node,"mjx-base");
+ var ic = this.data[this.base].CHTML.ic;
+ if (ic) base.style.marginRight = CHTML.Em(-ic);
+ if (start.length > 1) {
+ this.data[this.base].CHTMLmoveSlice(start.slice(1),end.slice(1),base,state,values,"marginLeft");
+ } else {
+ if (end.length <= 1) this.data[this.base].CHTMLmoveNode(base,state,values);
+ else this.data[this.base].CHTMLmoveSlice([],end.slice(1),base,state,values,"marginRight");
+ }
+ }
+ //
+ // If this is the end, check for super and subscripts, and move those
+ // by moving the elements that contains them. Adjust the bounding box
+ // to include the super and subscripts.
+ //
+ if (end.length === 0) {
+ var NODE = this.CHTMLnodeElement(),
+ stack = CHTML.getNode(NODE,"mjx-stack"),
+ sup = CHTML.getNode(NODE,"mjx-sup"),
+ sub = CHTML.getNode(NODE,"mjx-sub");
+ if (stack) node.appendChild(stack);
+ else if (sup) node.appendChild(sup);
+ else if (sub) node.appendChild(sub);
+ var w = state.bbox.w, bbox;
+ if (sup) {
+ bbox = this.data[this.sup].CHTML;
+ state.bbox.combine(bbox,w,bbox.Y);
+ }
+ if (sub) {
+ bbox = this.data[this.sub].CHTML;
+ state.bbox.combine(bbox,w,bbox.Y);
+ }
+ }
+ }
+
+ });
+
+ /**************************************************************************/
+
+ MML.mmultiscripts.Augment({
+ CHTMLbetterBreak: function (info,state) {
+ if (!this.data[this.base]) return false;
+ //
+ // Get the current breakpoint position and other data
+ //
+ var index = info.index.slice(0); info.index.shift();
+ var W, w, scanW, broken = (info.index.length > 0), better = false;
+ if (!broken) {info.W += info.w; info.w = 0}
+ info.scanW = info.W;
+ //
+ // Get the bounding boxes and the width of the scripts
+ //
+ var bbox = this.CHTML, base = this.data[this.base].CHTML;
+ var dw = bbox.w - base.w - (bbox.X||0);
+ //
+ // Add in the width of the prescripts
+ //
+ info.scanW += bbox.X||0; scanW = info.scanW;
+ //
+ // Check if the base can be broken
+ //
+ if (this.data[this.base].CHTMLbetterBreak(info,state)) {
+ better = true; index = [this.base].concat(info.index); W = info.W; w = info.w;
+ if (info.penalty === PENALTY.newline) better = broken = true;
+ }
+ //
+ // Add in the base if it is unbroken, and add the scripts
+ //
+ if (!broken) this.CHTMLaddWidth(this.base,info,scanW);
+ info.scanW += dw; info.W = info.scanW;
+ info.index = []; if (better) {info.W = W; info.w = w; info.index = index}
+ return better;
+ },
+
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ var NODE, BOX = this.CHTMLbbox, w;
+ //
+ // If this is the start, move the prescripts, if any.
+ //
+ if (start.length < 1) {
+ NODE = this.CHTMLnodeElement();
+ var prestack = CHTML.getNode(NODE,"mjx-prestack"),
+ presup = CHTML.getNode(NODE,"mjx-presup"),
+ presub = CHTML.getNode(NODE,"mjx-presub");
+ if (prestack) node.appendChild(prestack);
+ else if (presup) node.appendChild(presup);
+ else if (presub) node.appendChild(presub);
+ w = state.bbox.w;
+ if (presup) state.bbox.combine(BOX.presup,w+BOX.presup.X,BOX.presup.Y);
+ if (presub) state.bbox.combine(BOX.presub,w+BOX.presub.X,BOX.presub.Y);
+ }
+ //
+ // Move the proper part of the base
+ //
+ if (this.data[this.base]) {
+ var base = CHTML.addElement(node,"mjx-base");
+ if (start.length > 1) {
+ this.data[this.base].CHTMLmoveSlice(start.slice(1),end.slice(1),base,state,values,"marginLeft");
+ } else {
+ if (end.length <= 1) this.data[this.base].CHTMLmoveNode(base,state,values);
+ else this.data[this.base].CHTMLmoveSlice([],end.slice(1),base,state,values,"marginRight");
+ }
+ }
+ //
+ // If this is the end, check for super and subscripts, and move those
+ // by moving the elements that contains them. Adjust the bounding box
+ // to include the super and subscripts.
+ //
+ if (end.length === 0) {
+ NODE = this.CHTMLnodeElement();
+ var stack = CHTML.getNode(NODE,"mjx-stack"),
+ sup = CHTML.getNode(NODE,"mjx-sup"),
+ sub = CHTML.getNode(NODE,"mjx-sub");
+ if (stack) node.appendChild(stack);
+ else if (sup) node.appendChild(sup);
+ else if (sub) node.appendChild(sub);
+ w = state.bbox.w;
+ if (sup) state.bbox.combine(BOX.sup,w,BOX.sup.Y);
+ if (sub) state.bbox.combine(BOX.sub,w,BOX.sub.Y);
+ }
+ }
+
+ });
+
+ /**************************************************************************/
+
+ MML.mo.Augment({
+ //
+ // Override the method for checking line breaks to properly handle <mo>
+ //
+ CHTMLbetterBreak: function (info,state) {
+ if (info.values && info.values.id === this.CHTMLnodeID) return false;
+ var values = this.getValues(
+ "linebreak","linebreakstyle","lineleading","linebreakmultchar",
+ "indentalign","indentshift",
+ "indentalignfirst","indentshiftfirst",
+ "indentalignlast","indentshiftlast",
+ "texClass", "fence"
+ );
+ if (values.linebreakstyle === MML.LINEBREAKSTYLE.INFIXLINEBREAKSTYLE)
+ values.linebreakstyle = this.Get("infixlinebreakstyle");
+ //
+ // Adjust nesting by TeX class (helps output that does not include
+ // mrows for nesting, but can leave these unbalanced.
+ //
+ if (values.texClass === MML.TEXCLASS.OPEN) info.nest++;
+ if (values.texClass === MML.TEXCLASS.CLOSE && info.nest) info.nest--;
+ //
+ // Get the default penalty for this location
+ //
+ var W = info.scanW; delete info.embellished;
+ var w = this.CHTML.w + (this.CHTML.L||0) + (this.CHTML.R||0);
+ if (values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER) {W += w; w = 0}
+ if (W - info.shift === 0 && values.linebreak !== MML.LINEBREAK.NEWLINE)
+ return false; // don't break at zero width (FIXME?)
+ var offset = CHTML.linebreakWidth - W;
+ // Adjust offest for explicit first-line indent and align
+ if (state.n === 0 && (values.indentshiftfirst !== state.VALUES.indentshiftfirst ||
+ values.indentalignfirst !== state.VALUES.indentalignfirst)) {
+ var align = this.CHTMLgetAlign(state,values),
+ shift = this.CHTMLgetShift(state,values,align);
+ offset += (info.shift - shift);
+ }
+ //
+ var penalty = Math.floor(offset / CHTML.linebreakWidth * 1000);
+ if (penalty < 0) penalty = PENALTY.toobig - 3*penalty;
+ if (values.fence) penalty += PENALTY.fence;
+ if ((values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER &&
+ values.texClass === MML.TEXCLASS.OPEN) ||
+ values.texClass === MML.TEXCLASS.CLOSE) penalty += PENALTY.close;
+ penalty += info.nest * PENALTY.nestfactor;
+ //
+ // Get the penalty for this type of break and
+ // use it to modify the default penalty
+ //
+ var linebreak = PENALTY[values.linebreak||MML.LINEBREAK.AUTO]||0;
+ if (!MathJax.Object.isArray(linebreak)) {
+ // for breaks past the width, keep original penalty for newline
+ if (linebreak || offset >= 0) {penalty = linebreak * info.nest}
+ } else {penalty = Math.max(1,penalty + linebreak[0] * info.nest)}
+ //
+ // If the penalty is no better than the current one, return false
+ // Otherwise save the data for this breakpoint and return true
+ //
+ if (penalty >= info.penalty) return false;
+ info.penalty = penalty; info.values = values; info.W = W; info.w = w;
+ values.lineleading = this.CHTMLlength2em(values.lineleading,state.VALUES.lineleading);
+ values.id = this.CHTMLnodeID;
+ return true;
+ }
+ });
+
+ /**************************************************************************/
+
+ MML.mspace.Augment({
+ //
+ // Override the method for checking line breaks to properly handle <mspace>
+ //
+ CHTMLbetterBreak: function (info,state) {
+ if (info.values && info.values.id === this.CHTMLnodeID) return false;
+ var values = this.getValues("linebreak");
+ var linebreakValue = values.linebreak;
+ if (!linebreakValue || this.hasDimAttr()) {
+ // The MathML spec says that the linebreak attribute should be ignored
+ // if any dimensional attribute is set.
+ linebreakValue = MML.LINEBREAK.AUTO;
+ }
+ //
+ // Get the default penalty for this location
+ //
+ var W = info.scanW, w = this.CHTML.w + (this.CHTML.L||0) + (this.CHTML.R||0);
+ if (W - info.shift === 0) return false; // don't break at zero width (FIXME?)
+ var offset = CHTML.linebreakWidth - W;
+ //
+ var penalty = Math.floor(offset / CHTML.linebreakWidth * 1000);
+ if (penalty < 0) penalty = PENALTY.toobig - 3*penalty;
+ penalty += info.nest * PENALTY.nestfactor;
+ //
+ // Get the penalty for this type of break and
+ // use it to modify the default penalty
+ //
+ var linebreak = PENALTY[linebreakValue]||0;
+ if (linebreakValue === MML.LINEBREAK.AUTO && w >= PENALTY.spacelimit &&
+ !this.mathbackground && !this.background)
+ linebreak = [(w+PENALTY.spaceoffset)*PENALTY.spacefactor];
+ if (!MathJax.Object.isArray(linebreak)) {
+ // for breaks past the width, keep original penalty for newline
+ if (linebreak || offset >= 0) {penalty = linebreak * info.nest}
+ } else {penalty = Math.max(1,penalty + linebreak[0] * info.nest)}
+ //
+ // If the penalty is no better than the current one, return false
+ // Otherwise save the data for this breakpoint and return true
+ //
+ if (penalty >= info.penalty) return false;
+ info.penalty = penalty; info.values = values; info.W = W; info.w = w;
+ values.lineleading = state.VALUES.lineleading;
+ values.linebreakstyle = "before"; values.id = this.CHTMLnodeID;
+ return true;
+ }
+ });
+
+ //
+ // Hook into the mathchoice extension
+ //
+ MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () {
+ MML.TeXmathchoice.Augment({
+ CHTMLbetterBreak: function (info,state) {
+ return this.Core().CHTMLbetterBreak(info,state);
+ },
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ return this.Core().CHTMLmoveSlice(start,end,node,state,values);
+ }
+ });
+ });
+
+ //
+ // Have maction process only the selected item
+ //
+ MML.maction.Augment({
+ CHTMLbetterBreak: function (info,state) {
+ return this.Core().CHTMLbetterBreak(info,state);
+ },
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ return this.Core().CHTMLmoveSlice(start,end,node,state,values);
+ }
+ });
+
+ //
+ // Have semantics only do the first element
+ // (FIXME: do we need to do anything special about annotation-xml?)
+ //
+ MML.semantics.Augment({
+ CHTMLbetterBreak: function (info,state) {
+ return (this.data[0] ? this.data[0].CHTMLbetterBreak(info,state) : false);
+ },
+ CHTMLmoveLine: function (start,end,node,state,values) {
+ return (this.data[0] ? this.data[0].CHTMLmoveSlice(start,end,node,state,values) : null);
+ }
+ });
+
+ /**************************************************************************/
+
+ MathJax.Hub.Startup.signal.Post("CommonHTML multiline Ready");
+ MathJax.Ajax.loadComplete(CHTML.autoloadDir+"/multiline.js");
+
+});
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/config.js b/js/mathjax/jax/output/CommonHTML/config.js
new file mode 100644
index 0000000..9708c55
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/config.js
@@ -0,0 +1,66 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML2/config.js
+ *
+ * Initializes the HTML2 OutputJax (the main definition is in
+ * MathJax/jax/input/HTML2/jax.js, which is loaded when needed).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2013-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.OutputJax.CommonHTML = MathJax.OutputJax({
+ id: "CommonHTML",
+ version: "2.7.9",
+ directory: MathJax.OutputJax.directory + "/CommonHTML",
+ extensionDir: MathJax.OutputJax.extensionDir + "/CommonHTML",
+ autoloadDir: MathJax.OutputJax.directory + "/CommonHTML/autoload",
+ fontDir: MathJax.OutputJax.directory + "/CommonHTML/fonts", // fontname added later
+ webfontDir: MathJax.OutputJax.fontDir + "/HTML-CSS", // fontname added later
+
+ config: {
+ matchFontHeight: true, // try to match math font height to surrounding font?
+ scale: 100, minScaleAdjust: 50, // global math scaling factor, and minimum adjusted scale factor
+ mtextFontInherit: false, // to make <mtext> be in page font rather than MathJax font
+ undefinedFamily: "STIXGeneral,'Cambria Math','Arial Unicode MS',serif",
+
+ EqnChunk: (MathJax.Hub.Browser.isMobile ? 20: 100),
+ // number of equations to process before showing them
+ EqnChunkFactor: 1.5, // chunk size is multiplied by this after each chunk
+ EqnChunkDelay: 100, // milliseconds to delay between chunks (to let browser
+ // respond to other events)
+
+ linebreaks: {
+ automatic: false, // when false, only process linebreak="newline",
+ // when true, insert line breaks automatically in long expressions.
+
+ width: "container" // maximum width of a line for automatic line breaks (e.g. "30em").
+ // use "container" to compute size from containing element,
+ // use "nn% container" for a portion of the container,
+ // use "nn%" for a portion of the window size
+ }
+
+ }
+});
+
+if (!MathJax.Hub.config.delayJaxRegistration) {MathJax.OutputJax.CommonHTML.Register("jax/mml")}
+
+MathJax.OutputJax.CommonHTML.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/AMS-Regular.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/AMS-Regular.js
new file mode 100644
index 0000000..4057716
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/AMS-Regular.js
@@ -0,0 +1,291 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/AMS-Regular.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_AMS';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 270, ascent: 1003, descent: 463,
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x41: [701,1,722,17,703], // LATIN CAPITAL LETTER A
+ 0x42: [683,1,667,11,620], // LATIN CAPITAL LETTER B
+ 0x43: [702,19,722,39,684], // LATIN CAPITAL LETTER C
+ 0x44: [683,1,722,16,688], // LATIN CAPITAL LETTER D
+ 0x45: [683,1,667,12,640], // LATIN CAPITAL LETTER E
+ 0x46: [683,1,611,12,584], // LATIN CAPITAL LETTER F
+ 0x47: [702,19,778,39,749], // LATIN CAPITAL LETTER G
+ 0x48: [683,1,778,14,762], // LATIN CAPITAL LETTER H
+ 0x49: [683,1,389,20,369], // LATIN CAPITAL LETTER I
+ 0x4A: [683,77,500,6,478], // LATIN CAPITAL LETTER J
+ 0x4B: [683,1,778,22,768], // LATIN CAPITAL LETTER K
+ 0x4C: [683,1,667,12,640], // LATIN CAPITAL LETTER L
+ 0x4D: [683,1,944,17,926], // LATIN CAPITAL LETTER M
+ 0x4E: [683,20,722,20,702], // LATIN CAPITAL LETTER N
+ 0x4F: [701,19,778,34,742], // LATIN CAPITAL LETTER O
+ 0x50: [683,1,611,16,597], // LATIN CAPITAL LETTER P
+ 0x51: [701,181,778,34,742], // LATIN CAPITAL LETTER Q
+ 0x52: [683,1,722,16,705], // LATIN CAPITAL LETTER R
+ 0x53: [702,12,556,28,528], // LATIN CAPITAL LETTER S
+ 0x54: [683,1,667,33,635], // LATIN CAPITAL LETTER T
+ 0x55: [683,19,722,16,709], // LATIN CAPITAL LETTER U
+ 0x56: [683,20,722,0,719], // LATIN CAPITAL LETTER V
+ 0x57: [683,19,1000,5,994], // LATIN CAPITAL LETTER W
+ 0x58: [683,1,722,16,705], // LATIN CAPITAL LETTER X
+ 0x59: [683,1,722,16,704], // LATIN CAPITAL LETTER Y
+ 0x5A: [683,1,667,29,635], // LATIN CAPITAL LETTER Z
+ 0x6B: [683,1,556,17,534], // LATIN SMALL LETTER K
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0xA5: [683,0,750,11,738], // YEN SIGN
+ 0xAE: [709,175,947,32,915], // REGISTERED SIGN
+ 0xF0: [749,21,556,42,509], // LATIN SMALL LETTER ETH
+ 0x127: [695,13,540,42,562], // LATIN SMALL LETTER H WITH STROKE
+ 0x2C6: [845,-561,2333,-14,2346], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2DC: [899,-628,2333,1,2330], // SMALL TILDE
+ 0x302: [845,-561,0,-2347,13], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [899,-628,0,-2332,-3], // COMBINING TILDE
+ 0x3DD: [605,85,778,55,719], // GREEK SMALL LETTER DIGAMMA
+ 0x3F0: [434,6,667,37,734], // GREEK KAPPA SYMBOL
+ 0x2035: [560,-43,275,12,244], // REVERSED PRIME
+ 0x210F: [695,13,540,42,562], // stix-/hbar - Planck's over 2pi
+ 0x2127: [684,22,722,44,675], // INVERTED OHM SIGN
+ 0x2132: [695,1,556,55,497], // TURNED CAPITAL F
+ 0x2136: [763,21,667,-22,687], // BET SYMBOL
+ 0x2137: [764,43,444,-22,421], // GIMEL SYMBOL
+ 0x2138: [764,43,667,54,640], // DALET SYMBOL
+ 0x2141: [705,23,639,37,577], // TURNED SANS-SERIF CAPITAL G
+ 0x2190: [437,-64,500,64,422], // LEFTWARDS ARROW
+ 0x2192: [437,-64,500,58,417], // RIGHTWARDS ARROW
+ 0x219A: [437,-60,1000,56,942], // LEFTWARDS ARROW WITH STROKE
+ 0x219B: [437,-60,1000,54,942], // RIGHTWARDS ARROW WITH STROKE
+ 0x219E: [417,-83,1000,56,944], // LEFTWARDS TWO HEADED ARROW
+ 0x21A0: [417,-83,1000,55,943], // RIGHTWARDS TWO HEADED ARROW
+ 0x21A2: [417,-83,1111,56,1031], // LEFTWARDS ARROW WITH TAIL
+ 0x21A3: [417,-83,1111,79,1054], // RIGHTWARDS ARROW WITH TAIL
+ 0x21AB: [575,41,1000,56,964], // LEFTWARDS ARROW WITH LOOP
+ 0x21AC: [575,41,1000,35,943], // RIGHTWARDS ARROW WITH LOOP
+ 0x21AD: [417,-83,1389,57,1331], // LEFT RIGHT WAVE ARROW
+ 0x21AE: [437,-60,1000,56,942], // LEFT RIGHT ARROW WITH STROKE
+ 0x21B0: [722,0,500,56,444], // UPWARDS ARROW WITH TIP LEFTWARDS
+ 0x21B1: [722,0,500,55,443], // UPWARDS ARROW WITH TIP RIGHTWARDS
+ 0x21B6: [461,1,1000,17,950], // ANTICLOCKWISE TOP SEMICIRCLE ARROW
+ 0x21B7: [460,1,1000,46,982], // CLOCKWISE TOP SEMICIRCLE ARROW
+ 0x21BA: [650,83,778,56,722], // ANTICLOCKWISE OPEN CIRCLE ARROW
+ 0x21BB: [650,83,778,56,721], // CLOCKWISE OPEN CIRCLE ARROW
+ 0x21BE: [694,194,417,188,375], // UPWARDS HARPOON WITH BARB RIGHTWARDS
+ 0x21BF: [694,194,417,41,228], // UPWARDS HARPOON WITH BARB LEFTWARDS
+ 0x21C2: [694,194,417,188,375], // DOWNWARDS HARPOON WITH BARB RIGHTWARDS
+ 0x21C3: [694,194,417,41,228], // DOWNWARDS HARPOON WITH BARB LEFTWARDS
+ 0x21C4: [667,0,1000,55,944], // RIGHTWARDS ARROW OVER LEFTWARDS ARROW
+ 0x21C6: [667,0,1000,55,944], // LEFTWARDS ARROW OVER RIGHTWARDS ARROW
+ 0x21C7: [583,83,1000,55,944], // LEFTWARDS PAIRED ARROWS
+ 0x21C8: [694,193,833,83,749], // UPWARDS PAIRED ARROWS
+ 0x21C9: [583,83,1000,55,944], // RIGHTWARDS PAIRED ARROWS
+ 0x21CA: [694,194,833,83,749], // DOWNWARDS PAIRED ARROWS
+ 0x21CB: [514,14,1000,55,944], // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
+ 0x21CC: [514,14,1000,55,944], // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+ 0x21CD: [534,35,1000,54,942], // LEFTWARDS DOUBLE ARROW WITH STROKE
+ 0x21CE: [534,37,1000,32,965], // LEFT RIGHT DOUBLE ARROW WITH STROKE
+ 0x21CF: [534,35,1000,55,943], // RIGHTWARDS DOUBLE ARROW WITH STROKE
+ 0x21DA: [611,111,1000,76,944], // LEFTWARDS TRIPLE ARROW
+ 0x21DB: [611,111,1000,55,923], // RIGHTWARDS TRIPLE ARROW
+ 0x21DD: [417,-83,1000,56,943], // RIGHTWARDS SQUIGGLE ARROW
+ 0x21E0: [437,-64,1334,64,1251], // LEFTWARDS DASHED ARROW
+ 0x21E2: [437,-64,1334,84,1251], // RIGHTWARDS DASHED ARROW
+ 0x2201: [846,21,500,56,444], // COMPLEMENT
+ 0x2204: [860,166,556,55,497], // THERE DOES NOT EXIST
+ 0x2205: [587,3,778,54,720], // EMPTY SET
+ 0x220D: [440,1,429,102,456], // SMALL CONTAINS AS MEMBER
+ 0x2212: [270,-230,500,84,417], // MINUS SIGN
+ 0x2214: [766,93,778,57,722], // DOT PLUS
+ 0x2216: [430,23,778,91,685], // SET MINUS
+ 0x221D: [472,-28,778,56,722], // PROPORTIONAL TO
+ 0x2220: [694,0,722,55,666], // ANGLE
+ 0x2221: [714,20,722,55,666], // MEASURED ANGLE
+ 0x2222: [551,51,722,55,666], // SPHERICAL ANGLE
+ 0x2223: [430,23,222,91,131], // DIVIDES
+ 0x2224: [750,252,278,-21,297], // DOES NOT DIVIDE
+ 0x2225: [431,23,389,55,331], // PARALLEL TO
+ 0x2226: [750,250,500,-20,518], // NOT PARALLEL TO
+ 0x2234: [471,82,667,24,643], // THEREFORE
+ 0x2235: [471,82,667,23,643], // BECAUSE
+ 0x223C: [365,-132,778,55,719], // TILDE OPERATOR
+ 0x223D: [367,-133,778,56,722], // REVERSED TILDE
+ 0x2241: [467,-32,778,55,719], // stix-not, vert, similar
+ 0x2242: [463,-34,778,55,720], // MINUS TILDE
+ 0x2246: [652,155,778,54,720], // APPROXIMATELY BUT NOT ACTUALLY EQUAL TO
+ 0x2248: [481,-50,778,55,719], // ALMOST EQUAL TO
+ 0x224A: [579,39,778,51,725], // ALMOST EQUAL OR EQUAL TO
+ 0x224E: [492,-8,778,56,722], // GEOMETRICALLY EQUIVALENT TO
+ 0x224F: [492,-133,778,56,722], // DIFFERENCE BETWEEN
+ 0x2251: [609,108,778,56,722], // GEOMETRICALLY EQUAL TO
+ 0x2252: [601,101,778,15,762], // APPROXIMATELY EQUAL TO OR THE IMAGE OF
+ 0x2253: [601,102,778,14,762], // IMAGE OF OR APPROXIMATELY EQUAL TO
+ 0x2256: [367,-133,778,56,722], // RING IN EQUAL TO
+ 0x2257: [721,-133,778,56,722], // RING EQUAL TO
+ 0x225C: [859,-133,778,56,723], // DELTA EQUAL TO
+ 0x2266: [753,175,778,83,694], // LESS-THAN OVER EQUAL TO
+ 0x2267: [753,175,778,83,694], // GREATER-THAN OVER EQUAL TO
+ 0x2268: [752,286,778,82,693], // stix-less, vert, not double equals
+ 0x2269: [752,286,778,82,693], // stix-gt, vert, not double equals
+ 0x226C: [750,250,500,74,425], // BETWEEN
+ 0x226E: [708,209,778,82,693], // stix-not, vert, less-than
+ 0x226F: [708,209,778,82,693], // stix-not, vert, greater-than
+ 0x2270: [801,303,778,82,694], // stix-not, vert, less-than-or-equal
+ 0x2271: [801,303,778,82,694], // stix-not, vert, greater-than-or-equal
+ 0x2272: [732,228,778,56,722], // stix-less-than or (contour) similar
+ 0x2273: [732,228,778,56,722], // stix-greater-than or (contour) similar
+ 0x2276: [681,253,778,44,734], // LESS-THAN OR GREATER-THAN
+ 0x2277: [681,253,778,83,694], // GREATER-THAN OR LESS-THAN
+ 0x227C: [580,153,778,83,694], // PRECEDES OR EQUAL TO
+ 0x227D: [580,154,778,82,694], // SUCCEEDS OR EQUAL TO
+ 0x227E: [732,228,778,56,722], // PRECEDES OR EQUIVALENT TO
+ 0x227F: [732,228,778,56,722], // SUCCEEDS OR EQUIVALENT TO
+ 0x2280: [705,208,778,82,693], // DOES NOT PRECEDE
+ 0x2281: [705,208,778,82,693], // stix-not (vert) succeeds
+ 0x2288: [801,303,778,83,693], // stix-/nsubseteq N: not (vert) subset, equals
+ 0x2289: [801,303,778,82,691], // stix-/nsupseteq N: not (vert) superset, equals
+ 0x228A: [635,241,778,84,693], // stix-subset, not equals, variant
+ 0x228B: [635,241,778,82,691], // stix-superset, not equals, variant
+ 0x228F: [539,41,778,83,694], // SQUARE IMAGE OF
+ 0x2290: [539,41,778,64,714], // SQUARE ORIGINAL OF
+ 0x229A: [582,82,778,57,721], // CIRCLED RING OPERATOR
+ 0x229B: [582,82,778,57,721], // CIRCLED ASTERISK OPERATOR
+ 0x229D: [582,82,778,57,721], // CIRCLED DASH
+ 0x229E: [689,0,778,55,722], // SQUARED PLUS
+ 0x229F: [689,0,778,55,722], // SQUARED MINUS
+ 0x22A0: [689,0,778,55,722], // SQUARED TIMES
+ 0x22A1: [689,0,778,55,722], // SQUARED DOT OPERATOR
+ 0x22A8: [694,0,611,55,555], // TRUE
+ 0x22A9: [694,0,722,55,666], // FORCES
+ 0x22AA: [694,0,889,55,833], // TRIPLE VERTICAL BAR RIGHT TURNSTILE
+ 0x22AC: [695,1,611,-55,554], // DOES NOT PROVE
+ 0x22AD: [695,1,611,-55,554], // NOT TRUE
+ 0x22AE: [695,1,722,-55,665], // DOES NOT FORCE
+ 0x22AF: [695,1,722,-55,665], // NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
+ 0x22B2: [539,41,778,83,694], // NORMAL SUBGROUP OF
+ 0x22B3: [539,41,778,83,694], // CONTAINS AS NORMAL SUBGROUP
+ 0x22B4: [636,138,778,83,694], // NORMAL SUBGROUP OF OR EQUAL TO
+ 0x22B5: [636,138,778,83,694], // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
+ 0x22B8: [408,-92,1111,55,1055], // MULTIMAP
+ 0x22BA: [431,212,556,57,500], // INTERCALATE
+ 0x22BB: [716,0,611,55,555], // XOR
+ 0x22BC: [716,0,611,55,555], // NAND
+ 0x22C5: [189,0,278,55,222], // DOT OPERATOR
+ 0x22C7: [545,44,778,55,720], // DIVISION TIMES
+ 0x22C9: [492,-8,778,146,628], // LEFT NORMAL FACTOR SEMIDIRECT PRODUCT
+ 0x22CA: [492,-8,778,146,628], // RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT
+ 0x22CB: [694,22,778,55,722], // LEFT SEMIDIRECT PRODUCT
+ 0x22CC: [694,22,778,55,722], // RIGHT SEMIDIRECT PRODUCT
+ 0x22CD: [464,-36,778,56,722], // REVERSED TILDE EQUALS
+ 0x22CE: [578,21,760,83,676], // CURLY LOGICAL OR
+ 0x22CF: [578,22,760,83,676], // CURLY LOGICAL AND
+ 0x22D0: [540,40,778,84,694], // DOUBLE SUBSET
+ 0x22D1: [540,40,778,83,693], // DOUBLE SUPERSET
+ 0x22D2: [598,22,667,55,611], // DOUBLE INTERSECTION
+ 0x22D3: [598,22,667,55,611], // DOUBLE UNION
+ 0x22D4: [736,22,667,56,611], // PITCHFORK
+ 0x22D6: [541,41,778,82,693], // LESS-THAN WITH DOT
+ 0x22D7: [541,41,778,82,693], // GREATER-THAN WITH DOT
+ 0x22D8: [568,67,1333,56,1277], // VERY MUCH LESS-THAN
+ 0x22D9: [568,67,1333,55,1277], // VERY MUCH GREATER-THAN
+ 0x22DA: [886,386,778,83,674], // stix-less, equal, slanted, greater
+ 0x22DB: [886,386,778,83,674], // stix-greater, equal, slanted, less
+ 0x22DE: [734,0,778,83,694], // EQUAL TO OR PRECEDES
+ 0x22DF: [734,0,778,82,694], // EQUAL TO OR SUCCEEDS
+ 0x22E0: [801,303,778,82,693], // stix-not (vert) precedes or contour equals
+ 0x22E1: [801,303,778,82,694], // stix-not (vert) succeeds or contour equals
+ 0x22E6: [730,359,778,55,719], // LESS-THAN BUT NOT EQUIVALENT TO
+ 0x22E7: [730,359,778,55,719], // GREATER-THAN BUT NOT EQUIVALENT TO
+ 0x22E8: [730,359,778,55,719], // PRECEDES BUT NOT EQUIVALENT TO
+ 0x22E9: [730,359,778,55,719], // SUCCEEDS BUT NOT EQUIVALENT TO
+ 0x22EA: [706,208,778,82,693], // NOT NORMAL SUBGROUP OF
+ 0x22EB: [706,208,778,82,693], // DOES NOT CONTAIN AS NORMAL SUBGROUP
+ 0x22EC: [802,303,778,82,693], // stix-not, vert, left triangle, equals
+ 0x22ED: [801,303,778,82,693], // stix-not, vert, right triangle, equals
+ 0x2322: [378,-122,778,55,722], // stix-small down curve
+ 0x2323: [378,-143,778,55,722], // stix-small up curve
+ 0x24C8: [709,175,902,8,894], // CIRCLED LATIN CAPITAL LETTER S
+ 0x250C: [694,-306,500,55,444], // BOX DRAWINGS LIGHT DOWN AND RIGHT
+ 0x2510: [694,-306,500,55,444], // BOX DRAWINGS LIGHT DOWN AND LEFT
+ 0x2514: [366,22,500,55,444], // BOX DRAWINGS LIGHT UP AND RIGHT
+ 0x2518: [366,22,500,55,444], // BOX DRAWINGS LIGHT UP AND LEFT
+ 0x2571: [694,195,889,0,860], // BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT
+ 0x2572: [694,195,889,0,860], // BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT
+ 0x25A0: [689,0,778,55,722], // BLACK SQUARE
+ 0x25A1: [689,0,778,55,722], // WHITE SQUARE
+ 0x25B2: [575,20,722,84,637], // BLACK UP-POINTING TRIANGLE
+ 0x25B3: [575,20,722,84,637], // WHITE UP-POINTING TRIANGLE
+ 0x25B6: [539,41,778,83,694], // BLACK RIGHT-POINTING TRIANGLE
+ 0x25BC: [576,19,722,84,637], // BLACK DOWN-POINTING TRIANGLE
+ 0x25BD: [576,19,722,84,637], // WHITE DOWN-POINTING TRIANGLE
+ 0x25C0: [539,41,778,83,694], // BLACK LEFT-POINTING TRIANGLE
+ 0x25CA: [716,132,667,56,611], // LOZENGE
+ 0x2605: [694,111,944,49,895], // BLACK STAR
+ 0x2713: [706,34,833,84,749], // CHECK MARK
+ 0x2720: [716,22,833,48,786], // MALTESE CROSS
+ 0x29EB: [716,132,667,56,611], // BLACK LOZENGE
+ 0x2A5E: [813,97,611,55,555], // LOGICAL AND WITH DOUBLE OVERBAR
+ 0x2A7D: [636,138,778,83,694], // LESS-THAN OR SLANTED EQUAL TO
+ 0x2A7E: [636,138,778,83,694], // GREATER-THAN OR SLANTED EQUAL TO
+ 0x2A85: [762,290,778,55,722], // LESS-THAN OR APPROXIMATE
+ 0x2A86: [762,290,778,55,722], // GREATER-THAN OR APPROXIMATE
+ 0x2A87: [635,241,778,82,693], // LESS-THAN AND SINGLE-LINE NOT EQUAL TO
+ 0x2A88: [635,241,778,82,693], // GREATER-THAN AND SINGLE-LINE NOT EQUAL TO
+ 0x2A89: [761,387,778,57,718], // LESS-THAN AND NOT APPROXIMATE
+ 0x2A8A: [761,387,778,57,718], // GREATER-THAN AND NOT APPROXIMATE
+ 0x2A8B: [1003,463,778,83,694], // LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN
+ 0x2A8C: [1003,463,778,83,694], // GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN
+ 0x2A95: [636,138,778,83,694], // SLANTED EQUAL TO OR LESS-THAN
+ 0x2A96: [636,138,778,83,694], // SLANTED EQUAL TO OR GREATER-THAN
+ 0x2AB5: [752,286,778,82,693], // PRECEDES ABOVE NOT EQUAL TO
+ 0x2AB6: [752,286,778,82,693], // SUCCEEDS ABOVE NOT EQUAL TO
+ 0x2AB7: [761,294,778,57,717], // PRECEDES ABOVE ALMOST EQUAL TO
+ 0x2AB8: [761,294,778,57,717], // SUCCEEDS ABOVE ALMOST EQUAL TO
+ 0x2AB9: [761,337,778,57,718], // PRECEDES ABOVE NOT ALMOST EQUAL TO
+ 0x2ABA: [761,337,778,57,718], // SUCCEEDS ABOVE NOT ALMOST EQUAL TO
+ 0x2AC5: [753,215,778,84,694], // SUBSET OF ABOVE EQUALS SIGN
+ 0x2AC6: [753,215,778,83,694], // SUPERSET OF ABOVE EQUALS SIGN
+ 0x2ACB: [783,385,778,82,693], // stix-subset not double equals, variant
+ 0x2ACC: [783,385,778,82,693], // SUPERSET OF ABOVE NOT EQUAL TO
+ 0xE006: [430,23,222,-20,240], // ??
+ 0xE007: [431,24,389,-20,407], // ??
+ 0xE008: [605,85,778,55,719], // ??
+ 0xE009: [434,6,667,37,734], // ??
+ 0xE00C: [752,284,778,82,693], // ??
+ 0xE00D: [752,284,778,82,693], // ??
+ 0xE00E: [919,421,778,82,694], // stix-not greater, double equals
+ 0xE00F: [801,303,778,82,694], // stix-not greater-or-equal, slanted
+ 0xE010: [801,303,778,82,694], // stix-not less-or-equal, slanted
+ 0xE011: [919,421,778,82,694], // stix-not less, double equals
+ 0xE016: [828,330,778,82,694], // stix-not subset, double equals
+ 0xE017: [752,332,778,82,694], // ??
+ 0xE018: [828,330,778,82,694], // stix-not superset, double equals
+ 0xE019: [752,333,778,82,693], // ??
+ 0xE01A: [634,255,778,84,693], // ??
+ 0xE01B: [634,254,778,82,691] // ??
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Caligraphic-Bold.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Caligraphic-Bold.js
new file mode 100644
index 0000000..8de81a8
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Caligraphic-Bold.js
@@ -0,0 +1,101 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/Caligraphic-Bold.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_Caligraphic-Bold';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 315, ascent: 840, descent: 211,
+ weight: 'bold',
+ skew: {
+ 0x41: 0.224,
+ 0x42: 0.16,
+ 0x43: 0.16,
+ 0x44: 0.0958,
+ 0x45: 0.128,
+ 0x46: 0.128,
+ 0x47: 0.128,
+ 0x48: 0.128,
+ 0x49: 0.0319,
+ 0x4A: 0.192,
+ 0x4B: 0.0639,
+ 0x4C: 0.16,
+ 0x4D: 0.16,
+ 0x4E: 0.0958,
+ 0x4F: 0.128,
+ 0x50: 0.0958,
+ 0x51: 0.128,
+ 0x52: 0.0958,
+ 0x53: 0.16,
+ 0x54: 0.0319,
+ 0x55: 0.0958,
+ 0x56: 0.0319,
+ 0x57: 0.0958,
+ 0x58: 0.16,
+ 0x59: 0.0958,
+ 0x5A: 0.16
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x30: [460,17,575,46,528], // DIGIT ZERO
+ 0x31: [461,0,575,80,494], // DIGIT ONE
+ 0x32: [460,0,575,51,517], // DIGIT TWO
+ 0x33: [461,211,575,48,525], // DIGIT THREE
+ 0x34: [469,194,575,32,542], // DIGIT FOUR
+ 0x35: [461,211,575,57,517], // DIGIT FIVE
+ 0x36: [660,17,575,48,526], // DIGIT SIX
+ 0x37: [476,211,575,64,558], // DIGIT SEVEN
+ 0x38: [661,17,575,48,526], // DIGIT EIGHT
+ 0x39: [461,210,575,48,526], // DIGIT NINE
+ 0x41: [751,49,921,39,989], // LATIN CAPITAL LETTER A
+ 0x42: [705,17,748,40,740], // LATIN CAPITAL LETTER B
+ 0x43: [703,20,613,20,599], // LATIN CAPITAL LETTER C
+ 0x44: [686,0,892,20,885], // LATIN CAPITAL LETTER D
+ 0x45: [703,16,607,37,627], // LATIN CAPITAL LETTER E
+ 0x46: [686,30,814,17,930], // LATIN CAPITAL LETTER F
+ 0x47: [703,113,682,50,671], // LATIN CAPITAL LETTER G
+ 0x48: [686,48,987,20,946], // LATIN CAPITAL LETTER H
+ 0x49: [686,0,642,-27,746], // LATIN CAPITAL LETTER I
+ 0x4A: [686,114,779,53,937], // LATIN CAPITAL LETTER J
+ 0x4B: [703,17,871,40,834], // LATIN CAPITAL LETTER K
+ 0x4C: [703,17,788,41,751], // LATIN CAPITAL LETTER L
+ 0x4D: [703,49,1378,38,1353], // LATIN CAPITAL LETTER M
+ 0x4E: [840,49,937,-24,1105], // LATIN CAPITAL LETTER N
+ 0x4F: [703,17,906,63,882], // LATIN CAPITAL LETTER O
+ 0x50: [686,67,810,20,846], // LATIN CAPITAL LETTER P
+ 0x51: [703,146,939,120,905], // LATIN CAPITAL LETTER Q
+ 0x52: [686,17,990,20,981], // LATIN CAPITAL LETTER R
+ 0x53: [703,16,696,25,721], // LATIN CAPITAL LETTER S
+ 0x54: [720,69,644,38,947], // LATIN CAPITAL LETTER T
+ 0x55: [686,24,715,-10,771], // LATIN CAPITAL LETTER U
+ 0x56: [686,77,737,25,774], // LATIN CAPITAL LETTER V
+ 0x57: [686,77,1169,25,1206], // LATIN CAPITAL LETTER W
+ 0x58: [686,-1,817,56,906], // LATIN CAPITAL LETTER X
+ 0x59: [686,164,759,36,797], // LATIN CAPITAL LETTER Y
+ 0x5A: [686,0,818,46,853], // LATIN CAPITAL LETTER Z
+ 0xA0: [0,0,250,0,0] // NO-BREAK SPACE
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Bold.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Bold.js
new file mode 100644
index 0000000..2715d24
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Bold.js
@@ -0,0 +1,127 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_Fraktur-Bold';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 259, ascent: 740, descent: 223,
+ weight: 'bold',
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [689,12,349,107,241], // EXCLAMATION MARK
+ 0x22: [695,-432,254,10,231], // QUOTATION MARK
+ 0x26: [696,16,871,44,839], // AMPERSAND
+ 0x27: [695,-436,250,80,158], // APOSTROPHE
+ 0x28: [737,186,459,134,347], // LEFT PARENTHESIS
+ 0x29: [735,187,459,105,326], // RIGHT PARENTHESIS
+ 0x2A: [692,-449,328,40,277], // ASTERISK
+ 0x2B: [598,82,893,56,837], // PLUS SIGN
+ 0x2C: [107,191,328,118,253], // COMMA
+ 0x2D: [275,-236,893,54,833], // HYPHEN-MINUS
+ 0x2E: [102,15,328,103,237], // FULL STOP
+ 0x2F: [721,182,593,41,550], // SOLIDUS
+ 0x30: [501,12,593,42,533], // DIGIT ZERO
+ 0x31: [489,0,593,54,548], // DIGIT ONE
+ 0x32: [491,-2,593,44,563], // DIGIT TWO
+ 0x33: [487,193,593,31,523], // DIGIT THREE
+ 0x34: [495,196,593,13,565], // DIGIT FOUR
+ 0x35: [481,190,593,19,518], // DIGIT FIVE
+ 0x36: [704,12,593,48,547], // DIGIT SIX
+ 0x37: [479,197,593,54,591], // DIGIT SEVEN
+ 0x38: [714,5,593,45,542], // DIGIT EIGHT
+ 0x39: [487,195,593,29,549], // DIGIT NINE
+ 0x3A: [457,12,255,57,197], // COLON
+ 0x3B: [458,190,255,56,211], // SEMICOLON
+ 0x3D: [343,-168,582,22,559], // EQUALS SIGN
+ 0x3F: [697,14,428,40,422], // QUESTION MARK
+ 0x41: [686,31,847,29,827], // LATIN CAPITAL LETTER A
+ 0x42: [684,31,1044,57,965], // LATIN CAPITAL LETTER B
+ 0x43: [676,32,723,72,726], // LATIN CAPITAL LETTER C
+ 0x44: [683,29,982,31,896], // LATIN CAPITAL LETTER D
+ 0x45: [686,29,783,74,728], // LATIN CAPITAL LETTER E
+ 0x46: [684,146,722,17,727], // LATIN CAPITAL LETTER F
+ 0x47: [687,29,927,74,844], // LATIN CAPITAL LETTER G
+ 0x48: [683,126,851,6,752], // LATIN CAPITAL LETTER H
+ 0x49: [681,25,655,32,623], // LATIN CAPITAL LETTER I
+ 0x4A: [680,141,652,-8,616], // LATIN CAPITAL LETTER J
+ 0x4B: [681,26,789,20,806], // LATIN CAPITAL LETTER K
+ 0x4C: [683,28,786,30,764], // LATIN CAPITAL LETTER L
+ 0x4D: [683,32,1239,27,1232], // LATIN CAPITAL LETTER M
+ 0x4E: [679,30,983,26,973], // LATIN CAPITAL LETTER N
+ 0x4F: [726,30,976,12,881], // LATIN CAPITAL LETTER O
+ 0x50: [688,223,977,33,943], // LATIN CAPITAL LETTER P
+ 0x51: [726,83,976,12,918], // LATIN CAPITAL LETTER Q
+ 0x52: [688,28,978,31,978], // LATIN CAPITAL LETTER R
+ 0x53: [685,31,978,82,905], // LATIN CAPITAL LETTER S
+ 0x54: [686,30,790,31,802], // LATIN CAPITAL LETTER T
+ 0x55: [688,39,851,18,871], // LATIN CAPITAL LETTER U
+ 0x56: [685,29,982,25,966], // LATIN CAPITAL LETTER V
+ 0x57: [683,30,1235,26,1240], // LATIN CAPITAL LETTER W
+ 0x58: [681,35,849,32,835], // LATIN CAPITAL LETTER X
+ 0x59: [688,214,984,34,878], // LATIN CAPITAL LETTER Y
+ 0x5A: [677,148,711,-4,624], // LATIN CAPITAL LETTER Z
+ 0x5B: [740,130,257,36,226], // LEFT SQUARE BRACKET
+ 0x5D: [738,132,257,14,208], // RIGHT SQUARE BRACKET
+ 0x5E: [734,-452,590,1,584], // CIRCUMFLEX ACCENT
+ 0x61: [472,32,603,80,586], // LATIN SMALL LETTER A
+ 0x62: [690,32,590,86,504], // LATIN SMALL LETTER B
+ 0x63: [473,26,464,87,424], // LATIN SMALL LETTER C
+ 0x64: [632,28,589,-1,511], // LATIN SMALL LETTER D
+ 0x65: [471,27,472,81,428], // LATIN SMALL LETTER E
+ 0x66: [687,222,388,35,372], // LATIN SMALL LETTER F
+ 0x67: [472,208,595,17,541], // LATIN SMALL LETTER G
+ 0x68: [687,207,615,89,507], // LATIN SMALL LETTER H
+ 0x69: [686,25,331,3,327], // LATIN SMALL LETTER I
+ 0x6A: [682,203,332,-19,238], // LATIN SMALL LETTER J
+ 0x6B: [682,25,464,34,432], // LATIN SMALL LETTER K
+ 0x6C: [681,24,337,100,312], // LATIN SMALL LETTER L
+ 0x6D: [476,31,921,16,900], // LATIN SMALL LETTER M
+ 0x6E: [473,28,654,5,608], // LATIN SMALL LETTER N
+ 0x6F: [482,34,609,107,515], // LATIN SMALL LETTER O
+ 0x70: [557,207,604,-1,519], // LATIN SMALL LETTER P
+ 0x71: [485,211,596,87,515], // LATIN SMALL LETTER Q
+ 0x72: [472,26,460,13,453], // LATIN SMALL LETTER R
+ 0x73: [479,34,523,-23,481], // LATIN SMALL LETTER S
+ 0x74: [648,27,393,43,407], // LATIN SMALL LETTER T
+ 0x75: [472,32,589,9,603], // LATIN SMALL LETTER U
+ 0x76: [546,27,604,56,507], // LATIN SMALL LETTER V
+ 0x77: [549,32,918,55,815], // LATIN SMALL LETTER W
+ 0x78: [471,188,459,8,441], // LATIN SMALL LETTER X
+ 0x79: [557,221,589,60,512], // LATIN SMALL LETTER Y
+ 0x7A: [471,214,461,-7,378], // LATIN SMALL LETTER Z
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x2018: [708,-411,254,53,187], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [692,-394,254,58,193], // RIGHT SINGLE QUOTATION MARK
+ 0xE301: [630,27,587,64,512], // stix-MATHEMATICAL BOLD CAPITAL GAMMA SLASHED
+ 0xE302: [693,212,394,37,408], // stix-capital Delta, Greek slashed
+ 0xE303: [681,219,387,36,384], // stix-MATHEMATICAL BOLD CAPITAL DELTA SLASHED
+ 0xE304: [473,212,593,67,531], // stix-capital Epsilon, Greek slashed
+ 0xE305: [684,27,393,33,387], // stix-MATHEMATICAL BOLD CAPITAL EPSILON SLASHED
+ 0xE308: [679,220,981,32,875], // stix-capital Eta, Greek slashed
+ 0xE309: [717,137,727,17,633] // stix-MATHEMATICAL BOLD CAPITAL ETA SLASHED
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js
new file mode 100644
index 0000000..1c9a35c
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js
@@ -0,0 +1,127 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_Fraktur';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 258, ascent: 740, descent: 224,
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [689,12,296,91,204], // EXCLAMATION MARK
+ 0x22: [695,-432,215,8,196], // QUOTATION MARK
+ 0x26: [698,11,738,49,733], // AMPERSAND
+ 0x27: [695,-436,212,69,134], // APOSTROPHE
+ 0x28: [737,186,389,114,293], // LEFT PARENTHESIS
+ 0x29: [735,187,389,89,276], // RIGHT PARENTHESIS
+ 0x2A: [692,-449,278,33,234], // ASTERISK
+ 0x2B: [598,82,756,47,709], // PLUS SIGN
+ 0x2C: [107,191,278,99,213], // COMMA
+ 0x2D: [275,-236,756,46,706], // HYPHEN-MINUS
+ 0x2E: [102,15,278,87,200], // FULL STOP
+ 0x2F: [721,182,502,34,466], // SOLIDUS
+ 0x30: [492,13,502,42,456], // DIGIT ZERO
+ 0x31: [468,2,502,47,460], // DIGIT ONE
+ 0x32: [474,-1,502,60,484], // DIGIT TWO
+ 0x33: [473,182,502,39,429], // DIGIT THREE
+ 0x34: [476,191,502,10,481], // DIGIT FOUR
+ 0x35: [458,184,502,47,440], // DIGIT FIVE
+ 0x36: [700,13,502,45,471], // DIGIT SIX
+ 0x37: [468,181,502,37,498], // DIGIT SEVEN
+ 0x38: [705,10,502,40,461], // DIGIT EIGHT
+ 0x39: [469,182,502,28,466], // DIGIT NINE
+ 0x3A: [457,12,216,50,168], // COLON
+ 0x3B: [458,189,216,47,179], // SEMICOLON
+ 0x3D: [368,-132,756,54,725], // EQUALS SIGN
+ 0x3F: [693,11,362,46,357], // QUESTION MARK
+ 0x41: [696,26,718,22,708], // LATIN CAPITAL LETTER A
+ 0x42: [691,27,884,48,820], // LATIN CAPITAL LETTER B
+ 0x43: [685,24,613,59,607], // LATIN CAPITAL LETTER C
+ 0x44: [685,27,832,27,745], // LATIN CAPITAL LETTER D
+ 0x45: [685,24,663,86,634], // LATIN CAPITAL LETTER E
+ 0x46: [686,153,611,11,612], // LATIN CAPITAL LETTER F
+ 0x47: [690,26,785,66,710], // LATIN CAPITAL LETTER G
+ 0x48: [666,133,720,1,644], // LATIN CAPITAL LETTER H
+ 0x49: [686,26,554,30,532], // LATIN CAPITAL LETTER I
+ 0x4A: [686,139,552,-10,522], // LATIN CAPITAL LETTER J
+ 0x4B: [680,27,668,17,682], // LATIN CAPITAL LETTER K
+ 0x4C: [686,26,666,33,644], // LATIN CAPITAL LETTER L
+ 0x4D: [692,27,1050,27,1048], // LATIN CAPITAL LETTER M
+ 0x4E: [686,25,832,27,825], // LATIN CAPITAL LETTER N
+ 0x4F: [729,27,827,12,744], // LATIN CAPITAL LETTER O
+ 0x50: [692,218,828,28,804], // LATIN CAPITAL LETTER P
+ 0x51: [729,69,827,11,782], // LATIN CAPITAL LETTER Q
+ 0x52: [686,26,828,27,824], // LATIN CAPITAL LETTER R
+ 0x53: [692,27,829,66,756], // LATIN CAPITAL LETTER S
+ 0x54: [701,27,669,34,676], // LATIN CAPITAL LETTER T
+ 0x55: [697,27,646,-25,665], // LATIN CAPITAL LETTER U
+ 0x56: [686,26,831,26,825], // LATIN CAPITAL LETTER V
+ 0x57: [686,27,1046,32,1054], // LATIN CAPITAL LETTER W
+ 0x58: [688,27,719,28,709], // LATIN CAPITAL LETTER X
+ 0x59: [686,218,833,27,740], // LATIN CAPITAL LETTER Y
+ 0x5A: [729,139,602,11,532], // LATIN CAPITAL LETTER Z
+ 0x5B: [740,130,278,117,278], // LEFT SQUARE BRACKET
+ 0x5D: [738,131,278,-4,160], // RIGHT SQUARE BRACKET
+ 0x5E: [734,-452,500,0,495], // CIRCUMFLEX ACCENT
+ 0x61: [470,35,500,66,497], // LATIN SMALL LETTER A
+ 0x62: [685,31,513,87,442], // LATIN SMALL LETTER B
+ 0x63: [466,29,389,72,359], // LATIN SMALL LETTER C
+ 0x64: [609,33,499,13,428], // LATIN SMALL LETTER D
+ 0x65: [467,30,401,70,364], // LATIN SMALL LETTER E
+ 0x66: [681,221,326,30,323], // LATIN SMALL LETTER F
+ 0x67: [470,209,504,17,455], // LATIN SMALL LETTER G
+ 0x68: [688,205,521,77,434], // LATIN SMALL LETTER H
+ 0x69: [673,20,279,14,267], // LATIN SMALL LETTER I
+ 0x6A: [672,208,281,-9,196], // LATIN SMALL LETTER J
+ 0x6B: [689,25,389,24,362], // LATIN SMALL LETTER K
+ 0x6C: [685,20,280,98,276], // LATIN SMALL LETTER L
+ 0x6D: [475,26,767,8,753], // LATIN SMALL LETTER M
+ 0x6E: [475,22,527,20,514], // LATIN SMALL LETTER N
+ 0x6F: [480,28,489,67,412], // LATIN SMALL LETTER O
+ 0x70: [541,212,500,12,430], // LATIN SMALL LETTER P
+ 0x71: [479,219,489,60,419], // LATIN SMALL LETTER Q
+ 0x72: [474,21,389,17,387], // LATIN SMALL LETTER R
+ 0x73: [478,29,443,-18,406], // LATIN SMALL LETTER S
+ 0x74: [640,20,333,27,348], // LATIN SMALL LETTER T
+ 0x75: [474,23,517,9,513], // LATIN SMALL LETTER U
+ 0x76: [530,28,512,55,434], // LATIN SMALL LETTER V
+ 0x77: [532,28,774,45,688], // LATIN SMALL LETTER W
+ 0x78: [472,188,389,10,363], // LATIN SMALL LETTER X
+ 0x79: [528,218,499,45,431], // LATIN SMALL LETTER Y
+ 0x7A: [471,214,391,-7,314], // LATIN SMALL LETTER Z
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x2018: [708,-410,215,45,158], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [692,-395,215,49,163], // RIGHT SINGLE QUOTATION MARK
+ 0xE300: [683,32,497,75,430], // stix-capital Gamma, Greek slashed
+ 0xE301: [616,30,498,35,432], // stix-MATHEMATICAL BOLD CAPITAL GAMMA SLASHED
+ 0xE302: [680,215,333,29,339], // stix-capital Delta, Greek slashed
+ 0xE303: [679,224,329,28,318], // stix-MATHEMATICAL BOLD CAPITAL DELTA SLASHED
+ 0xE304: [471,214,503,52,449], // stix-capital Epsilon, Greek slashed
+ 0xE305: [686,20,333,26,315], // stix-MATHEMATICAL BOLD CAPITAL EPSILON SLASHED
+ 0xE306: [577,21,334,29,347], // stix-capital Zeta, Greek slashed
+ 0xE307: [475,22,501,10,514] // stix-MATHEMATICAL BOLD CAPITAL ZETA SLASHED
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Main-Bold.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Main-Bold.js
new file mode 100644
index 0000000..1dd2251
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Main-Bold.js
@@ -0,0 +1,210 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/Main-Bold.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+(function (CHTML) {
+
+var font = 'MathJax_Main-Bold';
+
+MathJax.Hub.Insert(CHTML.FONTDATA.FONTS[font],{
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0xA8: [695,-535,575,96,478], // DIAERESIS
+ 0xAC: [371,-61,767,64,702], // NOT SIGN
+ 0xAF: [607,-540,575,80,494], // MACRON
+ 0xB0: [702,-536,575,160,414], // DEGREE SIGN
+ 0xB1: [728,35,894,64,829], // PLUS-MINUS SIGN
+ 0xB4: [706,-503,575,236,460], // ACUTE ACCENT
+ 0xD7: [530,28,894,168,726], // MULTIPLICATION SIGN
+ 0xF7: [597,96,894,64,828], // DIVISION SIGN
+ 0x131: [452,8,394,24,367], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [451,201,439,-12,420], // LATIN SMALL LETTER DOTLESS J
+ 0x2C6: [694,-520,575,126,448], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2C7: [660,-515,575,130,444], // CARON
+ 0x2C9: [607,-540,575,80,494], // MODIFIER LETTER MACRON
+ 0x2CA: [706,-503,575,236,460], // MODIFIER LETTER ACUTE ACCENT
+ 0x2CB: [706,-503,575,114,338], // MODIFIER LETTER GRAVE ACCENT
+ 0x2D8: [694,-500,575,102,472], // BREVE
+ 0x2D9: [695,-525,575,202,372], // DOT ABOVE
+ 0x2DA: [702,-536,575,160,414], // RING ABOVE
+ 0x2DC: [694,-552,575,96,478], // SMALL TILDE
+ 0x300: [706,-503,0,-461,-237], // COMBINING GRAVE ACCENT
+ 0x301: [706,-503,0,-339,-115], // COMBINING ACUTE ACCENT
+ 0x302: [694,-520,0,-449,-127], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [694,-552,0,-479,-97], // COMBINING TILDE
+ 0x304: [607,-540,0,-495,-81], // COMBINING MACRON
+ 0x306: [694,-500,0,-473,-103], // COMBINING BREVE
+ 0x307: [695,-525,0,-373,-203], // COMBINING DOT ABOVE
+ 0x308: [695,-535,0,-479,-97], // COMBINING DIAERESIS
+ 0x30A: [702,-536,0,-415,-161], // COMBINING RING ABOVE
+ 0x30B: [714,-511,0,-442,-82], // COMBINING DOUBLE ACUTE ACCENT
+ 0x30C: [660,-515,0,-445,-131], // COMBINING CARON
+ 0x338: [711,210,0,-734,-161], // COMBINING LONG SOLIDUS OVERLAY
+ 0x2002: [0,0,500,0,0], // ??
+ 0x2003: [0,0,999,0,0], // ??
+ 0x2004: [0,0,333,0,0], // ??
+ 0x2005: [0,0,250,0,0], // ??
+ 0x2006: [0,0,167,0,0], // ??
+ 0x2009: [0,0,167,0,0], // ??
+ 0x200A: [0,0,83,0,0], // ??
+ 0x2013: [300,-249,575,0,574], // EN DASH
+ 0x2014: [300,-249,1150,0,1149], // EM DASH
+ 0x2018: [694,-329,319,58,245], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [694,-329,319,74,261], // RIGHT SINGLE QUOTATION MARK
+ 0x201C: [694,-329,603,110,564], // LEFT DOUBLE QUOTATION MARK
+ 0x201D: [694,-329,603,38,492], // RIGHT DOUBLE QUOTATION MARK
+ 0x2020: [702,211,511,64,446], // DAGGER
+ 0x2021: [702,202,511,64,446], // DOUBLE DAGGER
+ 0x2026: [171,-1,1295,74,1221], // HORIZONTAL ELLIPSIS
+ 0x2032: [563,-33,344,35,331], // PRIME
+ 0x20D7: [723,-513,0,-542,-33], // COMBINING RIGHT ARROW ABOVE
+ 0x210F: [694,8,668,45,642], // stix-/hbar - Planck's over 2pi
+ 0x2111: [702,8,831,64,798], // BLACK-LETTER CAPITAL I
+ 0x2113: [702,19,474,-1,446], // SCRIPT SMALL L
+ 0x2118: [461,210,740,72,726], // SCRIPT CAPITAL P
+ 0x211C: [711,16,831,42,824], // BLACK-LETTER CAPITAL R
+ 0x2135: [694,0,703,64,638], // ALEF SYMBOL
+ 0x2190: [518,17,1150,64,1084], // LEFTWARDS ARROW
+ 0x2191: [694,193,575,14,561], // UPWARDS ARROW
+ 0x2192: [518,17,1150,65,1085], // RIGHTWARDS ARROW
+ 0x2193: [694,194,575,14,561], // DOWNWARDS ARROW
+ 0x2194: [518,17,1150,64,1085], // LEFT RIGHT ARROW
+ 0x2195: [767,267,575,14,561], // UP DOWN ARROW
+ 0x2196: [724,194,1150,64,1084], // NORTH WEST ARROW
+ 0x2197: [724,193,1150,64,1085], // NORTH EAST ARROW
+ 0x2198: [694,224,1150,65,1085], // SOUTH EAST ARROW
+ 0x2199: [694,224,1150,64,1085], // SOUTH WEST ARROW
+ 0x21A6: [518,17,1150,65,1085], // RIGHTWARDS ARROW FROM BAR
+ 0x21A9: [518,17,1282,64,1218], // LEFTWARDS ARROW WITH HOOK
+ 0x21AA: [518,17,1282,65,1217], // RIGHTWARDS ARROW WITH HOOK
+ 0x21BC: [518,-220,1150,64,1084], // LEFTWARDS HARPOON WITH BARB UPWARDS
+ 0x21BD: [281,17,1150,64,1084], // LEFTWARDS HARPOON WITH BARB DOWNWARDS
+ 0x21C0: [518,-220,1150,65,1085], // RIGHTWARDS HARPOON WITH BARB UPWARDS
+ 0x21C1: [281,17,1150,64,1085], // RIGHTWARDS HARPOON WITH BARB DOWNWARDS
+ 0x21CC: [718,17,1150,64,1085], // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+ 0x21D0: [547,46,1150,64,1085], // LEFTWARDS DOUBLE ARROW
+ 0x21D1: [694,193,703,30,672], // UPWARDS DOUBLE ARROW
+ 0x21D2: [547,46,1150,64,1084], // RIGHTWARDS DOUBLE ARROW
+ 0x21D3: [694,194,703,30,672], // DOWNWARDS DOUBLE ARROW
+ 0x21D4: [547,46,1150,47,1102], // LEFT RIGHT DOUBLE ARROW
+ 0x21D5: [767,267,703,30,672], // UP DOWN DOUBLE ARROW
+ 0x2200: [694,16,639,1,640], // FOR ALL
+ 0x2202: [710,17,628,60,657], // PARTIAL DIFFERENTIAL
+ 0x2203: [694,-1,639,64,574], // THERE EXISTS
+ 0x2205: [767,73,575,46,528], // EMPTY SET
+ 0x2207: [686,24,958,56,901], // NABLA
+ 0x2208: [587,86,767,97,670], // ELEMENT OF
+ 0x2209: [711,210,767,97,670], // stix-negated (vert) set membership, variant
+ 0x220B: [587,86,767,96,670], // CONTAINS AS MEMBER
+ 0x2212: [281,-221,894,96,797], // MINUS SIGN
+ 0x2213: [537,227,894,64,829], // MINUS-OR-PLUS SIGN
+ 0x2215: [750,250,575,63,511], // DIVISION SLASH
+ 0x2216: [750,250,575,63,511], // SET MINUS
+ 0x2217: [472,-28,575,73,501], // ASTERISK OPERATOR
+ 0x2218: [474,-28,575,64,510], // RING OPERATOR
+ 0x2219: [474,-28,575,64,510], // BULLET OPERATOR
+ 0x221A: [820,180,958,78,988], // SQUARE ROOT
+ 0x221D: [451,8,894,65,830], // PROPORTIONAL TO
+ 0x221E: [452,8,1150,65,1084], // INFINITY
+ 0x2220: [714,0,722,55,676], // ANGLE
+ 0x2223: [750,249,319,129,190], // DIVIDES
+ 0x2225: [750,248,575,145,430], // PARALLEL TO
+ 0x2227: [604,17,767,64,702], // LOGICAL AND
+ 0x2228: [604,16,767,64,702], // LOGICAL OR
+ 0x2229: [603,16,767,64,702], // stix-intersection, serifs
+ 0x222A: [604,16,767,64,702], // stix-union, serifs
+ 0x222B: [711,211,569,64,632], // INTEGRAL
+ 0x223C: [391,-109,894,64,828], // TILDE OPERATOR
+ 0x2240: [583,82,319,64,254], // WREATH PRODUCT
+ 0x2243: [502,3,894,64,829], // ASYMPTOTICALLY EQUAL TO
+ 0x2245: [638,27,1000,64,829], // APPROXIMATELY EQUAL TO
+ 0x2248: [524,-32,894,64,829], // ALMOST EQUAL TO
+ 0x224D: [533,32,894,64,829], // EQUIVALENT TO
+ 0x2250: [721,-109,894,64,829], // APPROACHES THE LIMIT
+ 0x2260: [711,210,894,64,829], // stix-not (vert) equals
+ 0x2261: [505,3,894,64,829], // IDENTICAL TO
+ 0x2264: [697,199,894,96,797], // LESS-THAN OR EQUAL TO
+ 0x2265: [697,199,894,96,797], // GREATER-THAN OR EQUAL TO
+ 0x226A: [617,116,1150,64,1085], // MUCH LESS-THAN
+ 0x226B: [618,116,1150,64,1085], // MUCH GREATER-THAN
+ 0x227A: [585,86,894,96,797], // PRECEDES
+ 0x227B: [586,86,894,96,797], // SUCCEEDS
+ 0x2282: [587,85,894,96,797], // SUBSET OF
+ 0x2283: [587,86,894,96,796], // SUPERSET OF
+ 0x2286: [697,199,894,96,797], // SUBSET OF OR EQUAL TO
+ 0x2287: [697,199,894,96,796], // SUPERSET OF OR EQUAL TO
+ 0x228E: [604,16,767,64,702], // MULTISET UNION
+ 0x2291: [697,199,894,96,828], // SQUARE IMAGE OF OR EQUAL TO
+ 0x2292: [697,199,894,66,797], // SQUARE ORIGINAL OF OR EQUAL TO
+ 0x2293: [604,-1,767,70,696], // stix-square intersection, serifs
+ 0x2294: [604,-1,767,70,696], // stix-square union, serifs
+ 0x2295: [632,132,894,64,828], // stix-circled plus (with rim)
+ 0x2296: [632,132,894,64,828], // CIRCLED MINUS
+ 0x2297: [632,132,894,64,828], // stix-circled times (with rim)
+ 0x2298: [632,132,894,64,828], // CIRCLED DIVISION SLASH
+ 0x2299: [632,132,894,64,828], // CIRCLED DOT OPERATOR
+ 0x22A2: [693,-1,703,65,637], // RIGHT TACK
+ 0x22A3: [693,-1,703,64,638], // LEFT TACK
+ 0x22A4: [694,-1,894,64,829], // DOWN TACK
+ 0x22A5: [693,-1,894,65,829], // UP TACK
+ 0x22A8: [750,249,974,129,918], // TRUE
+ 0x22C4: [523,21,575,15,560], // DIAMOND OPERATOR
+ 0x22C5: [336,-166,319,74,245], // DOT OPERATOR
+ 0x22C6: [502,0,575,24,550], // STAR OPERATOR
+ 0x22C8: [540,39,1000,33,967], // BOWTIE
+ 0x22EE: [951,29,319,74,245], // VERTICAL ELLIPSIS
+ 0x22EF: [336,-166,1295,74,1221], // MIDLINE HORIZONTAL ELLIPSIS
+ 0x22F1: [871,-101,1323,129,1194], // DOWN RIGHT DIAGONAL ELLIPSIS
+ 0x2308: [750,248,511,194,493], // LEFT CEILING
+ 0x2309: [750,248,511,17,317], // RIGHT CEILING
+ 0x230A: [749,248,511,194,493], // LEFT FLOOR
+ 0x230B: [749,248,511,17,317], // RIGHT FLOOR
+ 0x2322: [405,-108,1150,65,1084], // stix-small down curve
+ 0x2323: [392,-126,1150,64,1085], // stix-small up curve
+ 0x25B3: [711,-1,1022,69,953], // WHITE UP-POINTING TRIANGLE
+ 0x25B9: [540,39,575,33,542], // WHITE RIGHT-POINTING SMALL TRIANGLE
+ 0x25BD: [500,210,1022,68,953], // WHITE DOWN-POINTING TRIANGLE
+ 0x25C3: [539,38,575,33,542], // WHITE LEFT-POINTING SMALL TRIANGLE
+ 0x25EF: [711,211,1150,65,1084], // LARGE CIRCLE
+ 0x2660: [719,129,894,64,829], // BLACK SPADE SUIT
+ 0x2661: [711,24,894,65,828], // WHITE HEART SUIT
+ 0x2662: [719,154,894,64,828], // WHITE DIAMOND SUIT
+ 0x2663: [719,129,894,32,861], // BLACK CLUB SUIT
+ 0x266D: [750,17,447,64,381], // MUSIC FLAT SIGN
+ 0x266E: [741,223,447,57,389], // MUSIC NATURAL SIGN
+ 0x266F: [724,224,447,63,382], // MUSIC SHARP SIGN
+ 0x27E8: [750,249,447,127,382], // MATHEMATICAL LEFT ANGLE BRACKET
+ 0x27E9: [750,249,447,64,319], // MATHEMATICAL RIGHT ANGLE BRACKET
+ 0x27F5: [518,17,1805,64,1741], // LONG LEFTWARDS ARROW
+ 0x27F6: [518,17,1833,96,1773], // LONG RIGHTWARDS ARROW
+ 0x27F7: [518,17,2126,64,2061], // LONG LEFT RIGHT ARROW
+ 0x27F8: [547,46,1868,64,1804], // LONG LEFTWARDS DOUBLE ARROW
+ 0x27F9: [547,46,1870,64,1804], // LONG RIGHTWARDS DOUBLE ARROW
+ 0x27FA: [547,46,2126,64,2060], // LONG LEFT RIGHT DOUBLE ARROW
+ 0x27FC: [518,17,1833,65,1773], // LONG RIGHTWARDS ARROW FROM BAR
+ 0x2A3F: [686,0,900,39,860], // AMALGAMATION OR COPRODUCT
+ 0x2AAF: [696,199,894,96,797], // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN
+ 0x2AB0: [697,199,894,96,797] // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN
+});
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Math-BoldItalic.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Math-BoldItalic.js
new file mode 100644
index 0000000..b6c46d3
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Math-BoldItalic.js
@@ -0,0 +1,210 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/fonts/TeX/Math/BoldItalic/Main.js
+ *
+ * Copyright (c) 2009-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_Math-BoldItalic';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 255, ascent: 725, descent: 216,
+ weight: 'bold',
+ style: 'italic',
+ skew: {
+ 0x41: 0.16,
+ 0x42: 0.0958,
+ 0x43: 0.0958,
+ 0x44: 0.0639,
+ 0x45: 0.0958,
+ 0x46: 0.0958,
+ 0x47: 0.0958,
+ 0x48: 0.0639,
+ 0x49: 0.128,
+ 0x4A: 0.192,
+ 0x4B: 0.0639,
+ 0x4C: 0.0319,
+ 0x4D: 0.0958,
+ 0x4E: 0.0958,
+ 0x4F: 0.0958,
+ 0x50: 0.0958,
+ 0x51: 0.0958,
+ 0x52: 0.0958,
+ 0x53: 0.0958,
+ 0x54: 0.0958,
+ 0x55: 0.0319,
+ 0x58: 0.0958,
+ 0x5A: 0.0958,
+ 0x63: 0.0639,
+ 0x64: 0.192,
+ 0x65: 0.0639,
+ 0x66: 0.192,
+ 0x67: 0.0319,
+ 0x68: -0.0319,
+ 0x6C: 0.0958,
+ 0x6F: 0.0639,
+ 0x70: 0.0958,
+ 0x71: 0.0958,
+ 0x72: 0.0639,
+ 0x73: 0.0639,
+ 0x74: 0.0958,
+ 0x75: 0.0319,
+ 0x76: 0.0319,
+ 0x77: 0.0958,
+ 0x78: 0.0319,
+ 0x79: 0.0639,
+ 0x7A: 0.0639,
+ 0x393: 0.0958,
+ 0x394: 0.192,
+ 0x398: 0.0958,
+ 0x39B: 0.192,
+ 0x39E: 0.0958,
+ 0x3A0: 0.0639,
+ 0x3A3: 0.0958,
+ 0x3A5: 0.0639,
+ 0x3A6: 0.0958,
+ 0x3A8: 0.0639,
+ 0x3A9: 0.0958,
+ 0x3B1: 0.0319,
+ 0x3B2: 0.0958,
+ 0x3B4: 0.0639,
+ 0x3B5: 0.0958,
+ 0x3B6: 0.0958,
+ 0x3B7: 0.0639,
+ 0x3B8: 0.0958,
+ 0x3B9: 0.0639,
+ 0x3BC: 0.0319,
+ 0x3BD: 0.0319,
+ 0x3BE: 0.128,
+ 0x3BF: 0.0639,
+ 0x3C1: 0.0958,
+ 0x3C2: 0.0958,
+ 0x3C4: 0.0319,
+ 0x3C5: 0.0319,
+ 0x3C6: 0.0958,
+ 0x3C7: 0.0639,
+ 0x3C8: 0.128,
+ 0x3D1: 0.0958,
+ 0x3D5: 0.0958,
+ 0x3F1: 0.0958,
+ 0x3F5: 0.0639
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x2F: [711,210,894,160,733], // SOLIDUS
+ 0x41: [711,0,869,45,839], // LATIN CAPITAL LETTER A
+ 0x42: [686,0,866,43,853], // LATIN CAPITAL LETTER B
+ 0x43: [703,17,817,55,855], // LATIN CAPITAL LETTER C
+ 0x44: [686,0,938,43,914], // LATIN CAPITAL LETTER D
+ 0x45: [680,0,810,43,825], // LATIN CAPITAL LETTER E
+ 0x46: [680,0,689,43,809], // LATIN CAPITAL LETTER F
+ 0x47: [703,16,887,56,854], // LATIN CAPITAL LETTER G
+ 0x48: [686,0,982,43,1027], // LATIN CAPITAL LETTER H
+ 0x49: [686,0,511,30,573], // LATIN CAPITAL LETTER I
+ 0x4A: [686,17,631,42,694], // LATIN CAPITAL LETTER J
+ 0x4B: [686,0,971,43,1003], // LATIN CAPITAL LETTER K
+ 0x4C: [686,0,756,43,711], // LATIN CAPITAL LETTER L
+ 0x4D: [686,0,1142,43,1219], // LATIN CAPITAL LETTER M
+ 0x4E: [686,0,950,43,1027], // LATIN CAPITAL LETTER N
+ 0x4F: [703,17,837,53,815], // LATIN CAPITAL LETTER O
+ 0x50: [686,0,723,43,847], // LATIN CAPITAL LETTER P
+ 0x51: [703,194,869,53,815], // LATIN CAPITAL LETTER Q
+ 0x52: [686,17,872,43,881], // LATIN CAPITAL LETTER R
+ 0x53: [703,17,693,63,714], // LATIN CAPITAL LETTER S
+ 0x54: [675,0,637,22,772], // LATIN CAPITAL LETTER T
+ 0x55: [686,16,800,63,877], // LATIN CAPITAL LETTER U
+ 0x56: [686,16,678,62,886], // LATIN CAPITAL LETTER V
+ 0x57: [686,17,1093,61,1207], // LATIN CAPITAL LETTER W
+ 0x58: [686,0,947,38,953], // LATIN CAPITAL LETTER X
+ 0x59: [686,0,675,40,876], // LATIN CAPITAL LETTER Y
+ 0x5A: [686,0,773,68,805], // LATIN CAPITAL LETTER Z
+ 0x61: [452,8,633,38,607], // LATIN SMALL LETTER A
+ 0x62: [694,8,521,45,513], // LATIN SMALL LETTER B
+ 0x63: [451,8,513,40,509], // LATIN SMALL LETTER C
+ 0x64: [694,8,610,38,612], // LATIN SMALL LETTER D
+ 0x65: [452,8,554,42,509], // LATIN SMALL LETTER E
+ 0x66: [701,201,568,64,624], // LATIN SMALL LETTER F
+ 0x67: [452,202,545,0,540], // LATIN SMALL LETTER G
+ 0x68: [694,8,668,45,642], // LATIN SMALL LETTER H
+ 0x69: [694,8,405,24,367], // LATIN SMALL LETTER I
+ 0x6A: [694,202,471,-12,456], // LATIN SMALL LETTER J
+ 0x6B: [694,8,604,45,578], // LATIN SMALL LETTER K
+ 0x6C: [694,8,348,27,296], // LATIN SMALL LETTER L
+ 0x6D: [452,8,1032,24,1006], // LATIN SMALL LETTER M
+ 0x6E: [452,8,713,24,687], // LATIN SMALL LETTER N
+ 0x6F: [452,8,585,39,576], // LATIN SMALL LETTER O
+ 0x70: [452,194,601,-23,593], // LATIN SMALL LETTER P
+ 0x71: [452,194,542,38,550], // LATIN SMALL LETTER Q
+ 0x72: [452,8,529,24,500], // LATIN SMALL LETTER R
+ 0x73: [451,8,531,57,476], // LATIN SMALL LETTER S
+ 0x74: [643,7,415,21,387], // LATIN SMALL LETTER T
+ 0x75: [452,8,681,24,655], // LATIN SMALL LETTER U
+ 0x76: [453,8,567,24,540], // LATIN SMALL LETTER V
+ 0x77: [453,8,831,24,796], // LATIN SMALL LETTER W
+ 0x78: [452,8,659,43,599], // LATIN SMALL LETTER X
+ 0x79: [452,202,590,24,587], // LATIN SMALL LETTER Y
+ 0x7A: [452,8,555,34,539], // LATIN SMALL LETTER Z
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x393: [680,0,657,43,777], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [711,0,958,59,904], // GREEK CAPITAL LETTER DELTA
+ 0x398: [702,17,867,54,844], // GREEK CAPITAL LETTER THETA
+ 0x39B: [711,0,806,44,776], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [675,0,841,62,867], // GREEK CAPITAL LETTER XI
+ 0x3A0: [680,0,982,43,1026], // GREEK CAPITAL LETTER PI
+ 0x3A3: [686,0,885,69,902], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [703,0,671,32,802], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [686,0,767,29,737], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [686,0,714,22,790], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [703,0,879,93,886], // GREEK CAPITAL LETTER OMEGA
+ 0x3B1: [452,8,761,39,712], // GREEK SMALL LETTER ALPHA
+ 0x3B2: [701,194,660,28,637], // GREEK SMALL LETTER BETA
+ 0x3B3: [451,211,590,5,617], // GREEK SMALL LETTER GAMMA
+ 0x3B4: [725,8,522,39,513], // GREEK SMALL LETTER DELTA
+ 0x3B5: [461,17,529,36,481], // GREEK SMALL LETTER EPSILON
+ 0x3B6: [711,202,508,48,521], // GREEK SMALL LETTER ZETA
+ 0x3B7: [452,211,600,24,600], // GREEK SMALL LETTER ETA
+ 0x3B8: [702,8,562,40,554], // GREEK SMALL LETTER THETA
+ 0x3B9: [452,8,412,38,386], // GREEK SMALL LETTER IOTA
+ 0x3BA: [452,8,668,45,642], // GREEK SMALL LETTER KAPPA
+ 0x3BB: [694,13,671,40,652], // GREEK SMALL LETTER LAMDA
+ 0x3BC: [452,211,708,33,682], // GREEK SMALL LETTER MU
+ 0x3BD: [452,2,577,38,608], // GREEK SMALL LETTER NU
+ 0x3BE: [711,201,508,23,490], // GREEK SMALL LETTER XI
+ 0x3BF: [452,8,585,39,576], // GREEK SMALL LETTER OMICRON
+ 0x3C0: [444,8,682,23,674], // GREEK SMALL LETTER PI
+ 0x3C1: [451,211,612,34,603], // GREEK SMALL LETTER RHO
+ 0x3C2: [451,105,424,33,457], // GREEK SMALL LETTER FINAL SIGMA
+ 0x3C3: [444,8,686,35,677], // GREEK SMALL LETTER SIGMA
+ 0x3C4: [444,13,521,23,610], // GREEK SMALL LETTER TAU
+ 0x3C5: [453,8,631,24,604], // GREEK SMALL LETTER UPSILON
+ 0x3C6: [452,216,747,53,703], // GREEK SMALL LETTER PHI
+ 0x3C7: [452,201,718,32,685], // GREEK SMALL LETTER CHI
+ 0x3C8: [694,202,758,24,732], // GREEK SMALL LETTER PSI
+ 0x3C9: [453,8,718,24,691], // GREEK SMALL LETTER OMEGA
+ 0x3D1: [701,8,692,24,656], // GREEK THETA SYMBOL
+ 0x3D5: [694,202,712,51,693], // GREEK PHI SYMBOL
+ 0x3D6: [444,8,975,23,961], // GREEK PI SYMBOL
+ 0x3F1: [451,194,612,75,603], // GREEK RHO SYMBOL
+ 0x3F5: [444,7,483,44,450] // GREEK LUNATE EPSILON SYMBOL
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Bold.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Bold.js
new file mode 100644
index 0000000..42553d0
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Bold.js
@@ -0,0 +1,154 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/SansSerif-Bold.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_SansSerif-Bold';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 250, ascent: 750, descent: 250,
+ weight: 'bold',
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [694,0,367,110,256], // EXCLAMATION MARK
+ 0x22: [694,-442,558,37,420], // QUOTATION MARK
+ 0x23: [694,193,917,61,855], // NUMBER SIGN
+ 0x24: [750,56,550,49,488], // DOLLAR SIGN
+ 0x25: [750,56,1029,61,966], // PERCENT SIGN
+ 0x26: [716,22,831,47,769], // AMPERSAND
+ 0x27: [694,-442,306,80,226], // APOSTROPHE
+ 0x28: [750,249,428,79,366], // LEFT PARENTHESIS
+ 0x29: [750,250,428,61,348], // RIGHT PARENTHESIS
+ 0x2A: [750,-293,550,67,482], // ASTERISK
+ 0x2B: [617,116,856,61,794], // PLUS SIGN
+ 0x2C: [146,106,306,80,226], // COMMA
+ 0x2D: [273,-186,367,12,305], // HYPHEN-MINUS
+ 0x2E: [146,0,306,80,226], // FULL STOP
+ 0x2F: [750,249,550,61,488], // SOLIDUS
+ 0x30: [715,22,550,43,506], // DIGIT ZERO
+ 0x31: [716,-1,550,76,473], // DIGIT ONE
+ 0x32: [716,0,550,46,495], // DIGIT TWO
+ 0x33: [716,22,550,46,503], // DIGIT THREE
+ 0x34: [694,0,550,31,518], // DIGIT FOUR
+ 0x35: [694,22,550,37,494], // DIGIT FIVE
+ 0x36: [716,22,550,46,503], // DIGIT SIX
+ 0x37: [695,11,550,46,503], // DIGIT SEVEN
+ 0x38: [715,22,550,46,503], // DIGIT EIGHT
+ 0x39: [716,22,550,46,503], // DIGIT NINE
+ 0x3A: [458,0,306,80,226], // COLON
+ 0x3B: [458,106,306,80,226], // SEMICOLON
+ 0x3D: [407,-94,856,61,794], // EQUALS SIGN
+ 0x3F: [705,0,519,61,457], // QUESTION MARK
+ 0x40: [704,11,733,61,671], // COMMERCIAL AT
+ 0x41: [694,0,733,42,690], // LATIN CAPITAL LETTER A
+ 0x42: [694,-1,733,92,671], // LATIN CAPITAL LETTER B
+ 0x43: [704,11,703,61,647], // LATIN CAPITAL LETTER C
+ 0x44: [694,-1,794,92,732], // LATIN CAPITAL LETTER D
+ 0x45: [691,0,642,92,595], // LATIN CAPITAL LETTER E
+ 0x46: [691,0,611,92,564], // LATIN CAPITAL LETTER F
+ 0x47: [705,11,733,61,659], // LATIN CAPITAL LETTER G
+ 0x48: [694,0,794,92,702], // LATIN CAPITAL LETTER H
+ 0x49: [694,0,331,85,246], // LATIN CAPITAL LETTER I
+ 0x4A: [694,22,519,46,427], // LATIN CAPITAL LETTER J
+ 0x4B: [694,0,764,92,701], // LATIN CAPITAL LETTER K
+ 0x4C: [694,0,581,92,534], // LATIN CAPITAL LETTER L
+ 0x4D: [694,0,978,92,886], // LATIN CAPITAL LETTER M
+ 0x4E: [694,0,794,92,702], // LATIN CAPITAL LETTER N
+ 0x4F: [716,22,794,62,731], // LATIN CAPITAL LETTER O
+ 0x50: [694,0,703,92,641], // LATIN CAPITAL LETTER P
+ 0x51: [716,106,794,62,732], // LATIN CAPITAL LETTER Q
+ 0x52: [694,0,703,92,654], // LATIN CAPITAL LETTER R
+ 0x53: [716,22,611,49,549], // LATIN CAPITAL LETTER S
+ 0x54: [688,0,733,40,692], // LATIN CAPITAL LETTER T
+ 0x55: [694,22,764,92,672], // LATIN CAPITAL LETTER U
+ 0x56: [694,-1,733,27,705], // LATIN CAPITAL LETTER V
+ 0x57: [694,0,1039,24,1014], // LATIN CAPITAL LETTER W
+ 0x58: [694,0,733,37,694], // LATIN CAPITAL LETTER X
+ 0x59: [694,0,733,24,708], // LATIN CAPITAL LETTER Y
+ 0x5A: [694,0,672,61,616], // LATIN CAPITAL LETTER Z
+ 0x5B: [750,250,343,79,318], // LEFT SQUARE BRACKET
+ 0x5D: [750,250,343,24,263], // RIGHT SQUARE BRACKET
+ 0x5E: [694,-537,550,108,441], // CIRCUMFLEX ACCENT
+ 0x5F: [-23,110,550,0,549], // LOW LINE
+ 0x61: [475,11,525,31,472], // LATIN SMALL LETTER A
+ 0x62: [694,10,561,54,523], // LATIN SMALL LETTER B
+ 0x63: [475,11,489,37,457], // LATIN SMALL LETTER C
+ 0x64: [694,11,561,37,507], // LATIN SMALL LETTER D
+ 0x65: [474,10,511,30,480], // LATIN SMALL LETTER E
+ 0x66: [705,0,336,29,381], // LATIN SMALL LETTER F
+ 0x67: [469,206,550,17,534], // LATIN SMALL LETTER G
+ 0x68: [694,0,561,53,508], // LATIN SMALL LETTER H
+ 0x69: [695,0,256,46,208], // LATIN SMALL LETTER I
+ 0x6A: [695,205,286,-71,232], // LATIN SMALL LETTER J
+ 0x6B: [694,0,531,63,496], // LATIN SMALL LETTER K
+ 0x6C: [694,0,256,54,201], // LATIN SMALL LETTER L
+ 0x6D: [469,0,867,53,815], // LATIN SMALL LETTER M
+ 0x6E: [468,0,561,53,508], // LATIN SMALL LETTER N
+ 0x6F: [474,11,550,32,518], // LATIN SMALL LETTER O
+ 0x70: [469,194,561,54,523], // LATIN SMALL LETTER P
+ 0x71: [469,194,561,37,507], // LATIN SMALL LETTER Q
+ 0x72: [469,0,372,54,356], // LATIN SMALL LETTER R
+ 0x73: [474,10,422,30,396], // LATIN SMALL LETTER S
+ 0x74: [589,10,404,20,373], // LATIN SMALL LETTER T
+ 0x75: [458,11,561,52,508], // LATIN SMALL LETTER U
+ 0x76: [458,0,500,26,473], // LATIN SMALL LETTER V
+ 0x77: [458,0,744,24,719], // LATIN SMALL LETTER W
+ 0x78: [458,0,500,24,475], // LATIN SMALL LETTER X
+ 0x79: [458,205,500,29,473], // LATIN SMALL LETTER Y
+ 0x7A: [458,0,476,31,442], // LATIN SMALL LETTER Z
+ 0x7E: [344,-198,550,92,457], // TILDE
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x131: [458,0,256,54,201], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [458,205,286,-71,232], // LATIN SMALL LETTER DOTLESS J
+ 0x300: [694,-537,0,-458,-218], // COMBINING GRAVE ACCENT
+ 0x301: [694,-537,0,-334,-93], // COMBINING ACUTE ACCENT
+ 0x302: [694,-537,0,-442,-109], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [694,-548,0,-458,-93], // COMBINING TILDE
+ 0x304: [660,-560,0,-474,-77], // COMBINING MACRON
+ 0x306: [694,-552,0,-470,-80], // COMBINING BREVE
+ 0x307: [695,-596,0,-356,-194], // COMBINING DOT ABOVE
+ 0x308: [695,-595,0,-459,-91], // COMBINING DIAERESIS
+ 0x30A: [694,-538,0,-365,-119], // COMBINING RING ABOVE
+ 0x30B: [694,-537,0,-440,-94], // COMBINING DOUBLE ACUTE ACCENT
+ 0x30C: [657,-500,0,-442,-109], // COMBINING CARON
+ 0x393: [691,0,581,92,534], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [694,0,917,60,856], // GREEK CAPITAL LETTER DELTA
+ 0x398: [716,22,856,62,793], // GREEK CAPITAL LETTER THETA
+ 0x39B: [694,0,672,41,630], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [688,0,733,46,686], // GREEK CAPITAL LETTER XI
+ 0x3A0: [691,0,794,92,702], // GREEK CAPITAL LETTER PI
+ 0x3A3: [694,0,794,61,732], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [715,0,856,62,793], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [694,0,794,62,732], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [694,0,856,61,794], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [716,0,794,49,744], // GREEK CAPITAL LETTER OMEGA
+ 0x2013: [327,-240,550,0,549], // EN DASH
+ 0x2014: [327,-240,1100,0,1099], // EM DASH
+ 0x2018: [694,-443,306,81,226], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [694,-442,306,80,226], // RIGHT SINGLE QUOTATION MARK
+ 0x201C: [694,-443,558,138,520], // LEFT DOUBLE QUOTATION MARK
+ 0x201D: [694,-442,558,37,420] // RIGHT DOUBLE QUOTATION MARK
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Italic.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Italic.js
new file mode 100644
index 0000000..bf70f15
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Italic.js
@@ -0,0 +1,154 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/SansSerif-Italic.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_SansSerif-Italic';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 250, ascent: 750, descent: 250,
+ style: 'italic',
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [694,0,319,110,355], // EXCLAMATION MARK
+ 0x22: [694,-471,500,133,472], // QUOTATION MARK
+ 0x23: [694,194,833,87,851], // NUMBER SIGN
+ 0x24: [750,56,500,56,565], // DOLLAR SIGN
+ 0x25: [750,56,833,165,815], // PERCENT SIGN
+ 0x26: [716,22,758,71,747], // AMPERSAND
+ 0x27: [694,-471,278,190,335], // APOSTROPHE
+ 0x28: [750,250,389,104,491], // LEFT PARENTHESIS
+ 0x29: [750,250,389,2,390], // RIGHT PARENTHESIS
+ 0x2A: [750,-306,500,156,568], // ASTERISK
+ 0x2B: [583,83,778,108,775], // PLUS SIGN
+ 0x2C: [98,125,278,63,209], // COMMA
+ 0x2D: [259,-186,333,51,332], // HYPHEN-MINUS
+ 0x2E: [98,0,278,90,209], // FULL STOP
+ 0x2F: [750,250,500,6,600], // SOLIDUS
+ 0x30: [678,22,500,88,549], // DIGIT ZERO
+ 0x31: [678,0,500,88,451], // DIGIT ONE
+ 0x32: [678,0,500,50,551], // DIGIT TWO
+ 0x33: [678,22,500,56,544], // DIGIT THREE
+ 0x34: [656,0,500,62,521], // DIGIT FOUR
+ 0x35: [656,22,500,50,555], // DIGIT FIVE
+ 0x36: [678,22,500,94,548], // DIGIT SIX
+ 0x37: [656,11,500,143,596], // DIGIT SEVEN
+ 0x38: [678,22,500,77,554], // DIGIT EIGHT
+ 0x39: [677,22,500,77,545], // DIGIT NINE
+ 0x3A: [444,0,278,90,282], // COLON
+ 0x3B: [444,125,278,63,282], // SEMICOLON
+ 0x3D: [370,-130,778,88,796], // EQUALS SIGN
+ 0x3F: [704,0,472,173,536], // QUESTION MARK
+ 0x40: [705,10,667,120,707], // COMMERCIAL AT
+ 0x41: [694,0,667,28,638], // LATIN CAPITAL LETTER A
+ 0x42: [694,0,667,90,696], // LATIN CAPITAL LETTER B
+ 0x43: [705,10,639,124,719], // LATIN CAPITAL LETTER C
+ 0x44: [694,0,722,88,747], // LATIN CAPITAL LETTER D
+ 0x45: [691,0,597,86,688], // LATIN CAPITAL LETTER E
+ 0x46: [691,0,569,86,673], // LATIN CAPITAL LETTER F
+ 0x47: [705,11,667,125,730], // LATIN CAPITAL LETTER G
+ 0x48: [694,0,708,86,768], // LATIN CAPITAL LETTER H
+ 0x49: [694,0,278,87,338], // LATIN CAPITAL LETTER I
+ 0x4A: [694,22,472,46,535], // LATIN CAPITAL LETTER J
+ 0x4B: [694,0,694,88,785], // LATIN CAPITAL LETTER K
+ 0x4C: [694,0,542,87,516], // LATIN CAPITAL LETTER L
+ 0x4D: [694,0,875,92,929], // LATIN CAPITAL LETTER M
+ 0x4E: [694,0,708,88,766], // LATIN CAPITAL LETTER N
+ 0x4F: [716,22,736,118,763], // LATIN CAPITAL LETTER O
+ 0x50: [694,0,639,88,690], // LATIN CAPITAL LETTER P
+ 0x51: [716,125,736,118,763], // LATIN CAPITAL LETTER Q
+ 0x52: [694,0,646,88,698], // LATIN CAPITAL LETTER R
+ 0x53: [716,22,556,54,609], // LATIN CAPITAL LETTER S
+ 0x54: [688,0,681,165,790], // LATIN CAPITAL LETTER T
+ 0x55: [694,22,688,131,747], // LATIN CAPITAL LETTER U
+ 0x56: [694,0,667,161,799], // LATIN CAPITAL LETTER V
+ 0x57: [694,0,944,161,1076], // LATIN CAPITAL LETTER W
+ 0x58: [694,0,667,14,758], // LATIN CAPITAL LETTER X
+ 0x59: [694,0,667,151,810], // LATIN CAPITAL LETTER Y
+ 0x5A: [694,0,611,55,702], // LATIN CAPITAL LETTER Z
+ 0x5B: [750,250,289,41,425], // LEFT SQUARE BRACKET
+ 0x5D: [750,250,289,-31,353], // RIGHT SQUARE BRACKET
+ 0x5E: [694,-527,500,190,533], // CIRCUMFLEX ACCENT
+ 0x5F: [-38,114,500,50,565], // LOW LINE
+ 0x61: [461,10,481,61,473], // LATIN SMALL LETTER A
+ 0x62: [694,11,517,75,539], // LATIN SMALL LETTER B
+ 0x63: [460,11,444,75,499], // LATIN SMALL LETTER C
+ 0x64: [694,10,517,73,588], // LATIN SMALL LETTER D
+ 0x65: [460,11,444,71,472], // LATIN SMALL LETTER E
+ 0x66: [705,0,306,94,494], // LATIN SMALL LETTER F
+ 0x67: [455,206,500,12,568], // LATIN SMALL LETTER G
+ 0x68: [694,0,517,73,513], // LATIN SMALL LETTER H
+ 0x69: [680,0,239,74,315], // LATIN SMALL LETTER I
+ 0x6A: [680,204,267,-96,336], // LATIN SMALL LETTER J
+ 0x6B: [694,0,489,76,543], // LATIN SMALL LETTER K
+ 0x6C: [694,0,239,74,311], // LATIN SMALL LETTER L
+ 0x6D: [455,0,794,73,790], // LATIN SMALL LETTER M
+ 0x6E: [454,0,517,73,513], // LATIN SMALL LETTER N
+ 0x6F: [461,11,500,69,523], // LATIN SMALL LETTER O
+ 0x70: [455,194,517,34,538], // LATIN SMALL LETTER P
+ 0x71: [455,194,517,72,538], // LATIN SMALL LETTER Q
+ 0x72: [455,0,342,74,424], // LATIN SMALL LETTER R
+ 0x73: [461,11,383,35,436], // LATIN SMALL LETTER S
+ 0x74: [571,11,361,97,410], // LATIN SMALL LETTER T
+ 0x75: [444,10,517,90,537], // LATIN SMALL LETTER U
+ 0x76: [444,0,461,108,540], // LATIN SMALL LETTER V
+ 0x77: [444,0,683,108,762], // LATIN SMALL LETTER W
+ 0x78: [444,0,461,1,537], // LATIN SMALL LETTER X
+ 0x79: [444,205,461,1,540], // LATIN SMALL LETTER Y
+ 0x7A: [444,0,435,28,494], // LATIN SMALL LETTER Z
+ 0x7E: [327,-193,500,199,560], // TILDE
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x131: [444,0,239,74,258], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [444,204,267,-96,286], // LATIN SMALL LETTER DOTLESS J
+ 0x300: [694,-527,0,-270,-87], // COMBINING GRAVE ACCENT
+ 0x301: [694,-527,0,-190,63], // COMBINING ACUTE ACCENT
+ 0x302: [694,-527,0,-310,33], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [677,-543,0,-301,60], // COMBINING TILDE
+ 0x304: [631,-552,0,-314,64], // COMBINING MACRON
+ 0x306: [694,-508,0,-284,73], // COMBINING BREVE
+ 0x307: [680,-576,0,-180,-54], // COMBINING DOT ABOVE
+ 0x308: [680,-582,0,-273,40], // COMBINING DIAERESIS
+ 0x30A: [693,-527,0,-227,-2], // COMBINING RING ABOVE
+ 0x30B: [694,-527,0,-287,63], // COMBINING DOUBLE ACUTE ACCENT
+ 0x30C: [654,-487,0,-283,60], // COMBINING CARON
+ 0x393: [691,0,542,87,646], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [694,0,833,42,790], // GREEK CAPITAL LETTER DELTA
+ 0x398: [715,22,778,119,804], // GREEK CAPITAL LETTER THETA
+ 0x39B: [694,0,611,28,582], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [688,0,667,42,765], // GREEK CAPITAL LETTER XI
+ 0x3A0: [691,0,708,86,768], // GREEK CAPITAL LETTER PI
+ 0x3A3: [694,0,722,55,813], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [716,0,778,173,843], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [694,0,722,124,743], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [694,0,778,171,854], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [716,0,722,44,769], // GREEK CAPITAL LETTER OMEGA
+ 0x2013: [312,-236,500,50,565], // EN DASH
+ 0x2014: [312,-236,1000,50,1065], // EM DASH
+ 0x2018: [694,-471,278,190,336], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [694,-471,278,190,335], // RIGHT SINGLE QUOTATION MARK
+ 0x201C: [694,-471,500,274,614], // LEFT DOUBLE QUOTATION MARK
+ 0x201D: [694,-471,500,133,472] // RIGHT DOUBLE QUOTATION MARK
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Regular.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Regular.js
new file mode 100644
index 0000000..a49d5ad
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/SansSerif-Regular.js
@@ -0,0 +1,154 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/SansSerif-Regular.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_SansSerif';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 250, ascent: 750, descent: 250,
+
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [694,0,319,110,208], // EXCLAMATION MARK
+ 0x22: [694,-471,500,32,325], // QUOTATION MARK
+ 0x23: [694,194,833,56,777], // NUMBER SIGN
+ 0x24: [750,56,500,44,444], // DOLLAR SIGN
+ 0x25: [750,56,833,56,776], // PERCENT SIGN
+ 0x26: [716,22,758,42,702], // AMPERSAND
+ 0x27: [694,-471,278,89,188], // APOSTROPHE
+ 0x28: [750,250,389,74,333], // LEFT PARENTHESIS
+ 0x29: [750,250,389,55,314], // RIGHT PARENTHESIS
+ 0x2A: [750,-306,500,63,436], // ASTERISK
+ 0x2B: [583,82,778,56,722], // PLUS SIGN
+ 0x2C: [98,125,278,89,188], // COMMA
+ 0x2D: [259,-186,333,11,277], // HYPHEN-MINUS
+ 0x2E: [98,0,278,90,188], // FULL STOP
+ 0x2F: [750,250,500,56,445], // SOLIDUS
+ 0x30: [678,22,500,39,460], // DIGIT ZERO
+ 0x31: [678,0,500,83,430], // DIGIT ONE
+ 0x32: [677,0,500,42,449], // DIGIT TWO
+ 0x33: [678,22,500,42,457], // DIGIT THREE
+ 0x34: [656,0,500,28,471], // DIGIT FOUR
+ 0x35: [656,21,500,33,449], // DIGIT FIVE
+ 0x36: [677,22,500,42,457], // DIGIT SIX
+ 0x37: [656,11,500,42,457], // DIGIT SEVEN
+ 0x38: [678,22,500,43,456], // DIGIT EIGHT
+ 0x39: [677,22,500,42,457], // DIGIT NINE
+ 0x3A: [444,0,278,90,188], // COLON
+ 0x3B: [444,125,278,89,188], // SEMICOLON
+ 0x3D: [370,-130,778,56,722], // EQUALS SIGN
+ 0x3F: [704,0,472,55,416], // QUESTION MARK
+ 0x40: [704,11,667,56,612], // COMMERCIAL AT
+ 0x41: [694,0,667,28,638], // LATIN CAPITAL LETTER A
+ 0x42: [694,0,667,90,610], // LATIN CAPITAL LETTER B
+ 0x43: [705,11,639,59,587], // LATIN CAPITAL LETTER C
+ 0x44: [694,0,722,88,666], // LATIN CAPITAL LETTER D
+ 0x45: [691,0,597,86,554], // LATIN CAPITAL LETTER E
+ 0x46: [691,0,569,86,526], // LATIN CAPITAL LETTER F
+ 0x47: [704,11,667,59,599], // LATIN CAPITAL LETTER G
+ 0x48: [694,0,708,86,621], // LATIN CAPITAL LETTER H
+ 0x49: [694,0,278,87,191], // LATIN CAPITAL LETTER I
+ 0x4A: [694,22,472,42,388], // LATIN CAPITAL LETTER J
+ 0x4B: [694,0,694,88,651], // LATIN CAPITAL LETTER K
+ 0x4C: [694,0,542,87,499], // LATIN CAPITAL LETTER L
+ 0x4D: [694,0,875,92,782], // LATIN CAPITAL LETTER M
+ 0x4E: [694,0,708,88,619], // LATIN CAPITAL LETTER N
+ 0x4F: [715,22,736,55,680], // LATIN CAPITAL LETTER O
+ 0x50: [694,0,639,88,583], // LATIN CAPITAL LETTER P
+ 0x51: [715,125,736,55,680], // LATIN CAPITAL LETTER Q
+ 0x52: [694,0,646,88,617], // LATIN CAPITAL LETTER R
+ 0x53: [716,22,556,44,500], // LATIN CAPITAL LETTER S
+ 0x54: [688,0,681,36,644], // LATIN CAPITAL LETTER T
+ 0x55: [694,22,688,87,600], // LATIN CAPITAL LETTER U
+ 0x56: [694,0,667,14,652], // LATIN CAPITAL LETTER V
+ 0x57: [694,0,944,14,929], // LATIN CAPITAL LETTER W
+ 0x58: [694,0,667,14,652], // LATIN CAPITAL LETTER X
+ 0x59: [694,0,667,3,663], // LATIN CAPITAL LETTER Y
+ 0x5A: [694,0,611,55,560], // LATIN CAPITAL LETTER Z
+ 0x5B: [750,250,289,94,266], // LEFT SQUARE BRACKET
+ 0x5D: [750,250,289,22,194], // RIGHT SQUARE BRACKET
+ 0x5E: [694,-527,500,78,421], // CIRCUMFLEX ACCENT
+ 0x5F: [-38,114,500,0,499], // LOW LINE
+ 0x61: [460,10,481,38,407], // LATIN SMALL LETTER A
+ 0x62: [694,11,517,75,482], // LATIN SMALL LETTER B
+ 0x63: [460,10,444,34,415], // LATIN SMALL LETTER C
+ 0x64: [694,10,517,33,441], // LATIN SMALL LETTER D
+ 0x65: [461,10,444,28,415], // LATIN SMALL LETTER E
+ 0x66: [705,0,306,27,347], // LATIN SMALL LETTER F
+ 0x67: [455,206,500,28,485], // LATIN SMALL LETTER G
+ 0x68: [694,0,517,73,443], // LATIN SMALL LETTER H
+ 0x69: [680,0,239,67,171], // LATIN SMALL LETTER I
+ 0x6A: [680,205,267,-59,192], // LATIN SMALL LETTER J
+ 0x6B: [694,0,489,76,471], // LATIN SMALL LETTER K
+ 0x6C: [694,0,239,74,164], // LATIN SMALL LETTER L
+ 0x6D: [455,0,794,73,720], // LATIN SMALL LETTER M
+ 0x6E: [455,0,517,73,443], // LATIN SMALL LETTER N
+ 0x6F: [460,10,500,28,471], // LATIN SMALL LETTER O
+ 0x70: [455,194,517,75,483], // LATIN SMALL LETTER P
+ 0x71: [455,194,517,33,441], // LATIN SMALL LETTER Q
+ 0x72: [455,0,342,74,327], // LATIN SMALL LETTER R
+ 0x73: [460,10,383,28,360], // LATIN SMALL LETTER S
+ 0x74: [571,10,361,18,333], // LATIN SMALL LETTER T
+ 0x75: [444,10,517,73,443], // LATIN SMALL LETTER U
+ 0x76: [444,0,461,14,446], // LATIN SMALL LETTER V
+ 0x77: [444,0,683,14,668], // LATIN SMALL LETTER W
+ 0x78: [444,0,461,0,460], // LATIN SMALL LETTER X
+ 0x79: [444,204,461,14,446], // LATIN SMALL LETTER Y
+ 0x7A: [444,0,435,28,402], // LATIN SMALL LETTER Z
+ 0x7E: [327,-193,500,83,416], // TILDE
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x131: [444,0,239,74,164], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [444,205,267,-59,192], // LATIN SMALL LETTER DOTLESS J
+ 0x300: [694,-527,0,-417,-199], // COMBINING GRAVE ACCENT
+ 0x301: [694,-527,0,-302,-84], // COMBINING ACUTE ACCENT
+ 0x302: [694,-527,0,-422,-79], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [677,-543,0,-417,-84], // COMBINING TILDE
+ 0x304: [631,-552,0,-431,-70], // COMBINING MACRON
+ 0x306: [694,-508,0,-427,-74], // COMBINING BREVE
+ 0x307: [680,-576,0,-302,-198], // COMBINING DOT ABOVE
+ 0x308: [680,-582,0,-397,-104], // COMBINING DIAERESIS
+ 0x30A: [694,-527,0,-319,-99], // COMBINING RING ABOVE
+ 0x30B: [694,-527,0,-399,-84], // COMBINING DOUBLE ACUTE ACCENT
+ 0x30C: [654,-487,0,-422,-79], // COMBINING CARON
+ 0x393: [691,0,542,87,499], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [694,0,833,42,790], // GREEK CAPITAL LETTER DELTA
+ 0x398: [716,21,778,56,722], // GREEK CAPITAL LETTER THETA
+ 0x39B: [694,0,611,28,582], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [688,0,667,42,624], // GREEK CAPITAL LETTER XI
+ 0x3A0: [691,0,708,86,621], // GREEK CAPITAL LETTER PI
+ 0x3A3: [694,0,722,55,666], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [716,0,778,55,722], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [694,0,722,55,666], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [694,0,778,55,722], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [716,0,722,44,677], // GREEK CAPITAL LETTER OMEGA
+ 0x2013: [312,-236,500,0,499], // EN DASH
+ 0x2014: [312,-236,1000,0,999], // EM DASH
+ 0x2018: [694,-471,278,90,189], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [694,-471,278,89,188], // RIGHT SINGLE QUOTATION MARK
+ 0x201C: [694,-471,500,174,467], // LEFT DOUBLE QUOTATION MARK
+ 0x201D: [694,-471,500,32,325] // RIGHT DOUBLE QUOTATION MARK
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Script-Regular.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Script-Regular.js
new file mode 100644
index 0000000..95ef8d1
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Script-Regular.js
@@ -0,0 +1,90 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/Script-Regular.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_Script';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 211, ascent: 735, descent: 314,
+ skew: {
+ 0x41: 0.389,
+ 0x42: 0.194,
+ 0x43: 0.278,
+ 0x44: 0.111,
+ 0x45: 0.139,
+ 0x46: 0.222,
+ 0x47: 0.25,
+ 0x48: 0.333,
+ 0x49: 0.333,
+ 0x4A: 0.417,
+ 0x4B: 0.361,
+ 0x4C: 0.306,
+ 0x4D: 0.444,
+ 0x4E: 0.389,
+ 0x4F: 0.167,
+ 0x50: 0.222,
+ 0x51: 0.278,
+ 0x52: 0.194,
+ 0x53: 0.333,
+ 0x54: 0.222,
+ 0x55: 0.25,
+ 0x56: 0.222,
+ 0x57: 0.25,
+ 0x58: 0.278,
+ 0x59: 0.194,
+ 0x5A: 0.306
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x41: [717,8,803,35,1016], // LATIN CAPITAL LETTER A
+ 0x42: [708,28,908,31,928], // LATIN CAPITAL LETTER B
+ 0x43: [728,26,666,26,819], // LATIN CAPITAL LETTER C
+ 0x44: [708,31,774,68,855], // LATIN CAPITAL LETTER D
+ 0x45: [707,8,562,46,718], // LATIN CAPITAL LETTER E
+ 0x46: [735,36,895,39,990], // LATIN CAPITAL LETTER F
+ 0x47: [717,37,610,12,738], // LATIN CAPITAL LETTER G
+ 0x48: [717,36,969,29,1241], // LATIN CAPITAL LETTER H
+ 0x49: [717,17,809,59,946], // LATIN CAPITAL LETTER I
+ 0x4A: [717,314,1052,92,1133], // LATIN CAPITAL LETTER J
+ 0x4B: [717,37,914,29,1204], // LATIN CAPITAL LETTER K
+ 0x4C: [717,17,874,14,1035], // LATIN CAPITAL LETTER L
+ 0x4D: [721,50,1080,30,1216], // LATIN CAPITAL LETTER M
+ 0x4E: [726,36,902,29,1208], // LATIN CAPITAL LETTER N
+ 0x4F: [707,8,738,96,805], // LATIN CAPITAL LETTER O
+ 0x50: [716,37,1013,90,1031], // LATIN CAPITAL LETTER P
+ 0x51: [717,17,883,54,885], // LATIN CAPITAL LETTER Q
+ 0x52: [717,17,850,-2,887], // LATIN CAPITAL LETTER R
+ 0x53: [708,36,868,29,1016], // LATIN CAPITAL LETTER S
+ 0x54: [735,37,747,92,996], // LATIN CAPITAL LETTER T
+ 0x55: [717,17,800,55,960], // LATIN CAPITAL LETTER U
+ 0x56: [717,17,622,56,850], // LATIN CAPITAL LETTER V
+ 0x57: [717,17,805,46,1026], // LATIN CAPITAL LETTER W
+ 0x58: [717,17,944,103,1131], // LATIN CAPITAL LETTER X
+ 0x59: [716,17,710,57,959], // LATIN CAPITAL LETTER Y
+ 0x5A: [717,16,821,83,1032], // LATIN CAPITAL LETTER Z
+ 0xA0: [0,0,250,0,0] // NO-BREAK SPACE
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/Typewriter-Regular.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Typewriter-Regular.js
new file mode 100644
index 0000000..66cfd23
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/Typewriter-Regular.js
@@ -0,0 +1,157 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/Typewriter-Regular.js
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (CHTML) {
+
+var font = 'MathJax_Typewriter';
+
+CHTML.FONTDATA.FONTS[font] = {
+ className: CHTML.FONTDATA.familyName(font),
+ centerline: 233, ascent: 694, descent: 229,
+
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [622,0,525,206,320], // EXCLAMATION MARK
+ 0x22: [623,-333,525,122,402], // QUOTATION MARK
+ 0x23: [611,0,525,36,489], // NUMBER SIGN
+ 0x24: [694,82,525,58,466], // DOLLAR SIGN
+ 0x25: [694,83,525,35,489], // PERCENT SIGN
+ 0x26: [622,11,525,28,490], // AMPERSAND
+ 0x27: [611,-287,525,175,349], // APOSTROPHE
+ 0x28: [694,82,525,166,437], // LEFT PARENTHESIS
+ 0x29: [694,82,525,87,358], // RIGHT PARENTHESIS
+ 0x2A: [520,-90,525,68,456], // ASTERISK
+ 0x2B: [531,-81,525,38,487], // PLUS SIGN
+ 0x2C: [140,139,525,173,353], // COMMA
+ 0x2D: [341,-271,525,57,468], // HYPHEN-MINUS
+ 0x2E: [140,-1,525,193,332], // FULL STOP
+ 0x2F: [694,83,525,58,466], // SOLIDUS
+ 0x30: [621,10,525,42,482], // DIGIT ZERO
+ 0x31: [622,-1,525,99,450], // DIGIT ONE
+ 0x32: [622,-1,525,52,472], // DIGIT TWO
+ 0x33: [622,11,525,44,479], // DIGIT THREE
+ 0x34: [624,-1,525,29,495], // DIGIT FOUR
+ 0x35: [611,10,525,52,472], // DIGIT FIVE
+ 0x36: [622,11,525,45,479], // DIGIT SIX
+ 0x37: [627,10,525,44,480], // DIGIT SEVEN
+ 0x38: [621,10,525,45,479], // DIGIT EIGHT
+ 0x39: [622,11,525,46,479], // DIGIT NINE
+ 0x3A: [431,-1,525,193,332], // COLON
+ 0x3B: [431,139,525,175,337], // SEMICOLON
+ 0x3C: [557,-55,525,57,468], // LESS-THAN SIGN
+ 0x3D: [417,-195,525,38,487], // EQUALS SIGN
+ 0x3E: [557,-55,525,57,468], // GREATER-THAN SIGN
+ 0x3F: [617,0,525,62,462], // QUESTION MARK
+ 0x40: [617,6,525,44,481], // COMMERCIAL AT
+ 0x41: [623,-1,525,28,496], // LATIN CAPITAL LETTER A
+ 0x42: [611,-1,525,17,482], // LATIN CAPITAL LETTER B
+ 0x43: [622,11,525,40,484], // LATIN CAPITAL LETTER C
+ 0x44: [611,-1,525,16,485], // LATIN CAPITAL LETTER D
+ 0x45: [611,-1,525,19,502], // LATIN CAPITAL LETTER E
+ 0x46: [611,-1,525,22,490], // LATIN CAPITAL LETTER F
+ 0x47: [622,11,525,38,496], // LATIN CAPITAL LETTER G
+ 0x48: [611,-1,525,16,508], // LATIN CAPITAL LETTER H
+ 0x49: [611,-1,525,72,452], // LATIN CAPITAL LETTER I
+ 0x4A: [611,11,525,57,479], // LATIN CAPITAL LETTER J
+ 0x4B: [611,-1,525,18,495], // LATIN CAPITAL LETTER K
+ 0x4C: [611,0,525,25,488], // LATIN CAPITAL LETTER L
+ 0x4D: [611,-1,525,12,512], // LATIN CAPITAL LETTER M
+ 0x4E: [611,0,525,20,504], // LATIN CAPITAL LETTER N
+ 0x4F: [621,10,525,56,468], // LATIN CAPITAL LETTER O
+ 0x50: [611,-1,525,19,480], // LATIN CAPITAL LETTER P
+ 0x51: [621,138,525,56,468], // LATIN CAPITAL LETTER Q
+ 0x52: [611,11,525,16,522], // LATIN CAPITAL LETTER R
+ 0x53: [622,11,525,52,472], // LATIN CAPITAL LETTER S
+ 0x54: [611,-1,525,26,498], // LATIN CAPITAL LETTER T
+ 0x55: [611,11,525,-3,528], // LATIN CAPITAL LETTER U
+ 0x56: [611,7,525,19,505], // LATIN CAPITAL LETTER V
+ 0x57: [611,7,525,12,512], // LATIN CAPITAL LETTER W
+ 0x58: [611,-1,525,28,495], // LATIN CAPITAL LETTER X
+ 0x59: [611,-1,525,20,505], // LATIN CAPITAL LETTER Y
+ 0x5A: [611,-1,525,48,481], // LATIN CAPITAL LETTER Z
+ 0x5B: [694,82,525,214,483], // LEFT SQUARE BRACKET
+ 0x5C: [694,83,525,58,466], // REVERSE SOLIDUS
+ 0x5D: [694,82,525,41,310], // RIGHT SQUARE BRACKET
+ 0x5E: [611,-460,525,96,428], // CIRCUMFLEX ACCENT
+ 0x5F: [-25,95,525,57,468], // LOW LINE
+ 0x60: [681,-357,525,176,350], // GRAVE ACCENT
+ 0x61: [439,6,525,48,524], // LATIN SMALL LETTER A
+ 0x62: [611,6,525,4,492], // LATIN SMALL LETTER B
+ 0x63: [440,6,525,66,466], // LATIN SMALL LETTER C
+ 0x64: [611,6,525,31,520], // LATIN SMALL LETTER D
+ 0x65: [440,6,525,48,464], // LATIN SMALL LETTER E
+ 0x66: [617,-1,525,35,437], // LATIN SMALL LETTER F
+ 0x67: [442,229,525,28,509], // LATIN SMALL LETTER G
+ 0x68: [611,-1,525,4,520], // LATIN SMALL LETTER H
+ 0x69: [612,-1,525,72,462], // LATIN SMALL LETTER I
+ 0x6A: [612,228,525,48,376], // LATIN SMALL LETTER J
+ 0x6B: [611,-1,525,13,507], // LATIN SMALL LETTER K
+ 0x6C: [611,-1,525,51,474], // LATIN SMALL LETTER L
+ 0x6D: [436,-1,525,-12,536], // LATIN SMALL LETTER M
+ 0x6E: [436,-1,525,4,520], // LATIN SMALL LETTER N
+ 0x6F: [440,6,525,52,472], // LATIN SMALL LETTER O
+ 0x70: [437,221,525,4,492], // LATIN SMALL LETTER P
+ 0x71: [437,221,525,34,545], // LATIN SMALL LETTER Q
+ 0x72: [437,-1,525,24,487], // LATIN SMALL LETTER R
+ 0x73: [440,6,525,72,458], // LATIN SMALL LETTER S
+ 0x74: [554,6,525,25,448], // LATIN SMALL LETTER T
+ 0x75: [431,5,525,4,520], // LATIN SMALL LETTER U
+ 0x76: [431,4,525,24,500], // LATIN SMALL LETTER V
+ 0x77: [431,4,525,16,508], // LATIN SMALL LETTER W
+ 0x78: [431,-1,525,29,495], // LATIN SMALL LETTER X
+ 0x79: [431,228,525,26,500], // LATIN SMALL LETTER Y
+ 0x7A: [431,-1,525,34,475], // LATIN SMALL LETTER Z
+ 0x7B: [694,83,525,50,475], // LEFT CURLY BRACKET
+ 0x7C: [694,82,525,228,297], // VERTICAL LINE
+ 0x7D: [694,83,525,49,475], // RIGHT CURLY BRACKET
+ 0x7E: [611,-466,525,87,437], // TILDE
+ 0x7F: [612,-519,525,104,421], // ??
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x131: [431,-1,525,72,462], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [431,228,525,48,376], // LATIN SMALL LETTER DOTLESS J
+ 0x300: [611,-485,0,-409,-195], // COMBINING GRAVE ACCENT
+ 0x301: [611,-485,0,-331,-117], // COMBINING ACUTE ACCENT
+ 0x302: [611,-460,0,-429,-97], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [611,-466,0,-438,-88], // COMBINING TILDE
+ 0x304: [577,-500,0,-452,-74], // COMBINING MACRON
+ 0x306: [611,-504,0,-446,-79], // COMBINING BREVE
+ 0x308: [612,-519,0,-421,-104], // COMBINING DIAERESIS
+ 0x30A: [619,-499,0,-344,-182], // COMBINING RING ABOVE
+ 0x30C: [577,-449,0,-427,-99], // COMBINING CARON
+ 0x393: [611,0,525,25,488], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [623,0,525,35,489], // GREEK CAPITAL LETTER DELTA
+ 0x398: [621,10,525,56,468], // GREEK CAPITAL LETTER THETA
+ 0x39B: [623,-1,525,30,495], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [611,-1,525,33,491], // GREEK CAPITAL LETTER XI
+ 0x3A0: [611,-1,525,16,508], // GREEK CAPITAL LETTER PI
+ 0x3A3: [611,-1,525,40,484], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [622,-1,525,38,486], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [611,-1,525,41,483], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [611,-1,525,37,487], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [622,-1,525,32,492], // GREEK CAPITAL LETTER OMEGA
+ 0x7E2: [611,-287,525,175,349], // ??
+ 0x7E3: [681,-357,525,176,350], // ??
+ 0x2032: [623,-334,525,211,313] // PRIME
+};
+
+CHTML.fontLoaded("TeX/"+font.substr(8));
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata-extra.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata-extra.js
new file mode 100644
index 0000000..62d7389
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata-extra.js
@@ -0,0 +1,242 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/fontdata-extra.js
+ *
+ * Adds extra stretchy characters to the TeX font data.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function (CHTML) {
+ var VERSION = "2.7.9";
+
+ var DELIMITERS = CHTML.FONTDATA.DELIMITERS;
+
+ var MAIN = "MathJax_Main",
+ BOLD = "MathJax_Main-Bold",
+ AMS = "MathJax_AMS",
+ SIZE1 = "MathJax_Size1",
+ SIZE4 = "MathJax_Size4";
+ var H = "H", V = "V";
+ var ARROWREP = [0x2212,MAIN,0,0,0,-.31,-.31]; // remove extra height/depth added below
+ var DARROWREP = [0x3D,MAIN,0,0,0,0,.1]; // add depth for arrow extender
+
+ var delim = {
+ 0x003D: // equal sign
+ {
+ dir: H, HW: [[.767,MAIN]], stretch: {rep:[0x003D,MAIN]}
+ },
+ 0x219E: // left two-headed arrow
+ {
+ dir: H, HW: [[1,AMS]], stretch: {left:[0x219E,AMS], rep:ARROWREP}
+ },
+ 0x21A0: // right two-headed arrow
+ {
+ dir: H, HW: [[1,AMS]], stretch: {right:[0x21A0,AMS], rep:ARROWREP}
+ },
+ 0x21A4: // left arrow from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:1, left:[0x2190,MAIN], rep:ARROWREP, right:[0x2223,SIZE1,0,-.05,.9]}
+ },
+ 0x21A5: // up arrow from bar
+ {
+ dir: V, HW: [],
+ stretch: {min:.6, bot:[0x22A5,BOLD,0,0,.75], ext:[0x23D0,SIZE1], top:[0x2191,SIZE1]}
+ },
+ 0x21A6: // right arrow from bar
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {left:[0x2223,SIZE1,-.09,-.05,.9], rep:ARROWREP, right:[0x2192,MAIN]}
+ },
+ 0x21A7: // down arrow from bar
+ {
+ dir: V, HW: [],
+ stretch: {min:.6, top:[0x22A4,BOLD,0,0,.75], ext:[0x23D0,SIZE1], bot:[0x2193,SIZE1]}
+ },
+ 0x21B0: // up arrow with top leftwards
+ {
+ dir: V, HW: [[.722,AMS]],
+ stretch: {top:[0x21B0,AMS], ext:[0x23D0,SIZE1,.097]}
+ },
+ 0x21B1: // up arrow with top right
+ {
+ dir: V, HW: [[.722,AMS]],
+ stretch: {top:[0x21B1,AMS,.27], ext:[0x23D0,SIZE1]}
+ },
+ 0x21BC: // left harpoon with barb up
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {left:[0x21BC,MAIN], rep:ARROWREP}
+ },
+ 0x21BD: // left harpoon with barb down
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {left:[0x21BD,MAIN], rep:ARROWREP}
+ },
+ 0x21BE: // up harpoon with barb right
+ {
+ dir: V, HW: [[.888,AMS]],
+ stretch: {top:[0x21BE,AMS,.12,0,1.1], ext:[0x23D0,SIZE1]}
+ },
+ 0x21BF: // up harpoon with barb left
+ {
+ dir: V, HW: [[.888,AMS]],
+ stretch: {top:[0x21BF,AMS,.12,0,1.1], ext:[0x23D0,SIZE1]}
+ },
+ 0x21C0: // right harpoon with barb up
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {right:[0x21C0,MAIN], rep:ARROWREP}
+ },
+ 0x21C1: // right harpoon with barb down
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {right:[0x21C1,MAIN], rep:ARROWREP}
+ },
+ 0x21C2: // down harpoon with barb right
+ {
+ dir: V, HW: [[.888,AMS]],
+ stretch: {bot:[0x21C2,AMS,.12,0,1.1], ext:[0x23D0,SIZE1]}
+ },
+ 0x21C3: // down harpoon with barb left
+ {
+ dir: V, HW: [[.888,AMS]],
+ stretch: {bot:[0x21C3,AMS,.12,0,1.1], ext:[0x23D0,SIZE1]}
+ },
+ 0x21DA: // left triple arrow
+ {
+ dir: H, HW: [[1,AMS]],
+ stretch: {left:[0x21DA,AMS], rep:[0x2261,MAIN]}
+ },
+ 0x21DB: // right triple arrow
+ {
+ dir: H, HW: [[1,AMS]],
+ stretch: {right:[0x21DB,AMS], rep:[0x2261,MAIN]}
+ },
+ 0x23B4: // top square bracket
+ {
+ dir: H, HW: [],
+ stretch: {min:.5, left:[0x250C,AMS,0,-.1], rep:[0x2212,MAIN,0,.35], right:[0x2510,AMS,0,-.1]}
+ },
+ 0x23B5: // bottom square bracket
+ {
+ dir: H, HW: [],
+ stretch: {min:.5, left:[0x2514,AMS,0,.26], rep:[0x2212,MAIN,0,0,0,.25], right:[0x2518,AMS,0,.26]}
+ },
+ 0x23DC: // top paren
+ {
+ dir: H, HW: [[.778,AMS,0,0x2322],[1,MAIN,0,0x2322]],
+ stretch: {left:[0xE150,SIZE4], rep:[0xE154,SIZE4], right:[0xE151,SIZE4]}
+ },
+ 0x23DD: // bottom paren
+ {
+ dir: H, HW: [[.778,AMS,0,0x2323],[1,MAIN,0,0x2323]],
+ stretch: {left:[0xE152,SIZE4], rep:[0xE154,SIZE4], right:[0xE153,SIZE4]}
+ },
+ 0x23E0: // top tortoise shell
+ {
+ dir: H, HW: [],
+ stretch: {min:1.25, left:[0x2CA,MAIN,-.1], rep:[0x2C9,MAIN,0,.13], right:[0x2CB,MAIN], fullExtenders:true}
+ },
+ 0x23E1: // bottom tortoise shell
+ {
+ dir: H, HW: [],
+ stretch: {min:1.5, left:[0x2CB,MAIN,-.1,.1], rep:[0x2C9,MAIN], right:[0x2CA,MAIN,-.1,.1], fullExtenders:true}
+ },
+ 0x2906: // leftwards double arrow from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:1, left:[0x21D0,MAIN], rep:DARROWREP, right:[0x2223,SIZE1,0,-.1]}
+ },
+ 0x2907: // rightwards double arrow from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:.7, left:[0x22A8,AMS,0,-.12], rep:DARROWREP, right:[0x21D2,MAIN]}
+ },
+ 0x294E: // left barb up right barb up harpoon
+ {
+ dir: H, HW: [],
+ stretch: {min:.5, left:[0x21BC,MAIN], rep:ARROWREP, right:[0x21C0,MAIN]}
+ },
+ 0x294F: // up barb right down barb right harpoon
+ {
+ dir: V, HW: [],
+ stretch: {min:.5, top:[0x21BE,AMS,.12,0,1.1], ext:[0x23D0,SIZE1], bot:[0x21C2,AMS,.12,0,1.1]}
+ },
+ 0x2950: // left barb dow right barb down harpoon
+ {
+ dir: H, HW: [],
+ stretch: {min:.5, left:[0x21BD,MAIN], rep:ARROWREP, right:[0x21C1,MAIN]}
+ },
+ 0x2951: // up barb left down barb left harpoon
+ {
+ dir: V, HW: [],
+ stretch: {min:.5, top:[0x21BF,AMS,.12,0,1.1], ext:[0x23D0,SIZE1], bot:[0x21C3,AMS,.12,0,1.1]}
+ },
+ 0x295A: // leftwards harpoon with barb up from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:1, left:[0x21BC,MAIN], rep:ARROWREP, right:[0x2223,SIZE1,0,-.05,.9]}
+ },
+ 0x295B: // rightwards harpoon with barb up from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:1, left:[0x2223,SIZE1,-.05,-.05,.9], rep:ARROWREP, right:[0x21C0,MAIN]}
+ },
+ 0x295C: // up harpoon with barb right from bar
+ {
+ dir: V, HW: [],
+ stretch: {min:.7, bot:[0x22A5,BOLD,0,0,.75], ext:[0x23D0,SIZE1], top:[0x21BE,AMS,.12,0,1.1]}
+ },
+ 0x295D: // down harpoon with barb right from bar
+ {
+ dir: V, HW: [],
+ stretch: {min:.7, top:[0x22A4,BOLD,0,0,.75], ext:[0x23D0,SIZE1], bot:[0x21C2,AMS,.12,0,1.1]}
+ },
+ 0x295E: // leftwards harpoon with barb down from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:1, left:[0x21BD,MAIN], rep:ARROWREP, right:[0x2223,SIZE1,0,-.05,.9]}
+ },
+ 0x295F: // rightwards harpoon with barb down from bar
+ {
+ dir: H, HW: [],
+ stretch: {min:1, left:[0x2223,SIZE1,-.05,-.05,.9], rep:ARROWREP, right:[0x21C1,MAIN]}
+ },
+ 0x2960: // up harpoon with barb left from bar
+ {
+ dir: V, HW: [],
+ stretch: {min:.7, bot:[0x22A5,BOLD,0,0,.75], ext:[0x23D0,SIZE1], top:[0x21BF,AMS,.12,0,1.1]}
+ },
+ 0x2961: // down harpoon with barb left from bar
+ {
+ dir: V, HW: [],
+ stretch: {min:.7, top:[0x22A4,BOLD,0,0,.75], ext:[0x23D0,SIZE1], bot:[0x21C3,AMS,.12,0,1.1]}
+ }
+ };
+
+ for (var id in delim) {if (delim.hasOwnProperty(id)) {DELIMITERS[id] = delim[id]}};
+
+ CHTML.fontLoaded("TeX/fontdata-extra");
+
+})(MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata.js b/js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata.js
new file mode 100644
index 0000000..9036c71
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/fonts/TeX/fontdata.js
@@ -0,0 +1,1786 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/fonts/TeX/fontdata.js
+ *
+ * Initializes the CommonHTML OutputJax to use the MathJax TeX fonts
+ * for displaying mathematics.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function (CHTML,MML,AJAX) {
+ var VERSION = "2.7.9";
+
+ var MAIN = "MathJax_Main",
+ BOLD = "MathJax_Main-Bold",
+ ITALIC = "MathJax_Math-Italic",
+ AMS = "MathJax_AMS",
+ SIZE1 = "MathJax_Size1",
+ SIZE2 = "MathJax_Size2",
+ SIZE3 = "MathJax_Size3",
+ SIZE4 = "MathJax_Size4";
+ var H = "H", V = "V", EXTRAH = {load:"extra", dir:H}, EXTRAV = {load:"extra", dir:V};
+ var ARROWREP = [0x2212,MAIN,0,0,0,-.31,-.31]; // remove extra height/depth added below
+ var DARROWREP = [0x3D,MAIN,0,0,0,0,.1]; // add depth for arrow extender
+
+ var UNDEFINEDFAMILY = CHTML.config.undefinedFamily;
+
+ MathJax.Hub.Insert(CHTML.config.styles,{
+ ".MJXc-TeX-unknown-R": {"font-family":UNDEFINEDFAMILY, "font-style":"normal", "font-weight":"normal"},
+ ".MJXc-TeX-unknown-I": {"font-family":UNDEFINEDFAMILY, "font-style":"italic", "font-weight":"normal"},
+ ".MJXc-TeX-unknown-B": {"font-family":UNDEFINEDFAMILY, "font-style":"normal", "font-weight":"bold"},
+ ".MJXc-TeX-unknown-BI": {"font-family":UNDEFINEDFAMILY, "font-style":"italic", "font-weight":"bold"}
+ });
+
+ CHTML.TEX = CHTML.TEXDEF; // use default TeX parameters
+ CHTML.FONTDEF.TeX = {
+ version: VERSION,
+
+ baselineskip: 1.2,
+ lineH: .8, lineD: .2,
+
+ FONTS: {
+//
+// These ones are defined below
+//
+// "MathJax_Main":
+// "MathJax_Main-Bold":
+// "MathJax_Main-Italic":
+// "MathJax_Math-Italic":
+// "MathJax_Caligraphic":
+// "MathJax_Size1":
+// "MathJax_Size2":
+// "MathJax_Size3":
+// "MathJax_Size4":
+
+ "MathJax_AMS": "TeX/AMS-Regular.js",
+ "MathJax_Caligraphic-Bold": "TeX/Caligraphic-Bold.js",
+ "MathJax_Fraktur": "TeX/Fraktur-Regular.js",
+ "MathJax_Fraktur-Bold": "TeX/Fraktur-Bold.js",
+ "MathJax_Math-BoldItalic": "TeX/Math-BoldItalic.js",
+ "MathJax_SansSerif": "TeX/SansSerif-Regular.js",
+ "MathJax_SansSerif-Bold": "TeX/SansSerif-Bold.js",
+ "MathJax_SansSerif-Italic": "TeX/SansSerif-Italic.js",
+ "MathJax_Script": "TeX/Script-Regular.js",
+ "MathJax_Typewriter": "TeX/Typewriter-Regular.js"
+ },
+
+ UNKNOWN: {
+ R: {className:"MJXc-TeX-unknown-R"},
+ I: {className:"MJXc-TeX-unknown-I"},
+ B: {className:"MJXc-TeX-unknown-B"},
+ BI: {className:"MJXc-TeX-unknown-BI"}
+ },
+
+ VARIANT: {
+ "normal": {fonts:[MAIN,SIZE1,AMS], cache: {},
+ offsetG: 0x03B1, variantG: "italic",
+ remap: {0x391:0x41, 0x392:0x42, 0x395:0x45, 0x396:0x5A, 0x397:0x48,
+ 0x399:0x49, 0x39A:0x4B, 0x39C:0x4D, 0x39D:0x4E, 0x39F:0x4F,
+ 0x3A1:0x50, 0x3A4:0x54, 0x3A7:0x58,
+ 0xE160:[0x2192, "-TeX-vec"], // HACK for \vec (#1709)
+ 0x2016:0x2225,
+ 0x2216:[0x2216,"-TeX-variant",true], // \smallsetminus
+ 0x210F:[0x210F,"-TeX-variant",true], // \hbar
+ 0x2032:[0x27,"sans-serif-italic"], // HACK: a smaller prime
+ 0x29F8:[0x002F,MML.VARIANT.ITALIC]}},
+ "bold": {fonts:[BOLD], bold:true, cache: {}, chain:"normal",
+ offsetG: 0x03B1, variantG: "bold-italic",
+ remap: {0x391:0x41, 0x392:0x42, 0x395:0x45, 0x396:0x5A, 0x397:0x48,
+ 0x399:0x49, 0x39A:0x4B, 0x39C:0x4D, 0x39D:0x4E, 0x39F:0x4F,
+ 0x3A1:0x50, 0x3A4:0x54, 0x3A7:0x58, 0x29F8:[0x002F,"bold-italic"],
+ 0xE160:[0x2192, "-TeX-vec-bold"], // HACK for \vec (#1709)
+ 0x2016:0x2225,
+ 0x219A:"\u2190\u0338", 0x219B:"\u2192\u0338", 0x21AE:"\u2194\u0338",
+ 0x21CD:"\u21D0\u0338", 0x21CE:"\u21D4\u0338", 0x21CF:"\u21D2\u0338",
+ 0x2204:"\u2203\u0338", 0x2224:"\u2223\u0338", 0x2226:"\u2225\u0338",
+ 0x2241:"\u223C\u0338", 0x2247:"\u2245\u0338",
+ 0x226E:"<\u0338", 0x226F:">\u0338",
+ 0x2270:"\u2264\u0338", 0x2271:"\u2265\u0338",
+ 0x2280:"\u227A\u0338", 0x2281:"\u227B\u0338",
+ 0x2288:"\u2286\u0338", 0x2289:"\u2287\u0338",
+ 0x22AC:"\u22A2\u0338", 0x22AD:"\u22A8\u0338",
+// 0x22AE:"\u22A9\u0338", 0x22AF:"\u22AB\u0338",
+ 0x22E0:"\u227C\u0338", 0x22E1:"\u227D\u0338"//,
+// 0x22EA:"\u22B2\u0338", 0x22EB:"\u22B3\u0338",
+// 0x22EC:"\u22B4\u0338", 0x22ED:"\u22B5\u0338"
+ }},
+ "italic": {fonts:[ITALIC,"MathJax_Main-Italic"], italic:true, cache: {}, chain:"normal",
+ remap: {0x391:0x41, 0x392:0x42, 0x395:0x45, 0x396:0x5A, 0x397:0x48,
+ 0x399:0x49, 0x39A:0x4B, 0x39C:0x4D, 0x39D:0x4E, 0x39F:0x4F,
+ 0x3A1:0x50, 0x3A4:0x54, 0x3A7:0x58}},
+ "bold-italic": {fonts:["MathJax_Math-BoldItalic"], bold:true, italic:true,
+ cache: {}, chain:"bold",
+ remap: {0x391:0x41, 0x392:0x42, 0x395:0x45, 0x396:0x5A, 0x397:0x48,
+ 0x399:0x49, 0x39A:0x4B, 0x39C:0x4D, 0x39D:0x4E, 0x39F:0x4F,
+ 0x3A1:0x50, 0x3A4:0x54, 0x3A7:0x58}},
+ "double-struck": {fonts:[AMS,MAIN,SIZE1], cache:{}},
+ "fraktur": {fonts:["MathJax_Fraktur"], cache:{}, chain:"normal"},
+ "bold-fraktur": {fonts:["MathJax_Fraktur-Bold"], bold:true, cache:{}, chain:"bold"},
+ "script": {fonts:["MathJax_Script"], cache:{}, chain:"normal"},
+ "bold-script": {fonts:["MathJax_Script"], bold:true, cache:{}, chain:"bold"},
+ "sans-serif": {fonts:["MathJax_SansSerif"], cache:{}, chain:"normal"},
+ "bold-sans-serif": {fonts:["MathJax_SansSerif-Bold"], bold:true, cache:{}, chain:"bold"},
+ "sans-serif-italic": {fonts:["MathJax_SansSerif-Italic"], italic:true, cache:{}, chain:"italic"},
+ "sans-serif-bold-italic": {fonts:["MathJax_SansSerif-Italic"], bold:true, italic:true, cache:{}, chain:"italic"},
+ "monospace": {fonts:["MathJax_Typewriter"], cache:{}, chain:"normal"},
+ "-tex-caligraphic": {fonts:["MathJax_Caligraphic"], offsetA: 0x41, variantA: "italic", cache:{}, chain:"normal"},
+ "-tex-oldstyle": {fonts:["MathJax_Caligraphic"], cache:{}, chain:"normal"},
+ "-tex-mathit": {fonts:["MathJax_Main-Italic"], italic:true, noIC: true, cache:{}, chain:"normal",
+ remap: {0x391:0x41, 0x392:0x42, 0x395:0x45, 0x396:0x5A, 0x397:0x48,
+ 0x399:0x49, 0x39A:0x4B, 0x39C:0x4D, 0x39D:0x4E, 0x39F:0x4F,
+ 0x3A1:0x50, 0x3A4:0x54, 0x3A7:0x58}},
+ "-TeX-variant": {fonts:[AMS,MAIN,SIZE1], cache:{}, // HACK: to get larger prime for \prime
+ 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,
+ 0x2216:[0x2216,MML.VARIANT.NORMAL,true], // \setminus
+ 0x210F:[0x210F,MML.VARIANT.NORMAL,true] // \hslash
+ }},
+ "-TeX-vec": {fonts: ["MathJax_Vector"], cache:{}}, // HACK: non-combining \vec
+ "-TeX-vec-bold": {fonts: ["MathJax_Vector-Bold"], cache:{}}, // HACK: non-combining \vec
+ "-largeOp": {fonts:[SIZE2,SIZE1,MAIN,AMS],cache:{}},
+ "-smallOp": {fonts:[SIZE1,MAIN,AMS], cache:{}},
+ "-tex-caligraphic-bold": {fonts:["MathJax_Caligraphic-Bold","MathJax_Main-Bold"], bold:true, cache:{}, chain:"normal",
+ offsetA: 0x41, variantA: "bold-italic"},
+ "-tex-oldstyle-bold": {fonts:["MathJax_Caligraphic-Bold","MathJax_Main-Bold"], bold:true, cache:{}, chain:"normal"}
+ },
+
+ RANGES: [
+ {name: "alpha", low: 0x61, high: 0x7A, offset: "A", add: 32},
+ {name: "number", low: 0x30, high: 0x39, offset: "N"},
+ {name: "greek", low: 0x03B1, high: 0x03F6, offset: "G"}
+ ],
+
+ REMAP: {
+ 0xA: 0x20, // newline
+ 0x203E: 0x2C9, // overline
+ 0xFE37: 0x23DE, 0xFE38: 0x23DF, // OverBrace, UnderBrace
+
+ 0xB7: 0x22C5, // center dot
+ 0x2B9: 0x2032, // prime,
+ 0x3D2: 0x3A5, // Upsilon
+ 0x2206: 0x394, // increment
+ 0x2015: 0x2014, 0x2017: 0x5F, // horizontal bars
+ 0x2022: 0x2219, 0x2044: 0x2F, // bullet, fraction slash
+ 0x2305: 0x22BC, 0x2306: 0x2A5E, // barwedge, doublebarwedge
+ 0x25AA: 0x25A0, 0x25B4: 0x25B2, // blacksquare, blacktriangle
+ 0x25B5: 0x25B3, 0x25B8: 0x25B6, // triangle, blacktriangleright
+ 0x25BE: 0x25BC, 0x25BF: 0x25BD, // blacktriangledown, triangledown
+ 0x25C2: 0x25C0, // blacktriangleleft
+ 0x2329: 0x27E8, 0x232A: 0x27E9, // langle, rangle
+ 0x3008: 0x27E8, 0x3009: 0x27E9, // langle, rangle
+ 0x2758: 0x2223, // VerticalSeparator
+ 0x2A2F: 0xD7, // cross product
+
+ 0x25FB: 0x25A1, 0x25FC: 0x25A0, // square, blacksquare
+
+ //
+ // Letter-like symbols (that appear elsewhere)
+ //
+ 0x2102: [0x0043,MML.VARIANT.DOUBLESTRUCK],
+// 0x210A: [0x0067,MML.VARIANT.SCRIPT],
+ 0x210B: [0x0048,MML.VARIANT.SCRIPT],
+ 0x210C: [0x0048,MML.VARIANT.FRAKTUR],
+ 0x210D: [0x0048,MML.VARIANT.DOUBLESTRUCK],
+ 0x210E: [0x0068,MML.VARIANT.ITALIC],
+ 0x2110: [0x004A,MML.VARIANT.SCRIPT],
+ 0x2111: [0x0049,MML.VARIANT.FRAKTUR],
+ 0x2112: [0x004C,MML.VARIANT.SCRIPT],
+ 0x2115: [0x004E,MML.VARIANT.DOUBLESTRUCK],
+ 0x2119: [0x0050,MML.VARIANT.DOUBLESTRUCK],
+ 0x211A: [0x0051,MML.VARIANT.DOUBLESTRUCK],
+ 0x211B: [0x0052,MML.VARIANT.SCRIPT],
+ 0x211C: [0x0052,MML.VARIANT.FRAKTUR],
+ 0x211D: [0x0052,MML.VARIANT.DOUBLESTRUCK],
+ 0x2124: [0x005A,MML.VARIANT.DOUBLESTRUCK],
+ 0x2126: [0x03A9,MML.VARIANT.NORMAL],
+ 0x2128: [0x005A,MML.VARIANT.FRAKTUR],
+ 0x212C: [0x0042,MML.VARIANT.SCRIPT],
+ 0x212D: [0x0043,MML.VARIANT.FRAKTUR],
+// 0x212F: [0x0065,MML.VARIANT.SCRIPT],
+ 0x2130: [0x0045,MML.VARIANT.SCRIPT],
+ 0x2131: [0x0046,MML.VARIANT.SCRIPT],
+ 0x2133: [0x004D,MML.VARIANT.SCRIPT],
+// 0x2134: [0x006F,MML.VARIANT.SCRIPT],
+
+ 0x2247: 0x2246, // wrong placement of this character
+ 0x231C: 0x250C, 0x231D:0x2510, // wrong placement of \ulcorner, \urcorner
+ 0x231E: 0x2514, 0x231F:0x2518, // wrong placement of \llcorner, \lrcorner
+
+ //
+ // compound symbols not in these fonts
+ //
+ 0x2204: "\u2203\u0338", // \not\exists
+ 0x220C: "\u220B\u0338", // \not\ni
+ 0x2244: "\u2243\u0338", // \not\simeq
+ 0x2249: "\u2248\u0338", // \not\approx
+ 0x2262: "\u2261\u0338", // \not\equiv
+ 0x226D: "\u224D\u0338", // \not\asymp
+ 0x2274: "\u2272\u0338", // \not\lesssim
+ 0x2275: "\u2273\u0338", // \not\gtrsim
+ 0x2278: "\u2276\u0338", // \not\lessgtr
+ 0x2279: "\u2277\u0338", // \not\gtrless
+ 0x2284: "\u2282\u0338", // \not\subset
+ 0x2285: "\u2283\u0338", // \not\supset
+ 0x22E2: "\u2291\u0338", // \not\sqsubseteq
+ 0x22E3: "\u2292\u0338", // \not\sqsupseteq
+
+ 0x2A0C: "\u222C\u222C", // quadruple integral
+
+ 0x2033: "\u2032\u2032", // double prime
+ 0x2034: "\u2032\u2032\u2032", // triple prime
+ 0x2036: "\u2035\u2035", // double back prime
+ 0x2037: "\u2035\u2035\u2035", // trile back prime
+ 0x2057: "\u2032\u2032\u2032\u2032", // quadruple prime
+ },
+
+ REMAPACCENT: {
+ "\u0300":"\u02CB", // grave accent
+ "\u0301":"\u02CA", // acute accent
+ "\u0302":"\u02C6", // curcumflex
+ "\u0303":"\u02DC", // tilde accent
+ "\u0304":"\u02C9", // macron
+ "\u0306":"\u02D8", // breve
+ "\u0307":"\u02D9", // dot
+ "\u0308":"\u00A8", // diaresis
+ "\u030A":"\u02DA", // ring above
+ "\u030C":"\u02C7", // caron
+ "\u20D7":"\uE160", // HACK: for non-combining \vec (#1709)
+ "\u2192":"\uE160",
+ "\u2032":"'",
+ "\u2035":"`",
+ "\u20D0":"\u21BC", "\u20D1":"\u21C0", // combining left and right harpoons
+ "\u20D6":"\u2190", "\u20E1":"\u2194", // combining left arrow and lef-right arrow
+ "\u20F0":"*", // combining asterisk
+ "\u20DB":"...", // combining three dots above
+ "\u20DC":"...." // combining four dots above
+ },
+ REMAPACCENTUNDER: {
+ "\u20EC":"\u21C1", "\u20ED":"\u21BD", // combining low right and left harpoons
+ "\u20EE":"\u2190", "\u20EF":"\u2192", // combining low left and right arrows
+ "\u20DB":"...", // combining three dots above
+ "\u20DC":"...." // combining four dots above
+ },
+
+ PLANE1MAP: [
+ [0x1D400,0x1D419, 0x41, MML.VARIANT.BOLD],
+ [0x1D41A,0x1D433, 0x61, MML.VARIANT.BOLD],
+ [0x1D434,0x1D44D, 0x41, MML.VARIANT.ITALIC],
+ [0x1D44E,0x1D467, 0x61, MML.VARIANT.ITALIC],
+ [0x1D468,0x1D481, 0x41, MML.VARIANT.BOLDITALIC],
+ [0x1D482,0x1D49B, 0x61, MML.VARIANT.BOLDITALIC],
+ [0x1D49C,0x1D4B5, 0x41, MML.VARIANT.SCRIPT],
+// [0x1D4B6,0x1D4CF, 0x61, MML.VARIANT.SCRIPT],
+// [0x1D4D0,0x1D4E9, 0x41, MML.VARIANT.BOLDSCRIPT],
+// [0x1D4EA,0x1D503, 0x61, MML.VARIANT.BOLDSCRIPT],
+ [0x1D504,0x1D51D, 0x41, MML.VARIANT.FRAKTUR],
+ [0x1D51E,0x1D537, 0x61, MML.VARIANT.FRAKTUR],
+ [0x1D538,0x1D551, 0x41, MML.VARIANT.DOUBLESTRUCK],
+// [0x1D552,0x1D56B, 0x61, MML.VARIANT.DOUBLESTRUCK],
+ [0x1D56C,0x1D585, 0x41, MML.VARIANT.BOLDFRAKTUR],
+ [0x1D586,0x1D59F, 0x61, MML.VARIANT.BOLDFRAKTUR],
+ [0x1D5A0,0x1D5B9, 0x41, MML.VARIANT.SANSSERIF],
+ [0x1D5BA,0x1D5D3, 0x61, MML.VARIANT.SANSSERIF],
+ [0x1D5D4,0x1D5ED, 0x41, MML.VARIANT.BOLDSANSSERIF],
+ [0x1D5EE,0x1D607, 0x61, MML.VARIANT.BOLDSANSSERIF],
+ [0x1D608,0x1D621, 0x41, MML.VARIANT.SANSSERIFITALIC],
+ [0x1D622,0x1D63B, 0x61, MML.VARIANT.SANSSERIFITALIC],
+// [0x1D63C,0x1D655, 0x41, MML.VARIANT.SANSSERIFBOLDITALIC],
+// [0x1D656,0x1D66F, 0x61, MML.VARIANT.SANSSERIFBOLDITALIC],
+ [0x1D670,0x1D689, 0x41, MML.VARIANT.MONOSPACE],
+ [0x1D68A,0x1D6A3, 0x61, MML.VARIANT.MONOSPACE],
+
+ [0x1D6A8,0x1D6C1, 0x391, MML.VARIANT.BOLD],
+// [0x1D6C2,0x1D6E1, 0x3B1, MML.VARIANT.BOLD],
+ [0x1D6E2,0x1D6FA, 0x391, MML.VARIANT.ITALIC],
+ [0x1D6FC,0x1D71B, 0x3B1, MML.VARIANT.ITALIC],
+ [0x1D71C,0x1D734, 0x391, MML.VARIANT.BOLDITALIC],
+ [0x1D736,0x1D755, 0x3B1, MML.VARIANT.BOLDITALIC],
+ [0x1D756,0x1D76E, 0x391, MML.VARIANT.BOLDSANSSERIF],
+// [0x1D770,0x1D78F, 0x3B1, MML.VARIANT.BOLDSANSSERIF],
+ [0x1D790,0x1D7A8, 0x391, MML.VARIANT.SANSSERIFBOLDITALIC],
+// [0x1D7AA,0x1D7C9, 0x3B1, MML.VARIANT.SANSSERIFBOLDITALIC],
+
+ [0x1D7CE,0x1D7D7, 0x30, MML.VARIANT.BOLD],
+// [0x1D7D8,0x1D7E1, 0x30, MML.VARIANT.DOUBLESTRUCK],
+ [0x1D7E2,0x1D7EB, 0x30, MML.VARIANT.SANSSERIF],
+ [0x1D7EC,0x1D7F5, 0x30, MML.VARIANT.BOLDSANSSERIF],
+ [0x1D7F6,0x1D7FF, 0x30, MML.VARIANT.MONOSPACE]
+ ],
+
+ REMAPGREEK: {
+ 0x391: 0x41, 0x392: 0x42, 0x395: 0x45, 0x396: 0x5A,
+ 0x397: 0x48, 0x399: 0x49, 0x39A: 0x4B, 0x39C: 0x4D,
+ 0x39D: 0x4E, 0x39F: 0x4F, 0x3A1: 0x50, 0x3A2: 0x398,
+ 0x3A4: 0x54, 0x3A7: 0x58, 0x3AA: 0x2207,
+ 0x3CA: 0x2202, 0x3CB: 0x3F5, 0x3CC: 0x3D1, 0x3CD: 0x3F0,
+ 0x3CE: 0x3D5, 0x3CF: 0x3F1, 0x3D0: 0x3D6
+ },
+
+ RemapPlane1: function (n,variant) {
+ for (var i = 0, m = this.PLANE1MAP.length; i < m; i++) {
+ if (n < this.PLANE1MAP[i][0]) break;
+ if (n <= this.PLANE1MAP[i][1]) {
+ n = n - this.PLANE1MAP[i][0] + this.PLANE1MAP[i][2];
+ if (this.REMAPGREEK[n]) {n = this.REMAPGREEK[n]}
+ variant = this.VARIANT[this.PLANE1MAP[i][3]];
+ break;
+ }
+ }
+ return {n: n, variant: variant};
+ },
+
+ DELIMITERS: {
+ 0x0028: // (
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top: [0x239B,SIZE4], ext: [0x239C,SIZE4], bot: [0x239D,SIZE4]}
+ },
+ 0x0029: // )
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top:[0x239E,SIZE4], ext:[0x239F,SIZE4], bot:[0x23A0,SIZE4]}
+ },
+ 0x002F: // /
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]]
+ },
+ 0x005B: // [
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top:[0x23A1,SIZE4], ext:[0x23A2,SIZE4], bot:[0x23A3,SIZE4]}
+ },
+ 0x005C: // \
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]]
+ },
+ 0x005D: // ]
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top:[0x23A4,SIZE4], ext:[0x23A5,SIZE4], bot:[0x23A6,SIZE4]}
+ },
+ 0x007B: // {
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top:[0x23A7,SIZE4], mid:[0x23A8,SIZE4], bot:[0x23A9,SIZE4], ext:[0x23AA,SIZE4]}
+ },
+ 0x007C: // |
+ {
+ dir: V, HW: [[1,MAIN]], stretch: {ext:[0x2223,MAIN]}
+ },
+ 0x007D: // }
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top: [0x23AB,SIZE4], mid:[0x23AC,SIZE4], bot: [0x23AD,SIZE4], ext: [0x23AA,SIZE4]}
+ },
+ 0x00AF: // macron
+ {
+ dir: H, HW: [[.59,MAIN]], stretch: {rep:[0xAF,MAIN]}
+ },
+ 0x02C6: // wide hat
+ {
+ dir: H, HW: [[.267+.25,MAIN],[.567+.25,SIZE1],[1.005+.33,SIZE2],[1.447+.33,SIZE3],[1.909,SIZE4]]
+ },
+ 0x02DC: // wide tilde
+ {
+ dir: H, HW: [[.333+.25,MAIN],[.555+.25,SIZE1],[1+.33,SIZE2],[1.443+.33,SIZE3],[1.887,SIZE4]]
+ },
+ 0x2013: // en-dash
+ {
+ dir: H, HW: [[.5,MAIN]], stretch: {rep:[0x2013,MAIN]}
+ },
+ 0x2016: // vertical arrow extension
+ {
+ dir: V, HW: [[.602,SIZE1],[1,MAIN,null,0x2225]], stretch: {ext:[0x2225,MAIN]}
+ },
+ 0x2190: // left arrow
+ {
+ dir: H, HW: [[1,MAIN]], stretch: {left:[0x2190,MAIN], rep:ARROWREP}
+ },
+ 0x2191: // \uparrow
+ {
+ dir: V, HW: [[.888,MAIN]], stretch: {top:[0x2191,SIZE1], ext:[0x23D0,SIZE1]}
+ },
+ 0x2192: // right arrow
+ {
+ dir: H, HW: [[1,MAIN]], stretch: {rep:ARROWREP, right:[0x2192,MAIN]}
+ },
+ 0x2193: // \downarrow
+ {
+ dir: V, HW: [[.888,MAIN]], stretch: {ext:[0x23D0,SIZE1], bot:[0x2193,SIZE1]}
+ },
+ 0x2194: // left-right arrow
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {left:[0x2190,MAIN], rep:ARROWREP, right:[0x2192,MAIN]}
+ },
+ 0x2195: // \updownarrow
+ {
+ dir: V, HW: [[1.044,MAIN]],
+ stretch: {top:[0x2191,SIZE1], ext:[0x23D0,SIZE1], bot:[0x2193,SIZE1]}
+ },
+ 0x21D0: // left double arrow
+ {
+ dir: H, HW: [[1,MAIN]], stretch: {left:[0x21D0,MAIN], rep:DARROWREP}
+ },
+ 0x21D1: // \Uparrow
+ {
+ dir: V, HW: [[.888,MAIN]], stretch: {top:[0x21D1,SIZE1], ext:[0x2016,SIZE1]}
+ },
+ 0x21D2: // right double arrow
+ {
+ dir: H, HW: [[1,MAIN]], stretch: {rep:DARROWREP, right:[0x21D2,MAIN]}
+ },
+ 0x21D3: // \Downarrow
+ {
+ dir: V, HW: [[.888,MAIN]], stretch: {ext:[0x2016,SIZE1], bot:[0x21D3,SIZE1]}
+ },
+ 0x21D4: // left-right double arrow
+ {
+ dir: H, HW: [[1,MAIN]],
+ stretch: {left:[0x21D0,MAIN], rep:DARROWREP, right:[0x21D2,MAIN]}
+ },
+ 0x21D5: // \Updownarrow
+ {
+ dir: V, HW: [[1.044,MAIN]],
+ stretch: {top:[0x21D1,SIZE1], ext:[0x2016,SIZE1], bot:[0x21D3,SIZE1]}
+ },
+ 0x2212: // horizontal line
+ {
+ dir: H, HW: [[.778,MAIN]], stretch: {rep:[0x2212,MAIN]}
+ },
+ 0x221A: // \surd
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3,SIZE4]],
+ stretch: {top:[0xE001,SIZE4], ext:[0xE000,SIZE4], bot:[0x23B7,SIZE4], fullExtenders:true}
+ },
+ 0x2223: // \vert
+ {
+ dir: V, HW: [[1,MAIN]], stretch: {ext:[0x2223,MAIN]}
+ },
+ 0x2225: // \Vert
+ {
+ dir: V, HW: [[1,MAIN]], stretch: {ext:[0x2225,MAIN]}
+ },
+ 0x2308: // \lceil
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top:[0x23A1,SIZE4], ext:[0x23A2,SIZE4]}
+ },
+ 0x2309: // \rceil
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {top:[0x23A4,SIZE4], ext:[0x23A5,SIZE4]}
+ },
+ 0x230A: // \lfloor
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {ext:[0x23A2,SIZE4], bot:[0x23A3,SIZE4]}
+ },
+ 0x230B: // \rfloor
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]],
+ stretch: {ext:[0x23A5,SIZE4], bot:[0x23A6,SIZE4]}
+ },
+ 0x23AA: // \bracevert
+ {
+ dir: V, HW: [[.32,SIZE4]],
+ stretch: {top:[0x23AA,SIZE4], ext:[0x23AA,SIZE4], bot:[0x23AA,SIZE4]}
+ },
+ 0x23B0: // \lmoustache
+ {
+ dir: V, HW: [[.989,MAIN]],
+ stretch: {top:[0x23A7,SIZE4], ext:[0x23AA,SIZE4], bot:[0x23AD,SIZE4]}
+ },
+ 0x23B1: // \rmoustache
+ {
+ dir: V, HW: [[.989,MAIN]],
+ stretch: {top:[0x23AB,SIZE4], ext:[0x23AA,SIZE4], bot:[0x23A9,SIZE4]}
+ },
+ 0x23D0: // vertical line extension
+ {
+ dir: V, HW: [[.602,SIZE1],[1,MAIN,null,0x2223]], stretch: {ext:[0x2223,MAIN]}
+ },
+ 0x23DE: // horizontal brace down
+ {
+ dir: H, HW: [],
+ stretch: {min:.9, left:[0xE150,SIZE4], mid:[[0xE153,0xE152],SIZE4], right:[0xE151,SIZE4], rep:[0xE154,SIZE4]}
+ },
+ 0x23DF: // horizontal brace up
+ {
+ dir: H, HW: [],
+ stretch: {min:.9, left:[0xE152,SIZE4], mid:[[0xE151,0xE150],SIZE4], right:[0xE153,SIZE4], rep:[0xE154,SIZE4]}
+ },
+ 0x27E8: // \langle
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]]
+ },
+ 0x27E9: // \rangle
+ {
+ dir: V, HW: [[1,MAIN],[1.2,SIZE1],[1.8,SIZE2],[2.4,SIZE3],[3.0,SIZE4]]
+ },
+ 0x27EE: // \lgroup
+ {
+ dir: V, HW: [[.989,MAIN]],
+ stretch: {top:[0x23A7,SIZE4], ext:[0x23AA,SIZE4], bot:[0x23A9,SIZE4]}
+ },
+ 0x27EF: // \rgroup
+ {
+ dir: V, HW: [[.989,MAIN]],
+ stretch: {top:[0x23AB,SIZE4], ext:[0x23AA,SIZE4], bot:[0x23AD,SIZE4]}
+ },
+ 0x002D: {alias: 0x2212, dir:H}, // minus
+ 0x005E: {alias: 0x02C6, dir:H}, // wide hat
+ 0x005F: {alias: 0x2013, dir:H}, // low line
+ 0x007E: {alias: 0x02DC, dir:H}, // wide tilde
+ 0x02C9: {alias: 0x00AF, dir:H}, // macron
+ 0x0302: {alias: 0x02C6, dir:H}, // wide hat
+ 0x0303: {alias: 0x02DC, dir:H}, // wide tilde
+ 0x030C: {alias: 0x02C7, dir:H}, // wide caron
+ 0x0332: {alias: 0x2013, dir:H}, // combining low line
+ 0x2014: {alias: 0x2013, dir:H}, // em-dash
+ 0x2015: {alias: 0x2013, dir:H}, // horizontal line
+ 0x2017: {alias: 0x2013, dir:H}, // horizontal line
+ 0x203E: {alias: 0x00AF, dir:H}, // overline
+ 0x20D7: {alias: 0x2192, dir:H}, // combining over right arrow (vector arrow)
+ 0x2215: {alias: 0x002F, dir:V}, // division slash
+ 0x2329: {alias: 0x27E8, dir:V}, // langle
+ 0x232A: {alias: 0x27E9, dir:V}, // rangle
+ 0x23AF: {alias: 0x2013, dir:H}, // horizontal line extension
+ 0x2500: {alias: 0x2013, dir:H}, // horizontal line
+ 0x2758: {alias: 0x2223, dir:V}, // vertical separator
+ 0x3008: {alias: 0x27E8, dir:V}, // langle
+ 0x3009: {alias: 0x27E9, dir:V}, // rangle
+ 0xFE37: {alias: 0x23DE, dir:H}, // horizontal brace down
+ 0xFE38: {alias: 0x23DF, dir:H}, // horizontal brace up
+
+ 0x003D: EXTRAH, // equal sign
+ 0x219E: EXTRAH, // left two-headed arrow
+ 0x21A0: EXTRAH, // right two-headed arrow
+ 0x21A4: EXTRAH, // left arrow from bar
+ 0x21A5: EXTRAV, // up arrow from bar
+ 0x21A6: EXTRAH, // right arrow from bar
+ 0x21A7: EXTRAV, // down arrow from bar
+ 0x21B0: EXTRAV, // up arrow with top leftwards
+ 0x21B1: EXTRAV, // up arrow with top right
+ 0x21BC: EXTRAH, // left harpoon with barb up
+ 0x21BD: EXTRAH, // left harpoon with barb down
+ 0x21BE: EXTRAV, // up harpoon with barb right
+ 0x21BF: EXTRAV, // up harpoon with barb left
+ 0x21C0: EXTRAH, // right harpoon with barb up
+ 0x21C1: EXTRAH, // right harpoon with barb down
+ 0x21C2: EXTRAV, // down harpoon with barb right
+ 0x21C3: EXTRAV, // down harpoon with barb left
+ 0x21DA: EXTRAH, // left triple arrow
+ 0x21DB: EXTRAH, // right triple arrow
+ 0x23B4: EXTRAH, // top square bracket
+ 0x23B5: EXTRAH, // bottom square bracket
+ 0x23DC: EXTRAH, // top paren
+ 0x23DD: EXTRAH, // bottom paren
+ 0x23E0: EXTRAH, // top tortoise shell
+ 0x23E1: EXTRAH, // bottom tortoise shell
+ 0x2906: EXTRAH, // leftwards double arrow from bar
+ 0x2907: EXTRAH, // rightwards double arrow from bar
+ 0x294E: EXTRAH, // left barb up right barb up harpoon
+ 0x294F: EXTRAV, // up barb right down barb right harpoon
+ 0x2950: EXTRAH, // left barb dow right barb down harpoon
+ 0x2951: EXTRAV, // up barb left down barb left harpoon
+ 0x295A: EXTRAH, // leftwards harpoon with barb up from bar
+ 0x295B: EXTRAH, // rightwards harpoon with barb up from bar
+ 0x295C: EXTRAV, // up harpoon with barb right from bar
+ 0x295D: EXTRAV, // down harpoon with barb right from bar
+ 0x295E: EXTRAH, // leftwards harpoon with barb down from bar
+ 0x295F: EXTRAH, // rightwards harpoon with barb down from bar
+ 0x2960: EXTRAV, // up harpoon with barb left from bar
+ 0x2961: EXTRAV, // down harpoon with barb left from bar
+ 0x2312: {alias: 0x23DC, dir:H}, // arc
+ 0x2322: {alias: 0x23DC, dir:H}, // frown
+ 0x2323: {alias: 0x23DD, dir:H}, // smile
+ 0x27F5: {alias: 0x2190, dir:H}, // long left arrow
+ 0x27F6: {alias: 0x2192, dir:H}, // long right arrow
+ 0x27F7: {alias: 0x2194, dir:H}, // long left-right arrow
+ 0x27F8: {alias: 0x21D0, dir:H}, // long left double arrow
+ 0x27F9: {alias: 0x21D2, dir:H}, // long right double arrow
+ 0x27FA: {alias: 0x21D4, dir:H}, // long left-right double arrow
+ 0x27FB: {alias: 0x21A4, dir:H}, // long left arrow from bar
+ 0x27FC: {alias: 0x21A6, dir:H}, // long right arrow from bar
+ 0x27FD: {alias: 0x2906, dir:H}, // long left double arrow from bar
+ 0x27FE: {alias: 0x2907, dir:H}, // long right double arrow from bar
+ 0xE160: {alias: 0x2190, dir:H}, // replacement vector arrow
+ }
+ };
+
+ CHTML.FONTDATA = CHTML.FONTDEF["TeX"];
+
+ CHTML.FONTDATA.FONTS['MathJax_Caligraphic'] = {
+ centerline: 287, ascent: 789, descent: 216,
+ skew: {
+ 0x41: 0.194,
+ 0x42: 0.139,
+ 0x43: 0.139,
+ 0x44: 0.0833,
+ 0x45: 0.111,
+ 0x46: 0.111,
+ 0x47: 0.111,
+ 0x48: 0.111,
+ 0x49: 0.0278,
+ 0x4A: 0.167,
+ 0x4B: 0.0556,
+ 0x4C: 0.139,
+ 0x4D: 0.139,
+ 0x4E: 0.0833,
+ 0x4F: 0.111,
+ 0x50: 0.0833,
+ 0x51: 0.111,
+ 0x52: 0.0833,
+ 0x53: 0.139,
+ 0x54: 0.0278,
+ 0x55: 0.0833,
+ 0x56: 0.0278,
+ 0x57: 0.0833,
+ 0x58: 0.139,
+ 0x59: 0.0833,
+ 0x5A: 0.139
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x30: [452,22,500,39,460], // DIGIT ZERO
+ 0x31: [453,0,500,86,426], // DIGIT ONE
+ 0x32: [453,0,500,44,449], // DIGIT TWO
+ 0x33: [452,216,500,42,456], // DIGIT THREE
+ 0x34: [464,194,500,28,471], // DIGIT FOUR
+ 0x35: [453,216,500,50,448], // DIGIT FIVE
+ 0x36: [665,22,500,42,456], // DIGIT SIX
+ 0x37: [463,216,500,55,485], // DIGIT SEVEN
+ 0x38: [666,21,500,43,456], // DIGIT EIGHT
+ 0x39: [453,216,500,42,457], // DIGIT NINE
+ 0x41: [728,50,798,30,819], // LATIN CAPITAL LETTER A
+ 0x42: [705,22,657,32,664], // LATIN CAPITAL LETTER B
+ 0x43: [705,25,527,12,533], // LATIN CAPITAL LETTER C
+ 0x44: [683,0,771,19,766], // LATIN CAPITAL LETTER D
+ 0x45: [705,22,528,30,564], // LATIN CAPITAL LETTER E
+ 0x46: [683,32,719,18,829], // LATIN CAPITAL LETTER F
+ 0x47: [704,119,595,44,599], // LATIN CAPITAL LETTER G
+ 0x48: [683,48,845,18,803], // LATIN CAPITAL LETTER H
+ 0x49: [683,0,545,-30,642], // LATIN CAPITAL LETTER I
+ 0x4A: [683,119,678,47,839], // LATIN CAPITAL LETTER J
+ 0x4B: [705,22,762,32,732], // LATIN CAPITAL LETTER K
+ 0x4C: [705,22,690,32,656], // LATIN CAPITAL LETTER L
+ 0x4D: [705,50,1201,28,1137], // LATIN CAPITAL LETTER M
+ 0x4E: [789,50,820,-27,979], // LATIN CAPITAL LETTER N
+ 0x4F: [705,22,796,58,777], // LATIN CAPITAL LETTER O
+ 0x50: [683,57,696,19,733], // LATIN CAPITAL LETTER P
+ 0x51: [705,131,817,114,787], // LATIN CAPITAL LETTER Q
+ 0x52: [682,22,848,19,837], // LATIN CAPITAL LETTER R
+ 0x53: [705,22,606,18,642], // LATIN CAPITAL LETTER S
+ 0x54: [717,68,545,34,833], // LATIN CAPITAL LETTER T
+ 0x55: [683,28,626,-17,687], // LATIN CAPITAL LETTER U
+ 0x56: [683,52,613,25,658], // LATIN CAPITAL LETTER V
+ 0x57: [683,53,988,25,1034], // LATIN CAPITAL LETTER W
+ 0x58: [683,0,713,52,807], // LATIN CAPITAL LETTER X
+ 0x59: [683,143,668,31,714], // LATIN CAPITAL LETTER Y
+ 0x5A: [683,0,725,37,767], // LATIN CAPITAL LETTER Z
+ 0xA0: [0,0,250,0,0] // NO-BREAK SPACE
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Main-Bold'] = {
+ centerline: 342, ascent: 951, descent: 267,
+ weight: 'bold',
+ file: "TeX/Main-Bold.js",
+ Extra: [
+ 0xA0, 0xA8, 0xAC, [0xAF,0xB1], 0xB4, 0xD7, 0xF7,
+ 0x131, 0x237,
+ [0x2C6,0x2CB],[0x2D8,0x2DC],
+ [0x300,0x30C], 0x338,
+ [0x2002,0x2006], 0x2009, 0x200A, 0x2013, 0x2014, 0x2018, 0x2019,
+ 0x201C, 0x201D, 0x2020, 0x2021, 0x2026, 0x2032,
+ 0x20D7,
+ [0x210F,0x2113], 0x2118, 0x211C, 0x2135,
+ [0x2190,0x2199], 0x21A6, 0x21A9, 0x21AA, 0x21BC, 0x21BD, 0x21C0,
+ 0x21C1, 0x21CC, [0x21D0,0x21D5],
+ [0x2200,0x220B], [0x2212,0x221A], [0x221D,0x2220],
+ [0x2223,0x223C], 0x2240, 0x2243, 0x2245, 0x2248, 0x224D, 0x2250,
+ 0x2260, 0x2261, 0x2264, 0x2265, 0x226A, 0x226B, 0x227A, 0x227B,
+ 0x2282, 0x2283, 0x2286, 0x2287, 0x228E, [0x2291,0x2299],
+ [0x22A2,0x22A5], 0x22A8, [0x22C4,0x22C8], [0x22EE,0x22F1],
+ [0x2308,0x230B], 0x2322, 0x2323,
+ 0x25B3, 0x25B9, 0x25BD, 0x25C3, 0x25EF,
+ [0x2660,0x2663], [0x266D,0x266F],
+ 0x27E8, 0x27E9,
+ [0x27F5,0x27FC],
+ 0x2A3F, 0x2AAF, 0x2AB0
+ ],
+ skew: {
+ 0x131: 0.0319,
+ 0x237: 0.0958,
+ 0x210F: -0.0319,
+ 0x2113: 0.128,
+ 0x2202: 0.0958
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [705,-1,350,89,260], // EXCLAMATION MARK
+ 0x22: [694,-329,603,38,492], // QUOTATION MARK
+ 0x23: [694,193,958,64,893], // NUMBER SIGN
+ 0x24: [750,56,575,64,510], // DOLLAR SIGN
+ 0x25: [750,56,958,65,893], // PERCENT SIGN
+ 0x26: [705,11,894,48,836], // AMPERSAND
+ 0x27: [694,-329,319,74,261], // APOSTROPHE
+ 0x28: [750,249,447,103,382], // LEFT PARENTHESIS
+ 0x29: [750,249,447,64,343], // RIGHT PARENTHESIS
+ 0x2A: [750,-306,575,73,501], // ASTERISK
+ 0x2B: [633,131,894,64,829], // PLUS SIGN
+ 0x2C: [171,194,319,74,258], // COMMA
+ 0x2D: [278,-166,383,13,318], // HYPHEN-MINUS
+ 0x2E: [171,-1,319,74,245], // FULL STOP
+ 0x2F: [750,250,575,63,511], // SOLIDUS
+ 0x30: [654,10,575,45,529], // DIGIT ZERO
+ 0x31: [655,0,575,80,494], // DIGIT ONE
+ 0x32: [654,0,575,57,517], // DIGIT TWO
+ 0x33: [655,11,575,47,526], // DIGIT THREE
+ 0x34: [656,0,575,32,542], // DIGIT FOUR
+ 0x35: [655,11,575,57,517], // DIGIT FIVE
+ 0x36: [655,11,575,48,526], // DIGIT SIX
+ 0x37: [676,11,575,64,558], // DIGIT SEVEN
+ 0x38: [654,11,575,48,526], // DIGIT EIGHT
+ 0x39: [654,11,575,48,526], // DIGIT NINE
+ 0x3A: [444,-1,319,74,245], // COLON
+ 0x3B: [444,194,319,74,248], // SEMICOLON
+ 0x3C: [587,85,894,96,797], // LESS-THAN SIGN
+ 0x3D: [393,-109,894,64,829], // EQUALS SIGN
+ 0x3E: [587,85,894,96,797], // GREATER-THAN SIGN
+ 0x3F: [700,-1,543,65,478], // QUESTION MARK
+ 0x40: [699,6,894,64,829], // COMMERCIAL AT
+ 0x41: [698,0,869,40,828], // LATIN CAPITAL LETTER A
+ 0x42: [686,0,818,39,752], // LATIN CAPITAL LETTER B
+ 0x43: [697,11,831,64,766], // LATIN CAPITAL LETTER C
+ 0x44: [686,0,882,39,817], // LATIN CAPITAL LETTER D
+ 0x45: [680,0,756,39,723], // LATIN CAPITAL LETTER E
+ 0x46: [680,0,724,39,675], // LATIN CAPITAL LETTER F
+ 0x47: [697,10,904,64,845], // LATIN CAPITAL LETTER G
+ 0x48: [686,0,900,39,860], // LATIN CAPITAL LETTER H
+ 0x49: [686,0,436,25,410], // LATIN CAPITAL LETTER I
+ 0x4A: [686,11,594,8,527], // LATIN CAPITAL LETTER J
+ 0x4B: [686,0,901,39,852], // LATIN CAPITAL LETTER K
+ 0x4C: [686,0,692,39,643], // LATIN CAPITAL LETTER L
+ 0x4D: [686,0,1092,39,1052], // LATIN CAPITAL LETTER M
+ 0x4E: [686,0,900,39,860], // LATIN CAPITAL LETTER N
+ 0x4F: [696,10,864,64,798], // LATIN CAPITAL LETTER O
+ 0x50: [686,0,786,39,721], // LATIN CAPITAL LETTER P
+ 0x51: [696,193,864,64,805], // LATIN CAPITAL LETTER Q
+ 0x52: [686,11,862,39,858], // LATIN CAPITAL LETTER R
+ 0x53: [697,11,639,64,574], // LATIN CAPITAL LETTER S
+ 0x54: [675,0,800,41,758], // LATIN CAPITAL LETTER T
+ 0x55: [686,11,885,39,845], // LATIN CAPITAL LETTER U
+ 0x56: [686,7,869,25,843], // LATIN CAPITAL LETTER V
+ 0x57: [686,7,1189,24,1164], // LATIN CAPITAL LETTER W
+ 0x58: [686,0,869,33,835], // LATIN CAPITAL LETTER X
+ 0x59: [686,0,869,19,849], // LATIN CAPITAL LETTER Y
+ 0x5A: [686,0,703,64,645], // LATIN CAPITAL LETTER Z
+ 0x5B: [750,250,319,128,293], // LEFT SQUARE BRACKET
+ 0x5C: [750,250,575,63,511], // REVERSE SOLIDUS
+ 0x5D: [750,250,319,25,190], // RIGHT SQUARE BRACKET
+ 0x5E: [694,-520,575,126,448], // CIRCUMFLEX ACCENT
+ 0x5F: [-10,61,575,0,574], // LOW LINE
+ 0x60: [706,-503,575,114,338], // GRAVE ACCENT
+ 0x61: [453,6,559,32,558], // LATIN SMALL LETTER A
+ 0x62: [694,6,639,29,600], // LATIN SMALL LETTER B
+ 0x63: [453,6,511,39,478], // LATIN SMALL LETTER C
+ 0x64: [694,6,639,38,609], // LATIN SMALL LETTER D
+ 0x65: [452,6,527,32,494], // LATIN SMALL LETTER E
+ 0x66: [700,0,351,40,452], // LATIN SMALL LETTER F
+ 0x67: [455,201,575,30,558], // LATIN SMALL LETTER G
+ 0x68: [694,0,639,37,623], // LATIN SMALL LETTER H
+ 0x69: [695,0,319,40,294], // LATIN SMALL LETTER I
+ 0x6A: [695,200,351,-71,274], // LATIN SMALL LETTER J
+ 0x6B: [694,0,607,29,587], // LATIN SMALL LETTER K
+ 0x6C: [694,0,319,40,301], // LATIN SMALL LETTER L
+ 0x6D: [450,0,958,37,942], // LATIN SMALL LETTER M
+ 0x6E: [450,0,639,37,623], // LATIN SMALL LETTER N
+ 0x6F: [452,5,575,32,542], // LATIN SMALL LETTER O
+ 0x70: [450,194,639,29,600], // LATIN SMALL LETTER P
+ 0x71: [450,194,607,38,609], // LATIN SMALL LETTER Q
+ 0x72: [450,0,474,29,442], // LATIN SMALL LETTER R
+ 0x73: [453,6,454,38,414], // LATIN SMALL LETTER S
+ 0x74: [635,5,447,21,382], // LATIN SMALL LETTER T
+ 0x75: [450,6,639,37,623], // LATIN SMALL LETTER U
+ 0x76: [444,3,607,26,580], // LATIN SMALL LETTER V
+ 0x77: [444,4,831,25,805], // LATIN SMALL LETTER W
+ 0x78: [444,0,607,21,586], // LATIN SMALL LETTER X
+ 0x79: [444,200,607,23,580], // LATIN SMALL LETTER Y
+ 0x7A: [444,0,511,32,462], // LATIN SMALL LETTER Z
+ 0x7B: [750,250,575,70,504], // LEFT CURLY BRACKET
+ 0x7C: [750,249,319,129,190], // VERTICAL LINE
+ 0x7D: [750,250,575,70,504], // RIGHT CURLY BRACKET
+ 0x7E: [344,-202,575,96,478], // TILDE
+ 0x393: [680,0,692,39,643], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [698,0,958,56,901], // GREEK CAPITAL LETTER DELTA
+ 0x398: [696,10,894,64,829], // GREEK CAPITAL LETTER THETA
+ 0x39B: [698,0,806,40,765], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [675,0,767,48,718], // GREEK CAPITAL LETTER XI
+ 0x3A0: [680,0,900,39,860], // GREEK CAPITAL LETTER PI
+ 0x3A3: [686,0,831,63,766], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [697,0,894,64,829], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [686,0,831,64,766], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [686,0,894,64,829], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [696,0,831,51,779] // GREEK CAPITAL LETTER OMEGA
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Main-Italic'] = {
+ centerline: 250, ascent: 750, descent: 250,
+ style: 'italic',
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [716,0,307,107,380], // EXCLAMATION MARK
+ 0x22: [694,-379,514,176,538], // QUOTATION MARK
+ 0x23: [694,194,818,115,828], // NUMBER SIGN
+ 0x25: [750,56,818,145,847], // PERCENT SIGN
+ 0x26: [716,22,767,127,802], // AMPERSAND
+ 0x27: [694,-379,307,213,377], // APOSTROPHE
+ 0x28: [750,250,409,144,517], // LEFT PARENTHESIS
+ 0x29: [750,250,409,17,390], // RIGHT PARENTHESIS
+ 0x2A: [750,-320,511,195,584], // ASTERISK
+ 0x2B: [557,57,767,139,753], // PLUS SIGN
+ 0x2C: [121,194,307,69,232], // COMMA
+ 0x2D: [251,-180,358,84,341], // HYPHEN-MINUS
+ 0x2E: [121,0,307,107,231], // FULL STOP
+ 0x2F: [750,250,511,19,617], // SOLIDUS
+ 0x30: [665,21,511,110,562], // DIGIT ZERO
+ 0x31: [666,0,511,110,468], // DIGIT ONE
+ 0x32: [666,22,511,76,551], // DIGIT TWO
+ 0x33: [666,22,511,96,562], // DIGIT THREE
+ 0x34: [666,194,511,46,478], // DIGIT FOUR
+ 0x35: [666,22,511,106,567], // DIGIT FIVE
+ 0x36: [665,22,511,120,565], // DIGIT SIX
+ 0x37: [666,22,511,136,634], // DIGIT SEVEN
+ 0x38: [666,21,511,99,553], // DIGIT EIGHT
+ 0x39: [666,22,511,107,553], // DIGIT NINE
+ 0x3A: [431,0,307,107,308], // COLON
+ 0x3B: [431,194,307,70,308], // SEMICOLON
+ 0x3D: [367,-133,767,116,776], // EQUALS SIGN
+ 0x3F: [716,0,511,195,551], // QUESTION MARK
+ 0x40: [705,11,767,152,789], // COMMERCIAL AT
+ 0x41: [716,0,743,58,696], // LATIN CAPITAL LETTER A
+ 0x42: [683,0,704,57,732], // LATIN CAPITAL LETTER B
+ 0x43: [705,21,716,150,812], // LATIN CAPITAL LETTER C
+ 0x44: [683,0,755,56,775], // LATIN CAPITAL LETTER D
+ 0x45: [680,0,678,54,743], // LATIN CAPITAL LETTER E
+ 0x46: [680,-1,653,54,731], // LATIN CAPITAL LETTER F
+ 0x47: [705,22,774,150,812], // LATIN CAPITAL LETTER G
+ 0x48: [683,0,743,54,860], // LATIN CAPITAL LETTER H
+ 0x49: [683,0,386,49,508], // LATIN CAPITAL LETTER I
+ 0x4A: [683,21,525,78,622], // LATIN CAPITAL LETTER J
+ 0x4B: [683,0,769,54,859], // LATIN CAPITAL LETTER K
+ 0x4C: [683,0,627,54,628], // LATIN CAPITAL LETTER L
+ 0x4D: [683,0,897,58,1010], // LATIN CAPITAL LETTER M
+ 0x4E: [683,0,743,54,860], // LATIN CAPITAL LETTER N
+ 0x4F: [704,22,767,149,788], // LATIN CAPITAL LETTER O
+ 0x50: [683,0,678,55,729], // LATIN CAPITAL LETTER P
+ 0x51: [704,194,767,149,788], // LATIN CAPITAL LETTER Q
+ 0x52: [683,22,729,55,723], // LATIN CAPITAL LETTER R
+ 0x53: [705,22,562,74,633], // LATIN CAPITAL LETTER S
+ 0x54: [677,0,716,171,806], // LATIN CAPITAL LETTER T
+ 0x55: [683,22,743,194,860], // LATIN CAPITAL LETTER U
+ 0x56: [683,22,743,205,868], // LATIN CAPITAL LETTER V
+ 0x57: [683,22,999,205,1124], // LATIN CAPITAL LETTER W
+ 0x58: [683,0,743,50,825], // LATIN CAPITAL LETTER X
+ 0x59: [683,0,743,198,875], // LATIN CAPITAL LETTER Y
+ 0x5A: [683,0,613,80,704], // LATIN CAPITAL LETTER Z
+ 0x5B: [750,250,307,73,446], // LEFT SQUARE BRACKET
+ 0x5D: [750,250,307,-14,359], // RIGHT SQUARE BRACKET
+ 0x5E: [694,-527,511,260,528], // CIRCUMFLEX ACCENT
+ 0x5F: [-25,62,511,91,554], // LOW LINE
+ 0x61: [442,11,511,101,543], // LATIN SMALL LETTER A
+ 0x62: [694,11,460,108,467], // LATIN SMALL LETTER B
+ 0x63: [441,10,460,103,469], // LATIN SMALL LETTER C
+ 0x64: [694,11,511,101,567], // LATIN SMALL LETTER D
+ 0x65: [442,10,460,107,470], // LATIN SMALL LETTER E
+ 0x66: [705,204,307,-23,450], // LATIN SMALL LETTER F
+ 0x67: [442,205,460,46,494], // LATIN SMALL LETTER G
+ 0x68: [694,11,511,69,544], // LATIN SMALL LETTER H
+ 0x69: [656,10,307,75,340], // LATIN SMALL LETTER I
+ 0x6A: [656,204,307,-32,364], // LATIN SMALL LETTER J
+ 0x6B: [694,11,460,69,498], // LATIN SMALL LETTER K
+ 0x6C: [694,11,256,87,312], // LATIN SMALL LETTER L
+ 0x6D: [442,11,818,75,851], // LATIN SMALL LETTER M
+ 0x6E: [442,11,562,75,595], // LATIN SMALL LETTER N
+ 0x6F: [442,11,511,103,517], // LATIN SMALL LETTER O
+ 0x70: [442,194,511,6,518], // LATIN SMALL LETTER P
+ 0x71: [442,194,460,101,504], // LATIN SMALL LETTER Q
+ 0x72: [442,11,422,75,484], // LATIN SMALL LETTER R
+ 0x73: [442,11,409,76,418], // LATIN SMALL LETTER S
+ 0x74: [626,11,332,87,373], // LATIN SMALL LETTER T
+ 0x75: [441,11,537,75,570], // LATIN SMALL LETTER U
+ 0x76: [443,10,460,75,492], // LATIN SMALL LETTER V
+ 0x77: [443,11,664,75,696], // LATIN SMALL LETTER W
+ 0x78: [442,11,464,58,513], // LATIN SMALL LETTER X
+ 0x79: [441,205,486,75,522], // LATIN SMALL LETTER Y
+ 0x7A: [442,11,409,54,466], // LATIN SMALL LETTER Z
+ 0x7E: [318,-208,511,246,571], // TILDE
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0xA3: [714,11,769,88,699], // POUND SIGN
+ 0x131: [441,10,307,75,340], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [442,204,332,-32,327], // LATIN SMALL LETTER DOTLESS J
+ 0x300: [697,-500,0,-222,-74], // COMBINING GRAVE ACCENT
+ 0x301: [697,-500,0,-173,39], // COMBINING ACUTE ACCENT
+ 0x302: [694,-527,0,-251,17], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [668,-558,0,-265,60], // COMBINING TILDE
+ 0x304: [589,-544,0,-282,54], // COMBINING MACRON
+ 0x306: [694,-515,0,-237,62], // COMBINING BREVE
+ 0x307: [669,-548,0,-165,-41], // COMBINING DOT ABOVE
+ 0x308: [669,-554,0,-251,45], // COMBINING DIAERESIS
+ 0x30A: [716,-542,0,-199,3], // COMBINING RING ABOVE
+ 0x30B: [697,-503,0,-248,65], // COMBINING DOUBLE ACUTE ACCENT
+ 0x30C: [638,-502,0,-236,29], // COMBINING CARON
+ 0x393: [680,0,627,54,705], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [716,0,818,70,751], // GREEK CAPITAL LETTER DELTA
+ 0x398: [704,22,767,149,788], // GREEK CAPITAL LETTER THETA
+ 0x39B: [716,0,692,58,646], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [677,0,664,74,754], // GREEK CAPITAL LETTER XI
+ 0x3A0: [680,0,743,54,859], // GREEK CAPITAL LETTER PI
+ 0x3A3: [683,0,716,80,782], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [705,0,767,213,832], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [683,0,716,159,728], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [683,0,767,207,824], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [705,0,716,100,759], // GREEK CAPITAL LETTER OMEGA
+ 0x2013: [285,-248,511,91,554], // EN DASH
+ 0x2014: [285,-248,1022,117,1038], // EM DASH
+ 0x2018: [694,-379,307,197,362], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [694,-379,307,213,377], // RIGHT SINGLE QUOTATION MARK
+ 0x201C: [694,-379,514,243,606], // LEFT DOUBLE QUOTATION MARK
+ 0x201D: [694,-379,514,176,538], // RIGHT DOUBLE QUOTATION MARK
+ 0x210F: [695,13,540,42,562] // stix-/hbar - Planck's over 2pi
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Main'] = {
+ centerline: 314, ascent: 900, descent: 272,
+ skew: {
+ 0x131: 0.0278,
+ 0x237: 0.0833,
+ 0x2113: 0.111,
+ 0x2118: 0.111,
+ 0x2202: 0.0833
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x21: [716,-1,278,78,199], // EXCLAMATION MARK
+ 0x22: [694,-379,500,34,372], // QUOTATION MARK
+ 0x23: [694,194,833,56,777], // NUMBER SIGN
+ 0x24: [750,56,500,55,444], // DOLLAR SIGN
+ 0x25: [750,56,833,56,776], // PERCENT SIGN
+ 0x26: [716,22,778,42,727], // AMPERSAND
+ 0x27: [694,-379,278,78,212], // APOSTROPHE
+ 0x28: [750,250,389,94,333], // LEFT PARENTHESIS
+ 0x29: [750,250,389,55,294], // RIGHT PARENTHESIS
+ 0x2A: [750,-320,500,64,435], // ASTERISK
+ 0x2B: [583,82,778,56,722], // PLUS SIGN
+ 0x2C: [121,194,278,78,210], // COMMA
+ 0x2D: [252,-179,333,11,277], // HYPHEN-MINUS
+ 0x2E: [120,0,278,78,199], // FULL STOP
+ 0x2F: [750,250,500,56,445], // SOLIDUS
+ 0x30: [666,22,500,39,460], // DIGIT ZERO
+ 0x31: [666,0,500,83,427], // DIGIT ONE
+ 0x32: [666,0,500,50,449], // DIGIT TWO
+ 0x33: [665,22,500,42,457], // DIGIT THREE
+ 0x34: [677,0,500,28,471], // DIGIT FOUR
+ 0x35: [666,22,500,50,449], // DIGIT FIVE
+ 0x36: [666,22,500,42,456], // DIGIT SIX
+ 0x37: [676,22,500,55,485], // DIGIT SEVEN
+ 0x38: [666,22,500,43,457], // DIGIT EIGHT
+ 0x39: [666,22,500,42,456], // DIGIT NINE
+ 0x3A: [430,0,278,78,199], // COLON
+ 0x3B: [430,194,278,78,202], // SEMICOLON
+ 0x3C: [540,40,778,83,694], // LESS-THAN SIGN
+ 0x3D: [367,-133,778,56,722], // EQUALS SIGN
+ 0x3E: [540,40,778,83,694], // GREATER-THAN SIGN
+ 0x3F: [705,-1,472,55,416], // QUESTION MARK
+ 0x40: [705,11,778,56,722], // COMMERCIAL AT
+ 0x41: [716,0,750,32,717], // LATIN CAPITAL LETTER A
+ 0x42: [683,0,708,28,651], // LATIN CAPITAL LETTER B
+ 0x43: [705,21,722,56,666], // LATIN CAPITAL LETTER C
+ 0x44: [683,0,764,27,708], // LATIN CAPITAL LETTER D
+ 0x45: [680,0,681,25,652], // LATIN CAPITAL LETTER E
+ 0x46: [680,0,653,25,610], // LATIN CAPITAL LETTER F
+ 0x47: [705,22,785,56,735], // LATIN CAPITAL LETTER G
+ 0x48: [683,0,750,25,724], // LATIN CAPITAL LETTER H
+ 0x49: [683,0,361,21,339], // LATIN CAPITAL LETTER I
+ 0x4A: [683,22,514,25,465], // LATIN CAPITAL LETTER J
+ 0x4B: [683,0,778,25,736], // LATIN CAPITAL LETTER K
+ 0x4C: [683,0,625,25,582], // LATIN CAPITAL LETTER L
+ 0x4D: [683,0,917,29,887], // LATIN CAPITAL LETTER M
+ 0x4E: [683,0,750,25,724], // LATIN CAPITAL LETTER N
+ 0x4F: [705,22,778,56,722], // LATIN CAPITAL LETTER O
+ 0x50: [683,0,681,27,624], // LATIN CAPITAL LETTER P
+ 0x51: [705,193,778,56,728], // LATIN CAPITAL LETTER Q
+ 0x52: [683,22,736,27,732], // LATIN CAPITAL LETTER R
+ 0x53: [705,22,556,55,500], // LATIN CAPITAL LETTER S
+ 0x54: [677,0,722,36,685], // LATIN CAPITAL LETTER T
+ 0x55: [683,22,750,25,724], // LATIN CAPITAL LETTER U
+ 0x56: [683,22,750,19,730], // LATIN CAPITAL LETTER V
+ 0x57: [683,22,1028,18,1009], // LATIN CAPITAL LETTER W
+ 0x58: [683,0,750,23,726], // LATIN CAPITAL LETTER X
+ 0x59: [683,0,750,11,738], // LATIN CAPITAL LETTER Y
+ 0x5A: [683,0,611,55,560], // LATIN CAPITAL LETTER Z
+ 0x5B: [750,250,278,118,255], // LEFT SQUARE BRACKET
+ 0x5C: [750,250,500,56,444], // REVERSE SOLIDUS
+ 0x5D: [750,250,278,22,159], // RIGHT SQUARE BRACKET
+ 0x5E: [694,-531,500,112,387], // CIRCUMFLEX ACCENT
+ 0x5F: [-25,62,500,0,499], // LOW LINE
+ 0x60: [699,-505,500,106,295], // GRAVE ACCENT
+ 0x61: [448,11,500,34,493], // LATIN SMALL LETTER A
+ 0x62: [694,11,556,20,522], // LATIN SMALL LETTER B
+ 0x63: [448,11,444,34,415], // LATIN SMALL LETTER C
+ 0x64: [694,11,556,34,535], // LATIN SMALL LETTER D
+ 0x65: [448,11,444,28,415], // LATIN SMALL LETTER E
+ 0x66: [705,0,306,26,372], // LATIN SMALL LETTER F
+ 0x67: [453,206,500,29,485], // LATIN SMALL LETTER G
+ 0x68: [694,0,556,25,542], // LATIN SMALL LETTER H
+ 0x69: [669,0,278,26,255], // LATIN SMALL LETTER I
+ 0x6A: [669,205,306,-55,218], // LATIN SMALL LETTER J
+ 0x6B: [694,0,528,20,511], // LATIN SMALL LETTER K
+ 0x6C: [694,0,278,26,263], // LATIN SMALL LETTER L
+ 0x6D: [442,0,833,25,819], // LATIN SMALL LETTER M
+ 0x6E: [442,0,556,25,542], // LATIN SMALL LETTER N
+ 0x6F: [448,10,500,28,471], // LATIN SMALL LETTER O
+ 0x70: [442,194,556,20,522], // LATIN SMALL LETTER P
+ 0x71: [442,194,528,33,535], // LATIN SMALL LETTER Q
+ 0x72: [442,0,392,20,364], // LATIN SMALL LETTER R
+ 0x73: [448,11,394,33,359], // LATIN SMALL LETTER S
+ 0x74: [615,10,389,18,333], // LATIN SMALL LETTER T
+ 0x75: [442,11,556,25,542], // LATIN SMALL LETTER U
+ 0x76: [431,11,528,19,508], // LATIN SMALL LETTER V
+ 0x77: [431,11,722,18,703], // LATIN SMALL LETTER W
+ 0x78: [431,0,528,11,516], // LATIN SMALL LETTER X
+ 0x79: [431,204,528,19,508], // LATIN SMALL LETTER Y
+ 0x7A: [431,0,444,28,401], // LATIN SMALL LETTER Z
+ 0x7B: [750,250,500,65,434], // LEFT CURLY BRACKET
+ 0x7C: [750,249,278,119,159], // VERTICAL LINE
+ 0x7D: [750,250,500,65,434], // RIGHT CURLY BRACKET
+ 0x7E: [318,-215,500,83,416], // TILDE
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0xA8: [669,-554,500,95,404], // DIAERESIS
+ 0xAC: [356,-89,667,56,611], // NOT SIGN
+ 0xAF: [590,-544,500,69,430], // MACRON
+ 0xB0: [715,-542,500,147,352], // DEGREE SIGN
+ 0xB1: [666,0,778,56,722], // PLUS-MINUS SIGN
+ 0xB4: [699,-505,500,203,393], // ACUTE ACCENT
+ 0xD7: [491,-9,778,147,630], // MULTIPLICATION SIGN
+ 0xF7: [537,36,778,56,721], // DIVISION SIGN
+ 0x131: [442,0,278,26,255], // LATIN SMALL LETTER DOTLESS I
+ 0x237: [442,205,306,-55,218], // LATIN SMALL LETTER DOTLESS J
+ 0x2C6: [694,-531,500,112,387], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2C7: [644,-513,500,114,385], // CARON
+ 0x2C9: [590,-544,500,69,430], // MODIFIER LETTER MACRON
+ 0x2CA: [699,-505,500,203,393], // MODIFIER LETTER ACUTE ACCENT
+ 0x2CB: [699,-505,500,106,295], // MODIFIER LETTER GRAVE ACCENT
+ 0x2D8: [694,-515,500,92,407], // BREVE
+ 0x2D9: [669,-549,500,190,309], // DOT ABOVE
+ 0x2DC: [668,-565,500,83,416], // SMALL TILDE
+ 0x2DA: [715,-542,500,147,352], // RING ABOVE
+ 0x300: [699,-505,0,-394,-205], // COMBINING GRAVE ACCENT
+ 0x301: [699,-505,0,-297,-107], // COMBINING ACUTE ACCENT
+ 0x302: [694,-531,0,-388,-113], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [668,-565,0,-417,-84], // COMBINING TILDE
+ 0x304: [590,-544,0,-431,-70], // COMBINING MACRON
+ 0x306: [694,-515,0,-408,-93], // COMBINING BREVE
+ 0x307: [669,-549,0,-310,-191], // COMBINING DOT ABOVE
+ 0x308: [669,-554,0,-405,-96], // COMBINING DIAERESIS
+ 0x30A: [715,-542,0,-353,-148], // COMBINING RING ABOVE
+ 0x30B: [701,-510,0,-378,-80], // COMBINING DOUBLE ACUTE ACCENT
+ 0x30C: [644,-513,0,-386,-115], // COMBINING CARON
+ 0x338: [716,215,0,-639,-140], // COMBINING LONG SOLIDUS OVERLAY
+ 0x393: [680,0,625,25,582], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [716,0,833,46,786], // GREEK CAPITAL LETTER DELTA
+ 0x398: [705,22,778,56,722], // GREEK CAPITAL LETTER THETA
+ 0x39B: [716,0,694,32,661], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [677,0,667,42,624], // GREEK CAPITAL LETTER XI
+ 0x3A0: [680,0,750,25,724], // GREEK CAPITAL LETTER PI
+ 0x3A3: [683,0,722,55,666], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [705,0,778,55,722], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [683,0,722,56,665], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [683,0,778,55,722], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [704,0,722,44,677], // GREEK CAPITAL LETTER OMEGA
+ 0x2002: [0,0,500,0,0], // ??
+ 0x2003: [0,0,999,0,0], // ??
+ 0x2004: [0,0,333,0,0], // ??
+ 0x2005: [0,0,250,0,0], // ??
+ 0x2006: [0,0,167,0,0], // ??
+ 0x2009: [0,0,167,0,0], // ??
+ 0x200A: [0,0,83,0,0], // ??
+ 0x2013: [285,-248,500,0,499], // EN DASH
+ 0x2014: [285,-248,1000,0,999], // EM DASH
+ 0x2018: [694,-379,278,64,198], // LEFT SINGLE QUOTATION MARK
+ 0x2019: [694,-379,278,78,212], // RIGHT SINGLE QUOTATION MARK
+ 0x201C: [694,-379,500,128,466], // LEFT DOUBLE QUOTATION MARK
+ 0x201D: [694,-379,500,34,372], // RIGHT DOUBLE QUOTATION MARK
+ 0x2020: [705,216,444,55,389], // DAGGER
+ 0x2021: [705,205,444,55,389], // DOUBLE DAGGER
+ 0x2026: [120,0,1172,78,1093], // HORIZONTAL ELLIPSIS
+ 0x2032: [560,-43,275,30,262], // PRIME
+ 0x20D7: [714,-516,0,-471,-29], // COMBINING RIGHT ARROW ABOVE
+ 0x210F: [695,13,540,42,562], // stix-/hbar - Planck's over 2pi
+ 0x2111: [705,10,722,55,693], // BLACK-LETTER CAPITAL I
+ 0x2113: [705,20,417,6,397], // SCRIPT SMALL L
+ 0x2118: [453,216,636,67,625], // SCRIPT CAPITAL P
+ 0x211C: [716,22,722,40,715], // BLACK-LETTER CAPITAL R
+ 0x2135: [694,0,611,55,555], // ALEF SYMBOL
+ 0x2190: [511,11,1000,55,944], // LEFTWARDS ARROW
+ 0x2191: [694,193,500,17,483], // UPWARDS ARROW
+ 0x2192: [511,11,1000,56,944], // RIGHTWARDS ARROW
+ 0x2193: [694,194,500,17,483], // DOWNWARDS ARROW
+ 0x2194: [511,11,1000,55,944], // LEFT RIGHT ARROW
+ 0x2195: [772,272,500,17,483], // UP DOWN ARROW
+ 0x2196: [720,195,1000,29,944], // NORTH WEST ARROW
+ 0x2197: [720,195,1000,55,970], // NORTH EAST ARROW
+ 0x2198: [695,220,1000,55,970], // SOUTH EAST ARROW
+ 0x2199: [695,220,1000,29,944], // SOUTH WEST ARROW
+ 0x21A6: [511,11,1000,55,944], // RIGHTWARDS ARROW FROM BAR
+ 0x21A9: [511,11,1126,55,1070], // LEFTWARDS ARROW WITH HOOK
+ 0x21AA: [511,11,1126,55,1070], // RIGHTWARDS ARROW WITH HOOK
+ 0x21BC: [511,-230,1000,55,944], // LEFTWARDS HARPOON WITH BARB UPWARDS
+ 0x21BD: [270,11,1000,55,944], // LEFTWARDS HARPOON WITH BARB DOWNWARDS
+ 0x21C0: [511,-230,1000,56,944], // RIGHTWARDS HARPOON WITH BARB UPWARDS
+ 0x21C1: [270,11,1000,56,944], // RIGHTWARDS HARPOON WITH BARB DOWNWARDS
+ 0x21CC: [671,11,1000,55,944], // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+ 0x21D0: [525,24,1000,56,944], // LEFTWARDS DOUBLE ARROW
+ 0x21D1: [694,194,611,31,579], // UPWARDS DOUBLE ARROW
+ 0x21D2: [525,24,1000,56,944], // RIGHTWARDS DOUBLE ARROW
+ 0x21D3: [694,194,611,31,579], // DOWNWARDS DOUBLE ARROW
+ 0x21D4: [526,25,1000,34,966], // LEFT RIGHT DOUBLE ARROW
+ 0x21D5: [772,272,611,31,579], // UP DOWN DOUBLE ARROW
+ 0x2200: [694,22,556,0,556], // FOR ALL
+ 0x2202: [715,22,531,42,566], // PARTIAL DIFFERENTIAL
+ 0x2203: [694,0,556,56,500], // THERE EXISTS
+ 0x2205: [772,78,500,39,460], // EMPTY SET
+ 0x2207: [683,33,833,46,786], // NABLA
+ 0x2208: [540,40,667,84,583], // ELEMENT OF
+ 0x2209: [716,215,667,84,583], // stix-negated (vert) set membership, variant
+ 0x220B: [540,40,667,83,582], // CONTAINS AS MEMBER
+ 0x2212: [270,-230,778,84,694], // MINUS SIGN
+ 0x2213: [500,166,778,56,722], // MINUS-OR-PLUS SIGN
+ 0x2215: [750,250,500,56,445], // DIVISION SLASH
+ 0x2216: [750,250,500,56,444], // SET MINUS
+ 0x2217: [465,-35,500,64,435], // ASTERISK OPERATOR
+ 0x2218: [444,-55,500,55,444], // RING OPERATOR
+ 0x2219: [444,-55,500,55,444], // BULLET OPERATOR
+ 0x221A: [800,200,833,72,853], // SQUARE ROOT
+ 0x221D: [442,11,778,56,722], // PROPORTIONAL TO
+ 0x221E: [442,11,1000,55,944], // INFINITY
+ 0x2220: [694,0,722,55,666], // ANGLE
+ 0x2223: [750,249,278,119,159], // DIVIDES
+ 0x2225: [750,250,500,132,367], // PARALLEL TO
+ 0x2227: [598,22,667,55,611], // LOGICAL AND
+ 0x2228: [598,22,667,55,611], // LOGICAL OR
+ 0x2229: [598,22,667,55,611], // stix-intersection, serifs
+ 0x222A: [598,22,667,55,611], // stix-union, serifs
+ 0x222B: [716,216,417,55,472], // INTEGRAL
+ 0x223C: [367,-133,778,55,722], // TILDE OPERATOR
+ 0x2240: [583,83,278,55,222], // WREATH PRODUCT
+ 0x2243: [464,-36,778,55,722], // ASYMPTOTICALLY EQUAL TO
+ 0x2245: [589,-22,1000,55,722], // APPROXIMATELY EQUAL TO
+ 0x2248: [483,-55,778,55,722], // ALMOST EQUAL TO
+ 0x224D: [484,-16,778,55,722], // EQUIVALENT TO
+ 0x2250: [670,-133,778,56,722], // APPROACHES THE LIMIT
+ 0x2260: [716,215,778,56,722], // stix-not (vert) equals
+ 0x2261: [464,-36,778,56,722], // IDENTICAL TO
+ 0x2264: [636,138,778,83,694], // LESS-THAN OR EQUAL TO
+ 0x2265: [636,138,778,83,694], // GREATER-THAN OR EQUAL TO
+ 0x226A: [568,67,1000,56,944], // MUCH LESS-THAN
+ 0x226B: [567,67,1000,55,944], // MUCH GREATER-THAN
+ 0x227A: [539,41,778,84,694], // PRECEDES
+ 0x227B: [539,41,778,83,694], // SUCCEEDS
+ 0x2282: [540,40,778,84,694], // SUBSET OF
+ 0x2283: [540,40,778,83,693], // SUPERSET OF
+ 0x2286: [636,138,778,84,694], // SUBSET OF OR EQUAL TO
+ 0x2287: [636,138,778,83,693], // SUPERSET OF OR EQUAL TO
+ 0x228E: [598,22,667,55,611], // MULTISET UNION
+ 0x2291: [636,138,778,84,714], // SQUARE IMAGE OF OR EQUAL TO
+ 0x2292: [636,138,778,64,694], // SQUARE ORIGINAL OF OR EQUAL TO
+ 0x2293: [598,0,667,61,605], // stix-square intersection, serifs
+ 0x2294: [598,0,667,61,605], // stix-square union, serifs
+ 0x2295: [583,83,778,56,722], // stix-circled plus (with rim)
+ 0x2296: [583,83,778,56,722], // CIRCLED MINUS
+ 0x2297: [583,83,778,56,722], // stix-circled times (with rim)
+ 0x2298: [583,83,778,56,722], // CIRCLED DIVISION SLASH
+ 0x2299: [583,83,778,56,722], // CIRCLED DOT OPERATOR
+ 0x22A2: [694,0,611,55,555], // RIGHT TACK
+ 0x22A3: [694,0,611,55,555], // LEFT TACK
+ 0x22A4: [668,0,778,55,723], // DOWN TACK
+ 0x22A5: [668,0,778,55,723], // UP TACK
+ 0x22A8: [750,249,867,119,811], // TRUE
+ 0x22C4: [488,-12,500,12,488], // DIAMOND OPERATOR
+ 0x22C5: [310,-190,278,78,199], // DOT OPERATOR
+ 0x22C6: [486,-16,500,3,497], // STAR OPERATOR
+ 0x22C8: [505,5,900,26,873], // BOWTIE
+ 0x22EE: [900,30,278,78,199], // VERTICAL ELLIPSIS
+ 0x22EF: [310,-190,1172,78,1093], // MIDLINE HORIZONTAL ELLIPSIS
+ 0x22F1: [820,-100,1282,133,1148], // DOWN RIGHT DIAGONAL ELLIPSIS
+ 0x2308: [750,250,444,174,422], // LEFT CEILING
+ 0x2309: [750,250,444,21,269], // RIGHT CEILING
+ 0x230A: [750,250,444,174,422], // LEFT FLOOR
+ 0x230B: [750,250,444,21,269], // RIGHT FLOOR
+ 0x2322: [388,-122,1000,55,944], // stix-small down curve
+ 0x2323: [378,-134,1000,55,944], // stix-small up curve
+ 0x23B0: [744,244,412,55,357], // UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION
+ 0x23B1: [744,244,412,56,357], // UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION
+ 0x25B3: [716,0,889,59,828], // WHITE UP-POINTING TRIANGLE
+ 0x25B9: [505,5,500,26,474], // WHITE RIGHT-POINTING SMALL TRIANGLE
+ 0x25BD: [500,215,889,59,828], // WHITE DOWN-POINTING TRIANGLE
+ 0x25C3: [505,5,500,26,473], // WHITE LEFT-POINTING SMALL TRIANGLE
+ 0x25EF: [715,215,1000,56,944], // LARGE CIRCLE
+ 0x2660: [727,130,778,55,723], // BLACK SPADE SUIT
+ 0x2661: [716,33,778,55,723], // WHITE HEART SUIT
+ 0x2662: [727,162,778,55,723], // WHITE DIAMOND SUIT
+ 0x2663: [726,130,778,28,750], // BLACK CLUB SUIT
+ 0x266D: [750,22,389,55,332], // MUSIC FLAT SIGN
+ 0x266E: [734,223,389,65,324], // MUSIC NATURAL SIGN
+ 0x266F: [723,223,389,55,333], // MUSIC SHARP SIGN
+ 0x27E8: [750,250,389,110,333], // MATHEMATICAL LEFT ANGLE BRACKET
+ 0x27E9: [750,250,389,55,278], // MATHEMATICAL RIGHT ANGLE BRACKET
+ 0x27EE: [744,244,412,173,357], // MATHEMATICAL LEFT FLATTENED PARENTHESIS
+ 0x27EF: [744,244,412,56,240], // MATHEMATICAL RIGHT FLATTENED PARENTHESIS
+ 0x27F5: [511,11,1609,55,1525], // LONG LEFTWARDS ARROW
+ 0x27F6: [511,11,1638,84,1553], // LONG RIGHTWARDS ARROW
+ 0x27F7: [511,11,1859,55,1803], // LONG LEFT RIGHT ARROW
+ 0x27F8: [525,24,1609,56,1553], // LONG LEFTWARDS DOUBLE ARROW
+ 0x27F9: [525,24,1638,56,1582], // LONG RIGHTWARDS DOUBLE ARROW
+ 0x27FA: [525,24,1858,56,1802], // LONG LEFT RIGHT DOUBLE ARROW
+ 0x27FC: [511,11,1638,55,1553], // LONG RIGHTWARDS ARROW FROM BAR
+ 0x2A3F: [683,0,750,28,721], // AMALGAMATION OR COPRODUCT
+ 0x2AAF: [636,138,778,84,694], // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN
+ 0x2AB0: [636,138,778,83,694] // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Math-Italic'] = {
+ centerline: 250, ascent: 717, descent: 218,
+ style: 'italic',
+ skew: {
+ 0x41: 0.139,
+ 0x42: 0.0833,
+ 0x43: 0.0833,
+ 0x44: 0.0556,
+ 0x45: 0.0833,
+ 0x46: 0.0833,
+ 0x47: 0.0833,
+ 0x48: 0.0556,
+ 0x49: 0.111,
+ 0x4A: 0.167,
+ 0x4B: 0.0556,
+ 0x4C: 0.0278,
+ 0x4D: 0.0833,
+ 0x4E: 0.0833,
+ 0x4F: 0.0833,
+ 0x50: 0.0833,
+ 0x51: 0.0833,
+ 0x52: 0.0833,
+ 0x53: 0.0833,
+ 0x54: 0.0833,
+ 0x55: 0.0278,
+ 0x58: 0.0833,
+ 0x5A: 0.0833,
+ 0x63: 0.0556,
+ 0x64: 0.167,
+ 0x65: 0.0556,
+ 0x66: 0.167,
+ 0x67: 0.0278,
+ 0x68: -0.0278,
+ 0x6C: 0.0833,
+ 0x6F: 0.0556,
+ 0x70: 0.0833,
+ 0x71: 0.0833,
+ 0x72: 0.0556,
+ 0x73: 0.0556,
+ 0x74: 0.0833,
+ 0x75: 0.0278,
+ 0x76: 0.0278,
+ 0x77: 0.0833,
+ 0x78: 0.0278,
+ 0x79: 0.0556,
+ 0x7A: 0.0556,
+ 0x393: 0.0833,
+ 0x394: 0.167,
+ 0x398: 0.0833,
+ 0x39B: 0.167,
+ 0x39E: 0.0833,
+ 0x3A0: 0.0556,
+ 0x3A3: 0.0833,
+ 0x3A5: 0.0556,
+ 0x3A6: 0.0833,
+ 0x3A8: 0.0556,
+ 0x3A9: 0.0833,
+ 0x3B1: 0.0278,
+ 0x3B2: 0.0833,
+ 0x3B4: 0.0556,
+ 0x3B5: 0.0833,
+ 0x3B6: 0.0833,
+ 0x3B7: 0.0556,
+ 0x3B8: 0.0833,
+ 0x3B9: 0.0556,
+ 0x3BC: 0.0278,
+ 0x3BD: 0.0278,
+ 0x3BE: 0.111,
+ 0x3BF: 0.0556,
+ 0x3C1: 0.0833,
+ 0x3C2: 0.0833,
+ 0x3C4: 0.0278,
+ 0x3C5: 0.0278,
+ 0x3C6: 0.0833,
+ 0x3C7: 0.0556,
+ 0x3C8: 0.111,
+ 0x3D1: 0.0833,
+ 0x3D5: 0.0833,
+ 0x3F1: 0.0833,
+ 0x3F5: 0.0556
+ },
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x2F: [716,215,778,139,638], // SOLIDUS
+ 0x41: [716,0,750,35,726], // LATIN CAPITAL LETTER A
+ 0x42: [683,0,759,35,756], // LATIN CAPITAL LETTER B
+ 0x43: [705,22,715,50,760], // LATIN CAPITAL LETTER C
+ 0x44: [683,0,828,33,803], // LATIN CAPITAL LETTER D
+ 0x45: [680,0,738,31,764], // LATIN CAPITAL LETTER E
+ 0x46: [680,0,643,31,749], // LATIN CAPITAL LETTER F
+ 0x47: [705,22,786,50,760], // LATIN CAPITAL LETTER G
+ 0x48: [683,0,831,31,888], // LATIN CAPITAL LETTER H
+ 0x49: [683,0,440,26,504], // LATIN CAPITAL LETTER I
+ 0x4A: [683,22,555,57,633], // LATIN CAPITAL LETTER J
+ 0x4B: [683,0,849,31,889], // LATIN CAPITAL LETTER K
+ 0x4C: [683,0,681,32,647], // LATIN CAPITAL LETTER L
+ 0x4D: [683,0,970,35,1051], // LATIN CAPITAL LETTER M
+ 0x4E: [683,0,803,31,888], // LATIN CAPITAL LETTER N
+ 0x4F: [704,22,763,50,740], // LATIN CAPITAL LETTER O
+ 0x50: [683,0,642,33,751], // LATIN CAPITAL LETTER P
+ 0x51: [704,194,791,50,740], // LATIN CAPITAL LETTER Q
+ 0x52: [683,21,759,33,755], // LATIN CAPITAL LETTER R
+ 0x53: [705,22,613,52,645], // LATIN CAPITAL LETTER S
+ 0x54: [677,0,584,21,704], // LATIN CAPITAL LETTER T
+ 0x55: [683,22,683,60,767], // LATIN CAPITAL LETTER U
+ 0x56: [683,22,583,52,769], // LATIN CAPITAL LETTER V
+ 0x57: [683,22,944,51,1048], // LATIN CAPITAL LETTER W
+ 0x58: [683,0,828,26,852], // LATIN CAPITAL LETTER X
+ 0x59: [683,-1,581,30,763], // LATIN CAPITAL LETTER Y
+ 0x5A: [683,0,683,58,723], // LATIN CAPITAL LETTER Z
+ 0x61: [441,10,529,33,506], // LATIN SMALL LETTER A
+ 0x62: [694,11,429,40,422], // LATIN SMALL LETTER B
+ 0x63: [442,11,433,34,429], // LATIN SMALL LETTER C
+ 0x64: [694,10,520,33,523], // LATIN SMALL LETTER D
+ 0x65: [442,11,466,39,429], // LATIN SMALL LETTER E
+ 0x66: [705,205,490,55,550], // LATIN SMALL LETTER F
+ 0x67: [442,205,477,10,480], // LATIN SMALL LETTER G
+ 0x68: [694,11,576,48,555], // LATIN SMALL LETTER H
+ 0x69: [661,11,345,21,302], // LATIN SMALL LETTER I
+ 0x6A: [661,204,412,-12,403], // LATIN SMALL LETTER J
+ 0x6B: [694,11,521,48,503], // LATIN SMALL LETTER K
+ 0x6C: [694,11,298,38,266], // LATIN SMALL LETTER L
+ 0x6D: [442,11,878,21,857], // LATIN SMALL LETTER M
+ 0x6E: [442,11,600,21,580], // LATIN SMALL LETTER N
+ 0x6F: [441,11,485,34,476], // LATIN SMALL LETTER O
+ 0x70: [442,194,503,-39,497], // LATIN SMALL LETTER P
+ 0x71: [442,194,446,33,460], // LATIN SMALL LETTER Q
+ 0x72: [442,11,451,21,430], // LATIN SMALL LETTER R
+ 0x73: [442,10,469,53,419], // LATIN SMALL LETTER S
+ 0x74: [626,11,361,19,330], // LATIN SMALL LETTER T
+ 0x75: [442,11,572,21,551], // LATIN SMALL LETTER U
+ 0x76: [443,11,485,21,467], // LATIN SMALL LETTER V
+ 0x77: [443,11,716,21,690], // LATIN SMALL LETTER W
+ 0x78: [442,11,572,35,522], // LATIN SMALL LETTER X
+ 0x79: [442,205,490,21,496], // LATIN SMALL LETTER Y
+ 0x7A: [442,11,465,35,468], // LATIN SMALL LETTER Z
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x393: [680,-1,615,31,721], // GREEK CAPITAL LETTER GAMMA
+ 0x394: [716,0,833,48,788], // GREEK CAPITAL LETTER DELTA
+ 0x398: [704,22,763,50,740], // GREEK CAPITAL LETTER THETA
+ 0x39B: [716,0,694,35,670], // GREEK CAPITAL LETTER LAMDA
+ 0x39E: [677,0,742,53,777], // GREEK CAPITAL LETTER XI
+ 0x3A0: [680,0,831,31,887], // GREEK CAPITAL LETTER PI
+ 0x3A3: [683,0,780,58,806], // GREEK CAPITAL LETTER SIGMA
+ 0x3A5: [705,0,583,28,700], // GREEK CAPITAL LETTER UPSILON
+ 0x3A6: [683,0,667,24,642], // GREEK CAPITAL LETTER PHI
+ 0x3A8: [683,0,612,21,692], // GREEK CAPITAL LETTER PSI
+ 0x3A9: [704,0,772,80,786], // GREEK CAPITAL LETTER OMEGA
+ 0x3B1: [442,11,640,34,603], // GREEK SMALL LETTER ALPHA
+ 0x3B2: [705,194,566,23,573], // GREEK SMALL LETTER BETA
+ 0x3B3: [441,216,518,11,543], // GREEK SMALL LETTER GAMMA
+ 0x3B4: [717,10,444,36,451], // GREEK SMALL LETTER DELTA
+ 0x3B5: [452,22,466,27,428], // GREEK SMALL LETTER EPSILON
+ 0x3B6: [704,204,438,44,471], // GREEK SMALL LETTER ZETA
+ 0x3B7: [442,216,497,21,503], // GREEK SMALL LETTER ETA
+ 0x3B8: [705,10,469,35,462], // GREEK SMALL LETTER THETA
+ 0x3B9: [442,10,354,48,332], // GREEK SMALL LETTER IOTA
+ 0x3BA: [442,11,576,49,554], // GREEK SMALL LETTER KAPPA
+ 0x3BB: [694,12,583,47,556], // GREEK SMALL LETTER LAMDA
+ 0x3BC: [442,216,603,23,580], // GREEK SMALL LETTER MU
+ 0x3BD: [442,2,494,45,530], // GREEK SMALL LETTER NU
+ 0x3BE: [704,205,438,21,443], // GREEK SMALL LETTER XI
+ 0x3BF: [441,11,485,34,476], // GREEK SMALL LETTER OMICRON
+ 0x3C0: [431,11,570,19,573], // GREEK SMALL LETTER PI
+ 0x3C1: [442,216,517,23,510], // GREEK SMALL LETTER RHO
+ 0x3C2: [442,107,363,31,405], // GREEK SMALL LETTER FINAL SIGMA
+ 0x3C3: [431,11,571,31,572], // GREEK SMALL LETTER SIGMA
+ 0x3C4: [431,13,437,18,517], // GREEK SMALL LETTER TAU
+ 0x3C5: [443,10,540,21,523], // GREEK SMALL LETTER UPSILON
+ 0x3C6: [442,218,654,50,618], // GREEK SMALL LETTER PHI
+ 0x3C7: [442,204,626,25,600], // GREEK SMALL LETTER CHI
+ 0x3C8: [694,205,651,21,634], // GREEK SMALL LETTER PSI
+ 0x3C9: [443,11,622,15,604], // GREEK SMALL LETTER OMEGA
+ 0x3D1: [705,11,591,21,563], // GREEK THETA SYMBOL
+ 0x3D5: [694,205,596,43,579], // GREEK PHI SYMBOL
+ 0x3D6: [431,10,828,19,823], // GREEK PI SYMBOL
+ 0x3F1: [442,194,517,67,510], // GREEK RHO SYMBOL
+ 0x3F5: [431,11,406,40,382] // GREEK LUNATE EPSILON SYMBOL
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Size1'] = {
+ centerline: 250, ascent: 850, descent: 350,
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x28: [850,349,458,152,422], // LEFT PARENTHESIS
+ 0x29: [850,349,458,35,305], // RIGHT PARENTHESIS
+ 0x2F: [850,349,578,55,522], // SOLIDUS
+ 0x5B: [850,349,417,202,394], // LEFT SQUARE BRACKET
+ 0x5C: [850,349,578,54,522], // REVERSE SOLIDUS
+ 0x5D: [850,349,417,22,214], // RIGHT SQUARE BRACKET
+ 0x7B: [850,349,583,105,477], // LEFT CURLY BRACKET
+ 0x7D: [850,349,583,105,477], // RIGHT CURLY BRACKET
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x2C6: [744,-551,556,-8,564], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2DC: [722,-597,556,1,554], // SMALL TILDE
+ 0x302: [744,-551,0,-564,8], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [722,-597,0,-555,-2], // COMBINING TILDE
+ 0x2016: [602,0,778,257,521], // DOUBLE VERTICAL LINE
+ 0x2191: [600,0,667,112,555], // UPWARDS ARROW
+ 0x2193: [600,0,667,112,555], // DOWNWARDS ARROW
+ 0x21D1: [599,0,778,57,721], // UPWARDS DOUBLE ARROW
+ 0x21D3: [600,-1,778,57,721], // DOWNWARDS DOUBLE ARROW
+ 0x220F: [750,250,944,55,888], // N-ARY PRODUCT
+ 0x2210: [750,250,944,55,888], // N-ARY COPRODUCT
+ 0x2211: [750,250,1056,56,999], // N-ARY SUMMATION
+ 0x221A: [850,350,1000,111,1020], // SQUARE ROOT
+ 0x2223: [627,15,333,145,188], // DIVIDES
+ 0x2225: [627,15,556,145,410], // PARALLEL TO
+ 0x222B: [805,306,472,55,610], // INTEGRAL
+ 0x222C: [805,306,819,55,957], // DOUBLE INTEGRAL
+ 0x222D: [805,306,1166,55,1304], // TRIPLE INTEGRAL
+ 0x222E: [805,306,472,55,610], // CONTOUR INTEGRAL
+ 0x22C0: [750,249,833,55,777], // N-ARY LOGICAL AND
+ 0x22C1: [750,249,833,55,777], // N-ARY LOGICAL OR
+ 0x22C2: [750,249,833,55,777], // N-ARY INTERSECTION
+ 0x22C3: [750,249,833,55,777], // N-ARY UNION
+ 0x2308: [850,349,472,202,449], // LEFT CEILING
+ 0x2309: [850,349,472,22,269], // RIGHT CEILING
+ 0x230A: [850,349,472,202,449], // LEFT FLOOR
+ 0x230B: [850,349,472,22,269], // RIGHT FLOOR
+ 0x23D0: [602,0,667,312,355], // VERTICAL LINE EXTENSION (used to extend arrows)
+ 0x27E8: [850,350,472,97,394], // MATHEMATICAL LEFT ANGLE BRACKET
+ 0x27E9: [850,350,472,77,374], // MATHEMATICAL RIGHT ANGLE BRACKET
+ 0x2A00: [750,250,1111,56,1054], // N-ARY CIRCLED DOT OPERATOR
+ 0x2A01: [750,250,1111,56,1054], // N-ARY CIRCLED PLUS OPERATOR
+ 0x2A02: [750,250,1111,56,1054], // N-ARY CIRCLED TIMES OPERATOR
+ 0x2A04: [750,249,833,55,777], // N-ARY UNION OPERATOR WITH PLUS
+ 0x2A06: [750,249,833,55,777] // N-ARY SQUARE UNION OPERATOR
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Size2'] = {
+ centerline: 249, ascent: 1360, descent: 862,
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x28: [1150,649,597,180,561], // LEFT PARENTHESIS
+ 0x29: [1150,649,597,35,416], // RIGHT PARENTHESIS
+ 0x2F: [1150,649,811,56,754], // SOLIDUS
+ 0x5B: [1150,649,472,224,455], // LEFT SQUARE BRACKET
+ 0x5C: [1150,649,811,54,754], // REVERSE SOLIDUS
+ 0x5D: [1150,649,472,16,247], // RIGHT SQUARE BRACKET
+ 0x7B: [1150,649,667,119,547], // LEFT CURLY BRACKET
+ 0x7D: [1150,649,667,119,547], // RIGHT CURLY BRACKET
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x2C6: [772,-565,1000,-5,1004], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2DC: [750,-611,1000,0,999], // SMALL TILDE
+ 0x302: [772,-565,0,-1005,4], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [750,-611,0,-1000,-1], // COMBINING TILDE
+ 0x220F: [950,450,1278,56,1221], // N-ARY PRODUCT
+ 0x2210: [950,450,1278,56,1221], // N-ARY COPRODUCT
+ 0x2211: [950,450,1444,55,1388], // N-ARY SUMMATION
+ 0x221A: [1150,650,1000,111,1020], // SQUARE ROOT
+ 0x222B: [1360,862,556,55,944], // INTEGRAL
+ 0x222C: [1360,862,1084,55,1472], // DOUBLE INTEGRAL
+ 0x222D: [1360,862,1592,55,1980], // TRIPLE INTEGRAL
+ 0x222E: [1360,862,556,55,944], // CONTOUR INTEGRAL
+ 0x22C0: [950,450,1111,55,1055], // N-ARY LOGICAL AND
+ 0x22C1: [950,450,1111,55,1055], // N-ARY LOGICAL OR
+ 0x22C2: [949,450,1111,55,1055], // N-ARY INTERSECTION
+ 0x22C3: [950,449,1111,55,1055], // N-ARY UNION
+ 0x2308: [1150,649,528,224,511], // LEFT CEILING
+ 0x2309: [1150,649,528,16,303], // RIGHT CEILING
+ 0x230A: [1150,649,528,224,511], // LEFT FLOOR
+ 0x230B: [1150,649,528,16,303], // RIGHT FLOOR
+ 0x27E8: [1150,649,611,112,524], // MATHEMATICAL LEFT ANGLE BRACKET
+ 0x27E9: [1150,649,611,85,498], // MATHEMATICAL RIGHT ANGLE BRACKET
+ 0x2A00: [949,449,1511,56,1454], // N-ARY CIRCLED DOT OPERATOR
+ 0x2A01: [949,449,1511,56,1454], // N-ARY CIRCLED PLUS OPERATOR
+ 0x2A02: [949,449,1511,56,1454], // N-ARY CIRCLED TIMES OPERATOR
+ 0x2A04: [950,449,1111,55,1055], // N-ARY UNION OPERATOR WITH PLUS
+ 0x2A06: [950,450,1111,55,1055] // N-ARY SQUARE UNION OPERATOR
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Size3'] = {
+ centerline: 250, ascent: 1450, descent: 950,
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x28: [1450,949,736,209,701], // LEFT PARENTHESIS
+ 0x29: [1450,949,736,34,526], // RIGHT PARENTHESIS
+ 0x2F: [1450,949,1044,55,989], // SOLIDUS
+ 0x5B: [1450,949,528,247,516], // LEFT SQUARE BRACKET
+ 0x5C: [1450,949,1044,56,988], // REVERSE SOLIDUS
+ 0x5D: [1450,949,528,11,280], // RIGHT SQUARE BRACKET
+ 0x7B: [1450,949,750,130,618], // LEFT CURLY BRACKET
+ 0x7D: [1450,949,750,131,618], // RIGHT CURLY BRACKET
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x2C6: [772,-564,1444,-4,1447], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2DC: [749,-610,1444,1,1442], // SMALL TILDE
+ 0x302: [772,-564,0,-1448,3], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [749,-610,0,-1443,-2], // COMBINING TILDE
+ 0x221A: [1450,950,1000,111,1020], // SQUARE ROOT
+ 0x2308: [1450,949,583,246,571], // LEFT CEILING
+ 0x2309: [1450,949,583,11,336], // RIGHT CEILING
+ 0x230A: [1450,949,583,246,571], // LEFT FLOOR
+ 0x230B: [1450,949,583,11,336], // RIGHT FLOOR
+ 0x27E8: [1450,950,750,126,654], // MATHEMATICAL LEFT ANGLE BRACKET
+ 0x27E9: [1450,949,750,94,623] // MATHEMATICAL RIGHT ANGLE BRACKET
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Size4'] = {
+ centerline: 250, ascent: 1750, descent: 1250,
+ 0x20: [0,0,250,0,0], // SPACE
+ 0x28: [1750,1249,792,237,758], // LEFT PARENTHESIS
+ 0x29: [1750,1249,792,33,554], // RIGHT PARENTHESIS
+ 0x2F: [1750,1249,1278,56,1221], // SOLIDUS
+ 0x5B: [1750,1249,583,269,577], // LEFT SQUARE BRACKET
+ 0x5C: [1750,1249,1278,56,1221], // REVERSE SOLIDUS
+ 0x5D: [1750,1249,583,5,313], // RIGHT SQUARE BRACKET
+ 0x7B: [1750,1249,806,144,661], // LEFT CURLY BRACKET
+ 0x7D: [1750,1249,806,144,661], // RIGHT CURLY BRACKET
+ 0xA0: [0,0,250,0,0], // NO-BREAK SPACE
+ 0x2C6: [845,-561,1889,-14,1902], // MODIFIER LETTER CIRCUMFLEX ACCENT
+ 0x2DC: [823,-583,1889,1,1885], // SMALL TILDE
+ 0x302: [845,-561,0,-1903,13], // COMBINING CIRCUMFLEX ACCENT
+ 0x303: [823,-583,0,-1888,-4], // COMBINING TILDE
+ 0x221A: [1750,1250,1000,111,1020], // SQUARE ROOT
+ 0x2308: [1750,1249,639,269,633], // LEFT CEILING
+ 0x2309: [1750,1249,639,5,369], // RIGHT CEILING
+ 0x230A: [1750,1249,639,269,633], // LEFT FLOOR
+ 0x230B: [1750,1249,639,5,369], // RIGHT FLOOR
+ 0x239B: [1154,655,875,291,843], // LEFT PARENTHESIS UPPER HOOK
+ 0x239C: [610,10,875,291,417], // LEFT PARENTHESIS EXTENSION
+ 0x239D: [1165,644,875,291,843], // LEFT PARENTHESIS LOWER HOOK
+ 0x239E: [1154,655,875,31,583], // RIGHT PARENTHESIS UPPER HOOK
+ 0x239F: [610,10,875,457,583], // RIGHT PARENTHESIS EXTENSION
+ 0x23A0: [1165,644,875,31,583], // RIGHT PARENTHESIS LOWER HOOK
+ 0x23A1: [1154,645,667,319,666], // LEFT SQUARE BRACKET UPPER CORNER
+ 0x23A2: [602,0,667,319,403], // LEFT SQUARE BRACKET EXTENSION
+ 0x23A3: [1155,644,667,319,666], // LEFT SQUARE BRACKET LOWER CORNER
+ 0x23A4: [1154,645,667,0,347], // RIGHT SQUARE BRACKET UPPER CORNER
+ 0x23A5: [602,0,667,263,347], // RIGHT SQUARE BRACKET EXTENSION
+ 0x23A6: [1155,644,667,0,347], // RIGHT SQUARE BRACKET LOWER CORNER
+ 0x23A7: [899,10,889,384,718], // LEFT CURLY BRACKET UPPER HOOK
+ 0x23A8: [1160,660,889,170,504], // LEFT CURLY BRACKET MIDDLE PIECE
+ 0x23A9: [10,899,889,384,718], // LEFT CURLY BRACKET LOWER HOOK
+ 0x23AA: [310,10,889,384,504], // CURLY BRACKET EXTENSION
+ 0x23AB: [899,10,889,170,504], // RIGHT CURLY BRACKET UPPER HOOK
+ 0x23AC: [1160,660,889,384,718], // RIGHT CURLY BRACKET MIDDLE PIECE
+ 0x23AD: [10,899,889,170,504], // RIGHT CURLY BRACKET LOWER HOOK
+ 0x23B7: [935,885,1056,111,742], // RADICAL SYMBOL BOTTOM
+ 0x27E8: [1750,1248,806,140,703], // MATHEMATICAL LEFT ANGLE BRACKET
+ 0x27E9: [1750,1248,806,103,665], // MATHEMATICAL RIGHT ANGLE BRACKET
+ 0xE000: [625,14,1056,702,742], // stix-radical symbol vertical extender
+ 0xE001: [605,14,1056,702,1076], // stix-radical symbol top corner piece
+ 0xE150: [120,213,450,-24,460], // stix-horizontal brace, down left piece
+ 0xE151: [120,213,450,-10,474], // stix-horizontal brace, down right piece
+ 0xE152: [333,0,450,-24,460], // stix-horizontal brace, upper left piece
+ 0xE153: [333,0,450,-10,474], // stix-horizontal brace, upper right piece
+ 0xE154: [120,0,400,-10,410] // stix-oblique open face capital letter A
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Vector'] = {
+ centerline: 257, ascent: 714, descent: 200,
+ 0x2192: [714,-516,500,29,471] // vector arrow
+ };
+
+ CHTML.FONTDATA.FONTS['MathJax_Vector-Bold'] = {
+ centerline: 256, ascent: 723, descent: 210,
+ 0x2192: [723,-513,575,33,542] // vector arrow
+ };
+
+ CHTML.FONTDATA.FONTS[MAIN][0x2212][0] = CHTML.FONTDATA.FONTS[MAIN][0x002B][0]; // minus is sized as plus
+ CHTML.FONTDATA.FONTS[MAIN][0x2212][1] = CHTML.FONTDATA.FONTS[MAIN][0x002B][1]; // minus is sized as plus
+ CHTML.FONTDATA.FONTS[MAIN][0x22EE][0] += 400; // adjust height for \vdots
+ CHTML.FONTDATA.FONTS[MAIN][0x22F1][0] += 700; // adjust height for \ddots
+ CHTML.FONTDATA.FONTS[SIZE4][0x23AA][0] -= 20;
+ CHTML.FONTDATA.FONTS[SIZE4][0x23AA][1] += 5;
+ CHTML.FONTDATA.FONTS[SIZE4][0xE154][0] += 200; // adjust height for brace extender
+ CHTML.FONTDATA.FONTS[SIZE4][0xE154][1] += 200; // adjust depth for brace extender
+ CHTML.FONTDATA.FONTS[MAIN][0x2245][2] -= 222; // fix error in character's right bearing
+ CHTML.FONTDATA.FONTS[MAIN][0x2245][5] = {rfix:-222}; // fix error in character's right bearing
+ MathJax.Hub.Register.LoadHook(CHTML.fontDir+"/TeX/Main-Bold.js",function () {
+ CHTML.FONTDATA.FONTS[BOLD][0x2245][2] -= 106; // fix error in character's right bearing
+ CHTML.FONTDATA.FONTS[BOLD][0x2245][5] = {rfix:-106}; // fix error in character's right bearing
+ });
+ MathJax.Hub.Register.LoadHook(CHTML.fontDir+"/TeX/Typewriter-Regular.js",function () {
+ CHTML.FONTDATA.FONTS['MathJax_Typewriter'][0x20][2] += 275; // fix error in character width
+ CHTML.FONTDATA.FONTS['MathJax_Typewriter'][0x20][5] = {rfix:275}; // fix error in character width
+ CHTML.FONTDATA.FONTS['MathJax_Typewriter'][0xA0][2] += 275; // fix error in character width
+ CHTML.FONTDATA.FONTS['MathJax_Typewriter'][0xA0][5] = {rfix:275}; // fix error in character width
+ });
+
+ //
+ // Add some spacing characters
+ //
+ MathJax.Hub.Insert(CHTML.FONTDATA.FONTS[MAIN],{
+ remapCombining: {
+ 0x300: 0x2CB, // grave accent
+ 0x301: 0x2CA, // acute accent
+ 0x302: 0x2C6, // curcumflex
+ 0x303: 0x2DC, // tilde accent
+ 0x304: 0x2C9, // macron
+ 0x306: 0x2D8, // breve
+ 0x307: 0x2D9, // dot
+ 0x308: 0xA8, // diaresis
+ 0x30A: 0x2DA, // ring above
+// 0x30B: ?? // double acute accent
+ 0x30C: 0x2C7, // caron
+ 0x338: [0x2F, ITALIC], // \not
+ 0x20D7: [0x2192, 'MathJax_Vector'] // \vec
+ },
+ 0x2000: [0,0,500,0,0,{space:1}], // en space
+ 0x2001: [0,0,1000,0,0,{space:1}], // em quad
+ 0x2002: [0,0,500,0,0,{space:1}], // en quad
+ 0x2003: [0,0,1000,0,0,{space:1}], // em space
+ 0x2004: [0,0,333,0,0,{space:1}], // 3-per-em space
+ 0x2005: [0,0,250,0,0,{space:1}], // 4-per-em space
+ 0x2006: [0,0,167,0,0,{space:1}], // 6-per-em space
+ 0x2009: [0,0,167,0,0,{space:1}], // thin space
+ 0x200A: [0,0,100,0,0,{space:1}], // hair space
+ 0x200B: [0,0,0,0,0,{space:1}], // zero-width space
+ 0x200C: [0,0,0,0,0,{space:1}], // zero-width non-joiner space
+ 0x2061: [0,0,0,0,0,{space:1}], // function application
+ 0x2062: [0,0,0,0,0,{space:1}], // invisible times
+ 0x2063: [0,0,0,0,0,{space:1}], // invisible separator
+ 0x2064: [0,0,0,0,0,{space:1}], // invisible plus
+ 0xEEE0: [0,0,-575,0,0,{space:1}],
+ 0xEEE1: [0,0,-300,0,0,{space:1}],
+ 0xEEE8: [0,0,25,0,0,{space:1}]
+ });
+ MathJax.Hub.Insert(CHTML.FONTDATA.FONTS['MathJax_Main-Italic'],{
+ remapCombining: {
+ 0x300: [0x2CB, MAIN], // grave accent
+ 0x301: [0x2CA, MAIN], // acute accent
+ 0x302: [0x2C6, MAIN], // curcumflex
+ 0x303: [0x2DC, MAIN], // tilde accent
+ 0x304: [0x2C9, MAIN], // macron
+ 0x306: [0x2D8, MAIN], // breve
+ 0x307: [0x2D9, MAIN], // dot
+ 0x308: [0xA8, MAIN], // diaresis
+ 0x30A: [0x2DA, MAIN], // ring above
+// 0x30B: ?? // double acute accent
+ 0x30C: [0x2C7, MAIN], // caron
+ 0x338: [0x2F, 'MathJax_Vector'] // \not
+ }
+ });
+ MathJax.Hub.Insert(CHTML.FONTDATA.FONTS['MathJax_Main-Bold'],{
+ remapCombining: {
+ 0x300: 0x2CB, // grave accent
+ 0x301: 0x2CA, // acute accent
+ 0x302: 0x2C6, // curcumflex
+ 0x303: 0x2DC, // tilde accent
+ 0x304: 0x2C9, // macron
+ 0x306: 0x2D8, // breve
+ 0x307: 0x2D9, // dot
+ 0x308: 0xA8, // diaresis
+ 0x30A: 0x2DA, // ring above
+// 0x30B: ?? // double acute accent
+ 0x30C: 0x2C7, // caron
+ 0x338: [0x2F, 'MathJax_Math-BoldItalic'], // \not
+ 0x20D7: [0x2192, 'MathJax_Vector-Bold'] // \vec
+ }
+ });
+
+ //
+ // Create @font-face stylesheet for the declared fonts
+ //
+ CHTML.FONTDATA.familyName = function (font) {
+ font = font.replace(/^MathJax_/,"");
+ var names = (font+"-Regular").split(/-/);
+ var suffix = names[0].toLowerCase().replace(/(?:igraphic|serif|writer|tur|tor)$/,"")
+ + "-" + names[1].replace(/[^A-Z]/g,"");
+ return "MJXc-TeX-"+suffix;
+ };
+ (function () {
+ var STYLES = CHTML.config.styles, FONTS = CHTML.FONTDATA.FONTS;
+ var OTFDIR = AJAX.fileURL(CHTML.webfontDir+"/TeX/otf"),
+ EOTDIR = AJAX.fileURL(CHTML.webfontDir+"/TeX/eot"),
+ WOFFDIR = AJAX.fileURL(CHTML.webfontDir+"/TeX/woff");
+ var faces = [];
+ for (var name in FONTS) {if (FONTS.hasOwnProperty(name)) {
+ var family = CHTML.FONTDATA.familyName(name), FAMILY = family;
+ var variant = ((name+"-Regular").split(/-/))[1];
+ FONTS[name].className = family;
+ //
+ // The local font, if found
+ //
+ var font = {"font-family":family};
+ name = name.replace(/-.*/,"");
+ if (variant === "Regular") {
+ font.src = "local('"+name+"'), local('"+name+"-Regular')";
+ } else {
+ font.src = "local('"+name+" "+variant+"'), local('"+name+"-"+variant+"')";
+ }
+ faces.push(font);
+ //
+ // For Chrome, need to have separate font-weight and font-style versions
+ //
+ if (variant !== "Regular") {
+ font = {"font-family":family+"x", src:"local('"+name+"')"};
+ if (variant.match(/Bold/)) font["font-weight"] = "bold";
+ if (variant.match(/Italic/)) font["font-style"] = "italic";
+ FAMILY += ","+family+"x";
+ faces.push(font);
+ }
+ //
+ // The web font, if no local font found
+ //
+ font = {
+ "font-family": family+"w",
+ "src /*1*/": "url('"+EOTDIR+"/"+name+"-"+variant+".eot')", // for IE8
+ "src /*2*/": [
+ "url('"+WOFFDIR+"/"+name+"-"+variant+".woff') format('woff')",
+ "url('"+OTFDIR+"/"+name+"-"+variant+".otf') format('opentype')"
+ ].join(", ")
+ };
+ faces.push(font);
+ //
+ // A class that looks for the local and web fonts
+ //
+ FAMILY += ","+family+"w";
+ STYLES["."+family] = {"font-family":FAMILY};
+ }}
+ if (faces.length) STYLES["@font-face"] = faces;
+ })();
+
+ CHTML.fontLoaded("TeX/fontdata");
+
+})(MathJax.OutputJax.CommonHTML,MathJax.ElementJax.mml,MathJax.Ajax);
+
+// @license-end
diff --git a/js/mathjax/jax/output/CommonHTML/jax.js b/js/mathjax/jax/output/CommonHTML/jax.js
new file mode 100644
index 0000000..6c57957
--- /dev/null
+++ b/js/mathjax/jax/output/CommonHTML/jax.js
@@ -0,0 +1,2845 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/CommonHTML/jax.js
+ *
+ * Implements the CommonHTML OutputJax that displays mathematics
+ * using HTML and CSS to position the characters from math fonts
+ * in their proper locations. Unlike the HTML-CSS output jax,
+ * this HTML is browser and OS independent.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2013-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(function (AJAX,HUB,HTML,CHTML) {
+ var MML;
+ var isArray = MathJax.Object.isArray;
+
+ var EVENT, TOUCH, HOVER; // filled in later
+
+ var STRUTHEIGHT = 1,
+ EFUZZ = .1, // overlap needed for stretchy delimiters
+ HFUZZ = .025, DFUZZ = .025; // adjustments to bounding box of character boxes
+
+ var STYLES = {
+ ".mjx-chtml": {
+ display: "inline-block",
+ "line-height": 0,
+ "text-indent": 0,
+ "text-align": "left",
+ "text-transform": "none",
+ "font-style": "normal",
+ "font-weight": "normal",
+ "font-size": "100%",
+ "font-size-adjust":"none",
+ "letter-spacing": "normal",
+ "word-wrap": "normal",
+ "word-spacing": "normal",
+ "white-space": "nowrap",
+ "float": "none",
+ "direction": "ltr",
+ "max-width": "none",
+ "max-height": "none",
+ "min-width": 0,
+ "min-height": 0,
+ border: 0,
+ margin: 0,
+ padding: "1px 0"
+ },
+ ".MJXc-display": {
+ display: "block",
+ "text-align": "center",
+ "margin": "1em 0",
+ padding: 0
+ },
+ ".mjx-chtml[tabindex]:focus, body :focus .mjx-chtml[tabindex]": {
+ display: "inline-table" // see issues #1282 and #1338
+ },
+ ".mjx-full-width": {
+ "text-align": "center",
+ display: "table-cell!important",
+ width: "10000em"
+ },
+
+ ".mjx-math": {
+ "display": "inline-block",
+ "border-collapse": "separate",
+ "border-spacing": 0
+ },
+ ".mjx-math *": {
+ display:"inline-block",
+ "-webkit-box-sizing": "content-box!important",
+ "-moz-box-sizing": "content-box!important",
+ "box-sizing": "content-box!important", // override bootstrap settings
+ "text-align":"left"
+ },
+
+ ".mjx-numerator": {display:"block", "text-align":"center"},
+ ".mjx-denominator": {display:"block", "text-align":"center"},
+ ".MJXc-stacked": {height:0, position:"relative"},
+ ".MJXc-stacked > *": {position: "absolute"},
+ ".MJXc-bevelled > *": {display:"inline-block"},
+
+ ".mjx-stack": {display:"inline-block"},
+ ".mjx-op": {display:"block"},
+ ".mjx-under": {display:"table-cell"},
+ ".mjx-over": {display:"block"},
+ ".mjx-over > *": {"padding-left":"0px!important", "padding-right":"0px!important"},
+ ".mjx-under > *": {"padding-left":"0px!important", "padding-right":"0px!important"},
+
+ ".mjx-stack > .mjx-sup": {display:"block"},
+ ".mjx-stack > .mjx-sub": {display:"block"},
+ ".mjx-prestack > .mjx-presup": {display:"block"},
+ ".mjx-prestack > .mjx-presub": {display:"block"},
+
+ ".mjx-delim-h > .mjx-char": {display:"inline-block"},
+
+ ".mjx-surd": {"vertical-align":"top"},
+ ".mjx-surd + .mjx-box": {display:"inline-flex"},
+
+ ".mjx-mphantom *": {visibility:"hidden"},
+
+ ".mjx-merror": {
+ "background-color":"#FFFF88",
+ color: "#CC0000",
+ border: "1px solid #CC0000",
+ padding: "2px 3px",
+ "font-style": "normal",
+ "font-size": "90%"
+ },
+
+ ".mjx-annotation-xml": {"line-height":"normal"},
+
+ ".mjx-menclose > svg": {fill:"none", stroke:"currentColor", overflow:"visible"},
+
+ ".mjx-mtr": {display:"table-row"},
+ ".mjx-mlabeledtr": {display:"table-row"},
+ ".mjx-mtd": {display:"table-cell", "text-align":"center"},
+ ".mjx-label": {display:"table-row"},
+
+ ".mjx-box": {display:"inline-block"},
+ ".mjx-block": {display:"block"},
+ ".mjx-span": {display:"inline"},
+ ".mjx-char": {display:"block", "white-space":"pre"},
+ ".mjx-itable": {display:"inline-table", width:"auto"},
+ ".mjx-row": {display:"table-row"},
+ ".mjx-cell": {display:"table-cell"},
+ ".mjx-table": {display:"table", width:"100%"},
+ ".mjx-line": {display:"block", height:0},
+ ".mjx-strut": {width:0, "padding-top":STRUTHEIGHT+"em"},
+ ".mjx-vsize": {width:0},
+
+ ".MJXc-space1": {"margin-left":".167em"},
+ ".MJXc-space2": {"margin-left":".222em"},
+ ".MJXc-space3": {"margin-left":".278em"},
+
+ ".mjx-chartest": {
+ display:"block",
+ visibility: "hidden",
+ position:"absolute", top:0,
+ "line-height":"normal",
+ "font-size":"500%"
+ },
+ ".mjx-chartest .mjx-char": {display:"inline"},
+ ".mjx-chartest .mjx-box": {"padding-top": "1000px"},
+
+ ".MJXc-processing": {
+ visibility: "hidden", position:"fixed",
+ width: 0, height: 0, overflow:"hidden"
+ },
+ ".MJXc-processed": {display:"none"},
+
+ ".mjx-test": {
+ "font-style": "normal",
+ "font-weight": "normal",
+ "font-size": "100%",
+ "font-size-adjust":"none",
+ "text-indent": 0,
+ "text-transform": "none",
+ "letter-spacing": "normal",
+ "word-spacing": "normal",
+ overflow: "hidden",
+ height: "1px"
+ },
+ ".mjx-test.mjx-test-display": {
+ display: "table!important"
+ },
+ ".mjx-test.mjx-test-inline": {
+ display: "inline!important",
+ "margin-right": "-1px"
+ },
+ ".mjx-test.mjx-test-default": {
+ display: "block!important",
+ clear: "both"
+ },
+ ".mjx-ex-box": {
+ display: "inline-block!important",
+ position: "absolute",
+ overflow: "hidden",
+ "min-height": 0, "max-height":"none",
+ padding:0, border: 0, margin: 0,
+ width:"1px", height:"60ex"
+ },
+ ".mjx-test-inline .mjx-left-box": {
+ display: "inline-block",
+ width: 0,
+ "float":"left"
+ },
+ ".mjx-test-inline .mjx-right-box": {
+ display: "inline-block",
+ width: 0,
+ "float":"right"
+ },
+ ".mjx-test-display .mjx-right-box": {
+ display: "table-cell!important",
+ width: "10000em!important",
+ "min-width":0, "max-width":"none",
+ padding:0, border:0, margin:0
+ },
+
+ "#MathJax_CHTML_Tooltip": {
+ "background-color": "InfoBackground", color: "InfoText",
+ border: "1px solid black",
+ "box-shadow": "2px 2px 5px #AAAAAA", // Opera 10.5
+ "-webkit-box-shadow": "2px 2px 5px #AAAAAA", // Safari 3 and Chrome
+ "-moz-box-shadow": "2px 2px 5px #AAAAAA", // Firefox 3.5
+ "-khtml-box-shadow": "2px 2px 5px #AAAAAA", // Konqueror
+ padding: "3px 4px",
+ "z-index": 401,
+ position: "absolute", left: 0, top: 0,
+ width: "auto", height: "auto",
+ display: "none"
+ }
+
+ };
+
+
+ /************************************************************/
+
+ var BIGDIMEN = 1000000;
+ var MAXREMAP = 5;
+ var LINEBREAKS = {}, CONFIG = MathJax.Hub.config;
+
+ CHTML.Augment({
+ settings: HUB.config.menuSettings,
+ config: {styles: STYLES},
+
+ /********************************************/
+
+ Config: function () {
+ if (!this.require) {this.require = []}
+ this.SUPER(arguments).Config.call(this); var settings = this.settings;
+ if (settings.scale) {this.config.scale = settings.scale}
+ this.require.push(this.fontDir+"/TeX/fontdata.js");
+ this.require.push(MathJax.OutputJax.extensionDir+"/MathEvents.js");
+ LINEBREAKS = this.config.linebreaks;
+ },
+
+ Startup: function () {
+ //
+ // Set up event handling
+ //
+ EVENT = MathJax.Extension.MathEvents.Event;
+ TOUCH = MathJax.Extension.MathEvents.Touch;
+ HOVER = MathJax.Extension.MathEvents.Hover;
+ this.ContextMenu = EVENT.ContextMenu;
+ this.Mousedown = EVENT.AltContextMenu;
+ this.Mouseover = HOVER.Mouseover;
+ this.Mouseout = HOVER.Mouseout;
+ this.Mousemove = HOVER.Mousemove;
+
+ //
+ // Determine pixels per inch
+ //
+ var div = CHTML.addElement(document.body,"mjx-block",{style:{display:"block",width:"5in"}});
+ this.pxPerInch = div.offsetWidth/5; div.parentNode.removeChild(div);
+
+ //
+ // Used in preTranslate to get scaling factors and line width
+ //
+ this.TestSpan = CHTML.Element("mjx-test",{style:{left:"1em"}},
+ [["mjx-left-box"],["mjx-ex-box"],["mjx-right-box"]]);
+
+ //
+ // Set up styles and preload web fonts
+ //
+ return AJAX.Styles(this.config.styles,["InitializeCHTML",this]);
+ },
+
+ InitializeCHTML: function () {
+ this.getDefaultExEm();
+ //
+ // If the defaultEm size is zero, it might be that a web font hasn't
+ // arrived yet, so try to wait for it, but don't wait too long.
+ //
+ if (this.defaultEm) return;
+ var ready = MathJax.Callback();
+ AJAX.timer.start(AJAX,function (check) {
+ if (check.time(ready)) {HUB.signal.Post(["CommonHTML Jax - no default em size"]); return}
+ CHTML.getDefaultExEm();
+ if (CHTML.defaultEm) {ready()} else {setTimeout(check,check.delay)}
+ },this.defaultEmDelay,this.defaultEmTimeout);
+ return ready;
+ },
+ defaultEmDelay: 100, // initial delay when checking for defaultEm
+ defaultEmTimeout: 1000, // when to stop looking for defaultEm
+ getDefaultExEm: function () {
+ //
+ // Get the default sizes (need styles in place to do this)
+ //
+ var test = document.body.appendChild(this.TestSpan.cloneNode(true));
+ test.className += " mjx-test-inline mjx-test-default";
+ this.defaultEm = this.getFontSize(test);
+ this.defaultEx = test.childNodes[1].offsetHeight/60;
+ this.defaultWidth = Math.max(0,test.lastChild.offsetLeft-test.firstChild.offsetLeft-2);
+ document.body.removeChild(test);
+ },
+ getFontSize: (window.getComputedStyle ?
+ function (node) {
+ var style = window.getComputedStyle(node);
+ return parseFloat(style.fontSize);
+ } :
+ //
+ // IE 8 doesn't do getComputedStyle, so use
+ // an alternative approach
+ //
+ function (node) {
+ return node.style.pixelLeft;
+ }
+ ),
+ getMaxWidth: (window.getComputedStyle ?
+ function (node) {
+ var style = window.getComputedStyle(node);
+ if (style.maxWidth !== "none") return parseFloat(style.maxWidth);
+ return 0;
+ } :
+ //
+ // IE 8 doesn't do getComputedStyle, so use
+ // currentStyle, and a hack to get the pixels for
+ // a non-px max-width
+ //
+ function (node) {
+ var max = node.currentStyle.maxWidth;
+ if (max !== "none") {
+ if (max.match(/\d*px/)) return parseFloat(max);
+ var left = node.style.left;
+ node.style.left = max; max = node.style.pixelLeft;
+ node.style.left = left;
+ return max;
+ }
+ return 0;
+ }
+ ),
+
+ //
+ // Load data for a font
+ //
+ loadFont: function (font) {
+ HUB.RestartAfter(AJAX.Require(this.fontDir+"/"+font));
+ },
+ //
+ // Signal that the font data are loaded
+ //
+ fontLoaded: function (font) {
+ if (!font.match(/-|fontdata/)) font += "-Regular";
+ if (!font.match(/\.js$/)) font += ".js"
+ MathJax.Callback.Queue(
+ ["Post",HUB.Startup.signal,"CommonHTML - font data loaded for " + font],
+ ["loadComplete",AJAX,this.fontDir+"/"+font]
+ );
+ },
+
+ Element: function (type,def,content) {
+ if (type.substr(0,4) === "mjx-") {
+ if (!def) def = {};
+ if (def.isMathJax == null) def.isMathJax = true;
+ if (def.className) def.className = type+" "+def.className; else def.className = type;
+ type = "span";
+ }
+ return this.HTMLElement(type,def,content);
+ },
+ addElement: function (node,type,def,content) {
+ return node.appendChild(this.Element(type,def,content));
+ },
+ HTMLElement: HTML.Element,
+ ucMatch: HTML.ucMatch,
+ setScript: HTML.setScript,
+
+ //
+ // Look through the direct children of a node for one with the given
+ // type (but if the node has intervening containers for its children,
+ // step into them; note that elements corresponding to MathML nodes
+ // will have id's so we don't step into them).
+ //
+ // This is used by munderover and msubsup to locate their child elements
+ // when they are part of an embellished operator that is being stretched.
+ // We don't use querySelector because we want to find only the direct child
+ // nodes, not nodes that might be nested deeper in the tree (see issue #1447).
+ //
+ getNode: function (node,type) {
+ var name = RegExp("\\b"+type+"\\b");
+ var nodes = [];
+ while (node) {
+ for (var i = 0, m = node.childNodes.length; i < m; i++) {
+ var child = node.childNodes[i];
+ if (child) {
+ if (name.test(child.className)) return child;
+ if (child.id === "") nodes.push(child);
+ }
+ }
+ node = nodes.shift();
+ }
+ return null;
+ },
+
+ /********************************************/
+
+ preTranslate: function (state) {
+ var scripts = state.jax[this.id], i, m = scripts.length,
+ script, prev, node, test, jax, ex, em, scale;
+ //
+ // Get linebreaking information
+ //
+ var maxwidth = 100000, relwidth = false, cwidth = 0,
+ linebreak = LINEBREAKS.automatic, width = LINEBREAKS.width;
+ if (linebreak) {
+ relwidth = !!width.match(/^\s*(\d+(\.\d*)?%\s*)?container\s*$/);
+ if (relwidth) {width = width.replace(/\s*container\s*/,"")}
+ else {maxwidth = this.defaultWidth}
+ if (width === "") {width = "100%"}
+ }
+ //
+ // Loop through the scripts
+ //
+ for (i = 0; i < m; i++) {
+ script = scripts[i]; if (!script.parentNode) continue;
+ //
+ // Remove any existing output
+ //
+ prev = script.previousSibling;
+ if (prev && prev.className && String(prev.className).substr(0,9) === "mjx-chtml")
+ prev.parentNode.removeChild(prev);
+ if (script.MathJax.preview) script.MathJax.preview.style.display = "none";
+ //
+ // Add the node for the math and mark it as being processed
+ //
+ jax = script.MathJax.elementJax; if (!jax) continue;
+ jax.CHTML = {
+ display: (jax.root.Get("display") === "block"),
+ preview: (jax.CHTML||{}).preview // in case typeset calls are interleaved
+ };
+ node = CHTML.Element("mjx-chtml",{
+ id:jax.inputID+"-Frame", className:"MathJax_CHTML", isMathJax:true, jaxID:this.id,
+ oncontextmenu:EVENT.Menu, onmousedown: EVENT.Mousedown,
+ onmouseover:EVENT.Mouseover, onmouseout:EVENT.Mouseout, onmousemove:EVENT.Mousemove,
+ onclick:EVENT.Click, ondblclick:EVENT.DblClick,
+ // Added for keyboard accessible menu.
+ onkeydown: EVENT.Keydown, tabIndex: HUB.getTabOrder(jax)
+ });
+ if (jax.CHTML.display) {
+ //
+ // Zoom box requires an outer container to get the positioning right.
+ //
+ var NODE = CHTML.Element("mjx-chtml",{className:"MJXc-display",isMathJax:false});
+ NODE.appendChild(node); node = NODE;
+ }
+ if (HUB.Browser.noContextMenu) {
+ node.ontouchstart = TOUCH.start;
+ node.ontouchend = TOUCH.end;
+ }
+ //
+ node.className += " MJXc-processing";
+ script.parentNode.insertBefore(node,script);
+ //
+ // Add test nodes for determining scales and linebreak widths
+ //
+ test = this.TestSpan.cloneNode(true);
+ test.className += " mjx-test-" + (jax.CHTML.display ? "display" : "inline");
+ script.parentNode.insertBefore(test,script);
+ }
+ //
+ // Determine the scaling factors for each script
+ // (this only requires one reflow rather than a reflow for each equation)
+ //
+ for (i = 0; i < m; i++) {
+ script = scripts[i]; if (!script.parentNode) continue;
+ test = script.previousSibling;
+ jax = script.MathJax.elementJax; if (!jax) continue;
+ em = CHTML.getFontSize(test);
+ ex = test.childNodes[1].offsetHeight/60;
+ cwidth = Math.max(0, jax.CHTML.display ? test.lastChild.offsetWidth - 1:
+ test.lastChild.offsetLeft - test.firstChild.offsetLeft - 2);
+ if (ex === 0 || ex === "NaN") {
+ ex = this.defaultEx;
+ cwidth = this.defaultWidth;
+ }
+ if (cwidth === 0 && !jax.CHTML.display) cwidth = this.defaultWidth;
+ if (relwidth) maxwidth = cwidth;
+ scale = (this.config.matchFontHeight ? ex/this.TEX.x_height/em : 1);
+ scale = Math.floor(Math.max(this.config.minScaleAdjust/100,scale)*this.config.scale);
+ jax.CHTML.scale = scale/100; jax.CHTML.fontSize = scale+"%";
+ jax.CHTML.outerEm = em; jax.CHTML.em = this.em = em * scale/100;
+ jax.CHTML.ex = ex; jax.CHTML.cwidth = cwidth/this.em;
+ jax.CHTML.lineWidth = (linebreak ? this.length2em(width,maxwidth/this.em,1) : maxwidth);
+ }
+ //
+ // Remove the test spans used for determining scales and linebreak widths
+ //
+ for (i = 0; i < m; i++) {
+ script = scripts[i]; if (!script.parentNode) continue;
+ jax = script.MathJax.elementJax; if (!jax) continue;
+ script.parentNode.removeChild(script.previousSibling);
+ if (script.MathJax.preview) script.MathJax.preview.style.display = "";
+ }
+ state.CHTMLeqn = state.CHTMLlast = 0; state.CHTMLi = -1;
+ state.CHTMLchunk = this.config.EqnChunk;
+ state.CHTMLdelay = false;
+ },
+
+ /********************************************/
+
+ Translate: function (script,state) {
+ if (!script.parentNode) return;
+
+ //
+ // If we are supposed to do a chunk delay, do it
+ //
+ if (state.CHTMLdelay) {
+ state.CHTMLdelay = false;
+ HUB.RestartAfter(MathJax.Callback.Delay(this.config.EqnChunkDelay));
+ }
+
+ //
+ // Get the data about the math
+ //
+ var jax = script.MathJax.elementJax, math = jax.root,
+ node = document.getElementById(jax.inputID+"-Frame");
+ if (!node) return;
+ this.getMetrics(jax);
+ if (this.scale !== 1) node.style.fontSize = jax.CHTML.fontSize;
+ //
+ // Typeset the math
+ //
+ this.initCHTML(math,node);
+ this.savePreview(script);
+ this.CHTMLnode = node;
+ try {
+ math.setTeXclass();
+ math.toCommonHTML(node);
+ } catch (err) {
+ while (node.firstChild) node.removeChild(node.firstChild);
+ delete this.CHTMLnode;
+ this.restorePreview(script);
+ throw err;
+ }
+ delete this.CHTMLnode;
+ this.restorePreview(script);
+ //
+ // Put it in place, and remove the processing marker
+ //
+ if (jax.CHTML.display) node = node.parentNode;
+ node.className = node.className.replace(/ [^ ]+$/,"");
+ //
+ // Hide the math and don't let its preview be removed
+ //
+ node.className += " MJXc-processed";
+ if (script.MathJax.preview) {
+ jax.CHTML.preview = script.MathJax.preview;
+ delete script.MathJax.preview;
+ }
+ //
+ // Check if we should show this chunk of equations
+ //
+ state.CHTMLeqn += (state.i - state.CHTMLi); state.CHTMLi = state.i;
+ if (state.CHTMLeqn >= state.CHTMLlast + state.CHTMLchunk) {
+ this.postTranslate(state);
+ state.CHTMLchunk = Math.floor(state.CHTMLchunk*this.config.EqnChunkFactor);
+ state.CHTMLdelay = true; // delay if there are more scripts
+ }
+ },
+
+ initCHTML: function (math,node) {},
+
+ //
+ // MathML previews can contain the same ID's as the HTML output,
+ // which confuses CHTMLnodeElement(), so remove the preview temporarily
+ // and restore it after typesetting the math.
+ //
+ savePreview: function (script) {
+ var preview = script.MathJax.preview;
+ if (preview && preview.parentNode) {
+ script.MathJax.tmpPreview = document.createElement("span");
+ preview.parentNode.replaceChild(script.MathJax.tmpPreview,preview);
+ }
+ },
+ restorePreview: function (script) {
+ var tmpPreview = script.MathJax.tmpPreview;
+ if (tmpPreview) {
+ tmpPreview.parentNode.replaceChild(script.MathJax.preview,tmpPreview);
+ delete script.MathJax.tmpPreview;
+ }
+ },
+ //
+ // Get the jax metric information
+ //
+ getMetrics: function(jax) {
+ var data = jax.CHTML;
+ this.jax = jax;
+ this.em = data.em;
+ this.outerEm = data.outerEm;
+ this.scale = data.scale;
+ this.cwidth = data.cwidth;
+ this.linebreakWidth = data.lineWidth;
+ },
+
+ /********************************************/
+
+ postTranslate: function (state) {
+ var scripts = state.jax[this.id];
+ //
+ // Reveal this chunk of math
+ //
+ for (var i = state.CHTMLlast, m = state.CHTMLeqn; i < m; i++) {
+ var script = scripts[i];
+ if (script && script.MathJax.elementJax) {
+ //
+ // Remove the processed marker
+ //
+ script.previousSibling.className = script.previousSibling.className.replace(/ [^ ]+$/,"");
+ var data = script.MathJax.elementJax.CHTML;
+ //
+ // Remove the preview, if any
+ //
+ if (data.preview) {
+ data.preview.innerHTML = "";
+ script.MathJax.preview = data.preview;
+ delete data.preview;
+ }
+ }
+ }
+ //
+ // Save our place so we know what is revealed
+ //
+ state.CHTMLlast = state.CHTMLeqn;
+ },
+
+ /********************************************/
+
+ getJaxFromMath: function (math) {
+ if (math.parentNode.className.match(/MJXc-display/)) math = math.parentNode;
+ do {math = math.nextSibling} while (math && math.nodeName.toLowerCase() !== "script");
+ return HUB.getJaxFor(math);
+ },
+ getHoverSpan: function (jax,math) {return jax.root.CHTMLnodeElement()},
+ getHoverBBox: function (jax,span,math) {
+ var bbox = jax.root.CHTML, em = jax.CHTML.outerEm;
+ var BBOX = {w:bbox.w*em, h:bbox.h*em, d:bbox.d*em};
+ if (bbox.width) {BBOX.width = bbox.width}
+ return BBOX;
+ },
+
+ Zoom: function (jax,span,math,Mw,Mh) {
+ //
+ // Re-render at larger size
+ //
+ this.getMetrics(jax);
+ var node = CHTML.addElement(span,"mjx-chtml",{style:{"font-size":Math.floor(CHTML.scale*100)+"%"},isMathJax:false});
+ CHTML.CHTMLnode = node;
+ this.idPostfix = "-zoom"; jax.root.toCommonHTML(node); this.idPostfix = "";
+ //
+ // Adjust margins to prevent overlaps at the edges
+ //
+ var style = node.style, bbox = jax.root.CHTML;
+ if (bbox.t > bbox.h) style.marginTop = CHTML.Em(bbox.t-bbox.h);
+ if (bbox.b > bbox.d) style.marginBottom = CHTML.Em(bbox.b-bbox.d);
+ if (bbox.l < 0) style.paddingLeft = CHTML.Em(-bbox.l);
+ if (bbox.r > bbox.w) style.marginRight = CHTML.Em(bbox.r-bbox.w);
+ //
+ // Get height and width of zoomed math and original math
+ //
+ style.position = "absolute";
+ var zW = node.offsetWidth, zH = node.offsetHeight,
+ mH = math.firstChild.offsetHeight, mW = math.firstChild.offsetWidth;
+ node.style.position = "";
+ //
+ return {Y:-EVENT.getBBox(span).h, mW:mW, mH:mH, zW:zW, zH:zH};
+ },
+
+ Remove: function (jax) {
+ var node = document.getElementById(jax.inputID+"-Frame");
+ if (node && jax.CHTML.display) node = node.parentNode;
+ if (node) node.parentNode.removeChild(node);
+ delete jax.CHTML;
+ },
+
+ /********************************************/
+
+ ID: 0, idPostfix: "",
+ GetID: function () {this.ID++; return this.ID},
+
+ /********************************************/
+
+ MATHSPACE: {
+ veryverythinmathspace: 1/18,
+ verythinmathspace: 2/18,
+ thinmathspace: 3/18,
+ mediummathspace: 4/18,
+ thickmathspace: 5/18,
+ verythickmathspace: 6/18,
+ veryverythickmathspace: 7/18,
+ negativeveryverythinmathspace: -1/18,
+ negativeverythinmathspace: -2/18,
+ negativethinmathspace: -3/18,
+ negativemediummathspace: -4/18,
+ negativethickmathspace: -5/18,
+ negativeverythickmathspace: -6/18,
+ negativeveryverythickmathspace: -7/18,
+
+ thin: .04,
+ medium: .06,
+ thick: .1,
+
+ infinity: BIGDIMEN
+ },
+ SPACECLASS: {
+ thinmathspace: "MJXc-space1",
+ mediummathspace: "MJXc-space2",
+ thickmathspace: "MJXc-space3"
+ },
+ pxPerInch: 96,
+ em: 16,
+
+ maxStretchyParts: 1000, // limit the number of parts allowed for
+ // stretchy operators. See issue 366.
+
+ FONTDEF: {},
+ TEXDEF: {
+ x_height: .442,
+ quad: 1,
+ num1: .676508,
+ num2: .393732,
+ num3: .44373,
+ denom1: .685951,
+ denom2: .344841,
+ sup1: .412892,
+ sup2: .362892,
+ sup3: .288888,
+ sub1: .15,
+ sub2: .247217,
+ sup_drop: .386108,
+ sub_drop: .05,
+ delim1: 2.39,
+ delim2: 1.0,
+ axis_height: .25,
+ rule_thickness: .06,
+ big_op_spacing1: .111111,
+ big_op_spacing2: .166666,
+ big_op_spacing3: .2,
+ big_op_spacing4: .45, //.6, // better spacing for under arrows and braces
+ big_op_spacing5: .1,
+
+ surd_height: .075,
+
+ scriptspace: .05,
+ nulldelimiterspace: .12,
+ delimiterfactor: 901,
+ delimitershortfall: .3,
+
+ min_rule_thickness: 1.25 // in pixels
+ },
+
+ /********************************************************/
+
+ //
+ // True if text holds a single (unicode) glyph
+ //
+ isChar: function (text) {
+ if (text.length === 1) return true;
+ if (text.length !== 2) return false;
+ var n = text.charCodeAt(0);
+ return (n >= 0xD800 && n < 0xDBFF);
+ },
+ //
+ // Get a unicode character by number (even when it takes two character)
+ //
+ unicodeChar: function (n) {
+ if (n < 0xFFFF) return String.fromCharCode(n);
+ n -= 0x10000;
+ return String.fromCharCode((n>>10)+0xD800) + String.fromCharCode((n&0x3FF)+0xDC00);
+ },
+ //
+ // Get the unicode number of a (possibly multi-character) string
+ //
+ getUnicode: function (string) {
+ var n = string.text.charCodeAt(string.i); string.i++;
+ if (n >= 0xD800 && n < 0xDBFF) {
+ n = (((n-0xD800)<<10)+(string.text.charCodeAt(string.i)-0xDC00))+0x10000;
+ string.i++;
+ }
+ return n;
+ },
+ //
+ // Get the list of actions for a given character in a given variant
+ // (processing remaps, multi-character results, and so on). Results are
+ // cached so that future lookups for the same variant/n pair will not
+ // require looking through the data again.
+ //
+ getCharList: function (variant,n) {
+ var id, M, cache = variant.cache, nn = n;
+ if (cache[n]) return cache[n];
+ if (n > 0xFFFF && this.FONTDATA.RemapPlane1) {
+ var nv = this.FONTDATA.RemapPlane1(n,variant);
+ n = nv.n; variant = nv.variant;
+ }
+ var RANGES = this.FONTDATA.RANGES, VARIANT = this.FONTDATA.VARIANT;
+ if (n >= RANGES[0].low && n <= RANGES[RANGES.length-1].high) {
+ for (id = 0, M = RANGES.length; id < M; id++) {
+ if (RANGES[id].name === "alpha" && variant.noLowerCase) continue;
+ var N = variant["offset"+RANGES[id].offset];
+ if (N && n >= RANGES[id].low && n <= RANGES[id].high) {
+ if (RANGES[id].remap && RANGES[id].remap[n]) {
+ n = N + RANGES[id].remap[n];
+ } else {
+ n = n - RANGES[id].low + N;
+ if (RANGES[id].add) {n += RANGES[id].add}
+ }
+ if (variant["variant"+RANGES[id].offset])
+ variant = VARIANT[variant["variant"+RANGES[id].offset]];
+ break;
+ }
+ }
+ }
+ cache[nn] = this.remapChar(variant,n,0);
+ return cache[nn];
+ },
+ remapChar: function (variant,n,N) {
+ var list = [], VARIANT = this.FONTDATA.VARIANT;
+ if (variant.remap && variant.remap[n]) {
+ n = variant.remap[n];
+ if (variant.remap.variant) {variant = VARIANT[variant.remap.variant]}
+ } else if (this.FONTDATA.REMAP[n] && !variant.noRemap) {
+ n = this.FONTDATA.REMAP[n];
+ }
+ if (isArray(n)) {
+ if (n[2]) N = MAXREMAP; // stop remapping
+ variant = VARIANT[n[1]]; n = n[0];
+ }
+ if (typeof(n) === "string") {
+ var string = {text:n, i:0, length:n.length};
+ while (string.i < string.length) {
+ n = this.getUnicode(string);
+ var chars = this.getCharList(variant,n);
+ if (chars) list.push.apply(list,chars);
+ }
+ } else {
+ if (variant.cache[n]) {list = variant.cache[n]}
+ else {variant.cache[n] = list = this.lookupChar(variant,n,N)}
+ }
+ return list;
+ },
+ //
+ // After all remapping has been done, look up a character
+ // in the fonts for a given variant, chaining to other
+ // variants as needed. Return an undefined character if
+ // it isn't found in the given variant.
+ //
+ lookupChar: function (variant,n,N) {
+ var VARIANT = variant;
+ while (variant) {
+ for (var i = 0, m = variant.fonts.length; i < m; i++) {
+ var font = this.FONTDATA.FONTS[variant.fonts[i]];
+ if (typeof(font) === "string") this.loadFont(font);
+ var C = font[n];
+ if (C) {
+ this.fixChar(C,n);
+ if (C[5].space) return [{type:"space", w:C[2], font:font}];
+ return [{type:"char", font:font, n:n}];
+ } else if (font.Extra) {
+ this.findBlock(font,n);
+ }
+ }
+ variant = this.FONTDATA.VARIANT[variant.chain];
+ if (variant && variant.remap && variant.remap[n] && N++ < MAXREMAP) {
+ return this.remapChar(variant,n,N);
+ }
+ }
+ return [this.unknownChar(VARIANT,n)];
+ },
+ fixChar: function (C,n) {
+ if (C.length === 5) C[5] = {};
+ if (C.c == null) {
+ C[0] /= 1000; C[1] /= 1000; C[2] /= 1000; C[3] /= 1000; C[4] /= 1000;
+ C.c = this.unicodeChar(n);
+ }
+ return C;
+ },
+ findBlock: function (font,n) {
+ var extra = font.Extra, name = font.file, file;
+ for (var i = 0, m = extra.length; i < m; i++) {
+ if (typeof(extra[i]) === "number") {
+ if (n === extra[i]) {file = name; break}
+ } else {
+ if (n < extra[i][0]) return;
+ if (n <= extra[i][1]) {file = name; break}
+ }
+ }
+ //
+ // Currently this only loads one extra file, but that
+ // might need to be expanded in the future.
+ //
+ if (file) {delete font.Extra; this.loadFont(name)}
+ },
+ //
+ // Create a fake font entry for an unknown character.
+ //
+ unknownChar: function (variant,n) {
+ HUB.signal.Post(["CommonHTML Jax - unknown char",n,variant]);
+ var id = ""; if (variant.bold) id += "B"; if (variant.italic) id += "I";
+ var unknown = this.FONTDATA.UNKNOWN[id||"R"]; // cache of previously measured characters
+ if (!unknown[n]) this.getUnknownChar(unknown,n);
+ return {type:"unknown", n:n, font:unknown};
+ },
+ getUnknownChar: function (unknown,n) {
+ var c = this.unicodeChar(n);
+ var HDW = this.getHDW(c,unknown.className);
+ // ### FIXME: provide a means of setting the height and depth for individual characters
+ unknown[n] = [.8,.2,HDW.w,0,HDW.w,{a:Math.max(0,(HDW.h-HDW.d)/2), h:HDW.h, d:HDW.d}];
+ unknown[n].c = c;
+ },
+ styledText: function (variant,text) {
+ HUB.signal.Post(["CommonHTML Jax - styled text",text,variant]);
+ var style = variant.style;
+ var id = "_"+(style["font-family"]||variant.className||"");
+ if (style["font-weight"]) id += "_"+style["font-weight"];
+ if (style["font-style"]) id += "_"+style["font-style"];
+ if (!this.STYLEDTEXT) this.STYLEDTEXT = {};
+ if (!this.STYLEDTEXT[id]) this.STYLEDTEXT[id] = {className:variant.className||""};
+ var unknown = this.STYLEDTEXT[id];
+ if (!unknown["_"+text]) {
+ var HDW = this.getHDW(text,variant.className||"",style);
+ unknown["_"+text] = [.8,.2,HDW.w,0,HDW.w,{a:Math.max(0,(HDW.h-HDW.d)/2), h:HDW.h, d:HDW.d}];
+ unknown["_"+text].c = text;
+ }
+ return {type:"unknown", n:"_"+text, font:unknown, style:style, rscale:variant.rscale};
+ },
+
+ //
+ // Get the height, depth, and width of a character
+ // (height and depth are of the font, not the character).
+ // WARNING: causes reflow of the page!
+ //
+ getHDW: function (c,name,styles) {
+ var test1 = CHTML.addElement(CHTML.CHTMLnode,"mjx-chartest",{className:name},[["mjx-char",{style:styles},[c]]]);
+ var test2 = CHTML.addElement(CHTML.CHTMLnode,"mjx-chartest",{className:name},[["mjx-char",{style:styles},[c,["mjx-box"]]]]);
+ test1.firstChild.style.fontSize = test2.firstChild.style.fontSize = "";
+ var em = 5*CHTML.em;
+ var H1 = test1.offsetHeight, H2 = test2.offsetHeight, W = test1.offsetWidth;
+ CHTML.CHTMLnode.removeChild(test1);
+ CHTML.CHTMLnode.removeChild(test2);
+ if (H2 === 0) {
+ em = 5*CHTML.defaultEm;
+ var test = document.body.appendChild(document.createElement("div"));
+ test.appendChild(test1); test.appendChild(test2);
+ H1 = test1.offsetHeight, H2 = test2.offsetHeight, W = test1.offsetWidth;
+ document.body.removeChild(test);
+ }
+ var d = (H2-1000)/em, w = W/em, h = H1/em - d;
+ return {h:h, d:d, w:w}
+ },
+
+
+ /********************************************************/
+
+ //
+ // Process a character list into a given node and return
+ // the updated bounding box.
+ //
+ addCharList: function (node,list,bbox) {
+ var state = {text:"", className:null, a:0};
+ for (var i = 0, m = list.length; i < m; i++) {
+ var item = list[i];
+ if (this.charList[item.type]) (this.charList[item.type])(item,node,bbox,state,m);
+ }
+ if (state.text !== "") {
+ if (node.childNodes.length) {
+ this.charList.flushText(node,state);
+ } else {
+ HTML.addText(node,state.text);
+ if (node.className) node.className += " "+state.className;
+ else node.className = state.className;
+ }
+ }
+ bbox.b = (state.flushed ? 0 : bbox.a);
+ },
+ //
+ // The various item types are processed by these
+ // functions.
+ //
+ charList: {
+ //
+ // Character from the known fonts
+ //
+ "char": function (item,node,bbox,state,m) {
+ var font = item.font, remap = (font.remapCombining||{})[item.n];
+ if (font.className === state.className) {
+ remap = null;
+ } else if (state.className || (remap && state.text !== "")) {
+ this.flushText(node,state);
+ }
+ if (!state.a) state.a = font.centerline/1000;
+ if (state.a > (bbox.a||0)) bbox.a = state.a;
+ state.className = font.className;
+ var C = font[item.n];
+ if (remap) {
+ var FONT = font;
+ if (isArray(remap)) {
+ FONT = CHTML.FONTDATA.FONTS[remap[1]];
+ remap = remap[0];
+ if (typeof(FONT) === 'string') CHTML.loadFont(FONT);
+ }
+ if (FONT[item.n]) CHTML.fixChar(FONT[item.n],item.n);
+ C = CHTML.fixChar(FONT[remap],remap);
+ state.className = FONT.className;
+ }
+ state.text += C.c;
+ if (bbox.h < C[0]+HFUZZ) bbox.t = bbox.h = C[0]+HFUZZ;
+ if (bbox.d < C[1]+DFUZZ) bbox.b = bbox.d = C[1]+DFUZZ;
+ if (bbox.l > bbox.w+C[3]) bbox.l = bbox.w+C[3];
+ if (bbox.r < bbox.w+C[4]) bbox.r = bbox.w+C[4];
+ bbox.w += C[2] * (item.rscale||1);
+ if (m == 1 && font.skew && font.skew[item.n]) bbox.skew = font.skew[item.n];
+ if (C[5] && C[5].rfix) this.flushText(node,state).style.marginRight = CHTML.Em(C[5].rfix/1000);
+ if (remap) {
+ //
+ // Remap combining characters to non-combining versions since Safari
+ // handles them differently from everyone else. (#1709)
+ //
+ var chr = this.flushText(node,state);
+ var r = (FONT[item.n]||font[item.n])[4] - (C[4] - C[2]);
+ chr.style.marginLeft = CHTML.Em(-C[2]-r);
+ if (r < 0) chr.style.marginRight = CHTML.Em(-r);
+ }
+ },
+ //
+ // Space characters (not actually in the fonts)
+ //
+ space: function (item,node,bbox,state) {
+ if (item.w) {
+ if (state.text === "") state.className = item.font.className;
+ this.flushText(node,state).style.marginRight = CHTML.Em(item.w);
+ bbox.w += item.w;
+ }
+ },
+ //
+ // An unknown character (one not in the font data)
+ //
+ unknown: function (item,node,bbox,state) {
+ (this["char"])(item,node,bbox,state,0);
+ var C = item.font[item.n];
+ if (C[5].a) {
+ state.a = C[5].a;
+ if (bbox.a == null || state.a > bbox.a) bbox.a = state.a;
+ }
+ node = this.flushText(node,state,item.style);
+ if (C[2] < 3) node.style.width = CHTML.Em(C[2]); // only force width if not too large (#1718)
+ },
+ //
+ // Put the pending text into a box of the class, and
+ // reset the data about the text.
+ //
+ flushText: function (node,state,style) {
+ node = CHTML.addElement(node,"mjx-charbox",
+ {className:state.className,style:style},[state.text]);
+ if (state.a) node.style.paddingBottom = CHTML.Em(state.a);
+ state.text = ""; state.className = null; state.a = 0; state.flushed = true;
+ return node;
+ }
+ },
+
+ //
+ // Add the given text (in the given variant) into the given node, and
+ // update the bounding box of the result. Make sure the node's DOM
+ // bounding box matches the contents.
+ //
+ handleText: function (node,text,variant,bbox) {
+ if (node.childNodes.length === 0) {
+ CHTML.addElement(node,"mjx-char");
+ bbox = CHTML.BBOX.empty(bbox);
+ }
+ if (typeof(variant) === "string") variant = this.FONTDATA.VARIANT[variant];
+ if (!variant) variant = this.FONTDATA.VARIANT[MML.VARIANT.NORMAL];
+ var string = {text:text, i:0, length:text.length}, list = [];
+ if (variant.style && string.length) {
+ list.push(this.styledText(variant,text));
+ } else {
+ while (string.i < string.length) {
+ var n = this.getUnicode(string);
+ list.push.apply(list,this.getCharList(variant,n));
+ }
+ }
+ if (list.length) this.addCharList(node.firstChild,list,bbox);
+ bbox.clean();
+ if (bbox.d < 0) {bbox.D = bbox.d; bbox.d = 0}
+ if (bbox.h - bbox.a) node.firstChild.style[bbox.h - bbox.a < 0 ? "marginTop" : "paddingTop"] = this.EmRounded(bbox.h-bbox.a);
+ if (bbox.d > -bbox.b) node.firstChild.style.paddingBottom = this.EmRounded(bbox.d+bbox.b);
+ return bbox;
+ },
+
+ /********************************************************/
+
+ createDelimiter: function (node,code,HW,BBOX,font) {
+ if (!code) {
+ var bbox = this.BBOX.zero();
+ bbox.w = bbox.r = this.TEX.nulldelimiterspace;
+ CHTML.addElement(node,"mjx-box",{style:{width:bbox.w}});
+ return bbox;
+ }
+ if (!(HW instanceof Array)) HW = [HW,HW];
+ var hw = HW[1]; HW = HW[0];
+ var delim = {alias: code};
+ while (delim.alias) {
+ code = delim.alias; delim = this.FONTDATA.DELIMITERS[code];
+ if (!delim) {delim = {HW: [0,this.FONTDATA.VARIANT[MML.VARIANT.NORMAL]]}}
+ }
+ if (delim.load) HUB.RestartAfter(AJAX.Require(this.fontDir+"/TeX/fontdata-"+delim.load+".js"));
+ for (var i = 0, m = delim.HW.length; i < m; i++) {
+ if (delim.HW[i][0] >= HW-.01 || (i == m-1 && !delim.stretch)) {
+ if (delim.HW[i][3]) code = delim.HW[i][3];
+ bbox = this.createChar(node,[code,delim.HW[i][1]],(delim.HW[i][2]||1),font);
+ bbox.offset = .6 * bbox.w;
+ if (BBOX) {bbox.scale = BBOX.scale; BBOX.rscale = BBOX.rscale}
+ return bbox;
+ }
+ }
+ if (!delim.stretch) return bbox;
+ return this["extendDelimiter"+delim.dir](node,hw,delim.stretch,BBOX,font);
+ },
+ extendDelimiterV: function (node,H,delim,BBOX,font) {
+ node = CHTML.addElement(node,"mjx-delim-v"); var tmp = CHTML.Element("span");
+ var top, bot, mid, ext, tbox, bbox, mbox, ebox, k = 1, c;
+ tbox = this.createChar(tmp,(delim.top||delim.ext),1,font); top = tmp.removeChild(tmp.firstChild);
+ bbox = this.createChar(tmp,(delim.bot||delim.ext),1,font); bot = tmp.removeChild(tmp.firstChild);
+ mbox = ebox = CHTML.BBOX.zero();
+ var h = tbox.h + tbox.d + bbox.h + bbox.d - EFUZZ;
+ node.appendChild(top);
+ if (delim.mid) {
+ mbox = this.createChar(tmp,delim.mid,1,font); mid = tmp.removeChild(tmp.firstChild);
+ h += mbox.h + mbox.d; k = 2;
+ }
+ if (delim.min && H < h*delim.min) H = h*delim.min;
+ if (H > h) {
+ ebox = this.createChar(tmp,delim.ext,1,font); ext = tmp.removeChild(tmp.firstChild);
+ var eH = ebox.h + ebox.d, eh = eH - EFUZZ;
+ var n = Math.min(Math.ceil((H-h)/(k*eh)),this.maxStretchyParts);
+ if (delim.fullExtenders) H = n*k*eh + h; else eh = (H-h)/(k*n);
+ c = ebox.d + ebox.a - eH/2; // for centering of extenders
+ ext.style.margin = ext.style.padding = "";
+ ext.style.lineHeight = CHTML.Em(eh);
+ ext.style.marginBottom = CHTML.Em(c-EFUZZ/2/k);
+ ext.style.marginTop = CHTML.Em(-c-EFUZZ/2/k);
+ var TEXT = ext.textContent, text = "\n"+TEXT;
+ while (--n > 0) TEXT += text;
+ ext.textContent = TEXT;
+ node.appendChild(ext);
+ if (delim.mid) {
+ node.appendChild(mid);
+ node.appendChild(ext.cloneNode(true));
+ }
+ } else {
+ c = (H-h-EFUZZ) / k;
+ top.style.marginBottom = CHTML.Em(c+parseFloat(top.style.marginBottom||"0"));
+ if (delim.mid) node.appendChild(mid);
+ bot.style.marginTop = CHTML.Em(c+parseFloat(bot.style.marginTop||"0"));
+ }
+ node.appendChild(bot);
+ var vbox = CHTML.BBOX({
+ w: Math.max(tbox.w,ebox.w,bbox.w,mbox.w),
+ l: Math.min(tbox.l,ebox.l,bbox.l,mbox.l),
+ r: Math.max(tbox.r,ebox.r,bbox.r,mbox.r),
+ h: H-bbox.d, d: bbox.d, t: H-bbox.d, b: bbox.d
+ });
+ vbox.offset = .5 * vbox.w;
+ if (BBOX) {vbox.scale = BBOX.scale; vbox.rscale = BBOX.rscale}
+ return vbox;
+ },
+ extendDelimiterH: function (node,W,delim,BBOX,font) {
+ node = CHTML.addElement(node,"mjx-delim-h"); var tmp = CHTML.Element("span");
+ var left, right, mid, ext, ext2, lbox, rbox, mbox, ebox, k = 1;
+ lbox = this.createChar(tmp,(delim.left||delim.rep),1,font); left = tmp.removeChild(tmp.firstChild);
+ rbox = this.createChar(tmp,(delim.right||delim.rep),1,font); right = tmp.removeChild(tmp.firstChild);
+ ebox = this.createChar(tmp,delim.rep,1,font); ext = tmp.removeChild(tmp.firstChild);
+ left.style.marginLeft = CHTML.Em(-lbox.l);
+ right.style.marginRight = CHTML.Em(rbox.r-rbox.w);
+ node.appendChild(left);
+ var hbox = CHTML.BBOX.zero();
+ hbox.h = Math.max(lbox.h,rbox.h,ebox.h);
+ hbox.d = Math.max(lbox.D||lbox.d,rbox.D||rbox.d,ebox.D||ebox.d);
+ var w = (lbox.r - lbox.l) + (rbox.r - rbox.l) - EFUZZ;
+ if (delim.mid) {
+ mbox = this.createChar(tmp,delim.mid,1,font);
+ mid = tmp.removeChild(tmp.firstChild);
+ mid.style.marginleft = CHTML.Em(-mbox.l); mid.style.marginRight = CHTML.Em(mbox.r-mbox.w);
+ w += mbox.r - mbox.l + EFUZZ; k = 2;
+ if (mbox.h > hbox.h) hbox.h = mbox.h;
+ if (mbox.d > hbox.d) hbox.d = mbox.d;
+ }
+ if (delim.min && W < w*delim.min) W = w*delim.min;
+ hbox.w = hbox.r = W;
+ if (W > w) {
+ var eW = ebox.r-ebox.l, ew = eW - EFUZZ;
+ var n = Math.min(Math.ceil((W-w)/(k*ew)),this.maxStretchyParts);
+ if (delim.fullExtenders) W = n*k*ew + w; else ew = (W-w)/(k*n);
+ var c = (eW - ew + EFUZZ/k) / 2; // for centering of extenders
+ ext.style.marginLeft = CHTML.Em(-ebox.l-c);
+ ext.style.marginRight = CHTML.Em(ebox.r-ebox.w+c);
+ ext.style.letterSpacing = CHTML.Em(-(ebox.w-ew));
+ left.style.marginRight = CHTML.Em(lbox.r-lbox.w);
+ right.style.marginleft = CHTML.Em(-rbox.l);
+ var TEXT = ext.textContent, text = TEXT;
+ while (--n > 0) TEXT += text;
+ ext.textContent = TEXT;
+ node.appendChild(ext);
+ if (delim.mid) {
+ node.appendChild(mid);
+ ext2 = node.appendChild(ext.cloneNode(true));
+ }
+ } else {
+ c = (W-w-EFUZZ/k) / 2;
+ left.style.marginRight = CHTML.Em(lbox.r-lbox.w+c);
+ if (delim.mid) node.appendChild(mid);
+ right.style.marginLeft = CHTML.Em(-rbox.l+c);
+ }
+ node.appendChild(right);
+ this.adjustHeights([left,ext,mid,ext2,right],[lbox,ebox,mbox,ebox,rbox],hbox);
+ if (BBOX) {hbox.scale = BBOX.scale; hbox.rscale = BBOX.rscale}
+ return hbox;
+ },
+ adjustHeights: function (nodes,box,bbox) {
+ //
+ // To get alignment right in horizontal delimiters, we force all
+ // the elements to the same height and depth
+ //
+ var T = bbox.h, B = bbox.d;
+ if (bbox.d < 0) {B = -bbox.d; bbox.D = bbox.d; bbox.d = 0}
+ for (var i = 0, m = nodes.length; i < m; i++) if (nodes[i]) {
+ nodes[i].style.paddingTop = CHTML.Em(T-box[i].a);
+ nodes[i].style.paddingBottom = CHTML.Em(B+box[i].a);
+ nodes[i].style.marginTop = nodes[i].style.marginBottom = 0;
+ }
+ },
+ createChar: function (node,data,scale,font) {
+ // ### FIXME: handle cache better (by data[1] and font)
+ var text = "", variant = {fonts: [data[1]], noRemap:true, cache:{}};
+ if (font && font === MML.VARIANT.BOLD && this.FONTDATA.FONTS[data[1]+"-Bold"])
+ variant.fonts = [data[1]+"-Bold",data[1]];
+ if (typeof(data[1]) !== "string") variant = data[1];
+ if (data[0] instanceof Array) {
+ for (var i = 0, m = data[0].length; i < m; i++) text += String.fromCharCode(data[0][i]);
+ } else text = String.fromCharCode(data[0]);
+ if (data[4]) scale *= data[4];
+ var bbox = this.handleText(node,text,variant), style = node.firstChild.style;
+ if (scale !== 1) style.fontSize = this.Percent(scale);
+ if (data[2]) { // x offset
+ style.paddingLeft = this.Em(data[2]);
+ bbox.w += data[2]; bbox.r += data[2];
+ }
+ if (data[3]) { // y offset
+ style.verticalAlign = this.Em(data[3]);
+ bbox.h += data[3]; if (bbox.h < 0) bbox.h = 0;
+ }
+ if (data[5]) { // extra height
+ style.marginTop = this.Em(data[5]);
+ bbox.h += data[5]; bbox.t += data[5];
+ }
+ if (data[6]) { // extra depth
+ style.marginBottom = this.Em(data[6]);
+ bbox.d += data[6]; bbox.b += data[6];
+ }
+ return bbox;
+ },
+
+ /********************************************************/
+
+ //
+ // ### FIXME: Handle mu's
+ //
+ length2em: function (length,size,scale) {
+ if (typeof(length) !== "string") length = length.toString();
+ if (length === "") return "";
+ if (length === MML.SIZE.NORMAL) return 1;
+ if (length === MML.SIZE.BIG) return 2;
+ if (length === MML.SIZE.SMALL) return .71;
+ if (this.MATHSPACE[length]) return this.MATHSPACE[length];
+ var match = length.match(/^\s*([-+]?(?:\.\d+|\d+(?:\.\d*)?))?(pt|em|ex|mu|px|pc|in|mm|cm|%)?/);
+ var m = parseFloat(match[1]||"1"), unit = match[2];
+ if (size == null) size = 1; if (!scale) scale = 1;
+ scale = 1 /this.em / scale;
+ if (unit === "em") return m;
+ if (unit === "ex") return m * this.TEX.x_height;
+ if (unit === "%") return m / 100 * size;
+ if (unit === "px") return m * scale;
+ if (unit === "pt") return m / 10; // 10 pt to an em
+ if (unit === "pc") return m * 1.2; // 12 pt to a pc
+ scale *= this.pxPerInch;
+ if (unit === "in") return m * scale;
+ if (unit === "cm") return m * scale / 2.54; // 2.54 cm to an inch
+ if (unit === "mm") return m * scale / 25.4; // 10 mm to a cm
+ if (unit === "mu") return m / 18; // 18mu to an em for the scriptlevel
+ return m*size; // relative to given size (or 1em as default)
+ },
+ thickness2em: function (length,scale) {
+ var thick = CHTML.TEX.rule_thickness/(scale||1);
+ if (length === MML.LINETHICKNESS.MEDIUM) return thick;
+ if (length === MML.LINETHICKNESS.THIN) return .67*thick;
+ if (length === MML.LINETHICKNESS.THICK) return 1.67*thick;
+ return this.length2em(length,thick,scale);
+ },
+
+ Em: function (m) {
+ if (Math.abs(m) < .001) return "0";
+ return (m.toFixed(3).replace(/\.?0+$/,""))+"em";
+ },
+ EmRounded: function (m) {
+ m = (Math.round(m*CHTML.em)+.05)/CHTML.em;
+ if (Math.abs(m) < .0006) {return "0em"}
+ return m.toFixed(3).replace(/\.?0+$/,"") + "em";
+ },
+ unEm: function (m) {
+ return parseFloat(m);
+ },
+ Px: function (m,M) {
+ m *= this.em;
+ if (M && m < M) m = M;
+ if (Math.abs(m) < .1) return "0";
+ return m.toFixed(1).replace(/\.0$/,"")+"px";
+ },
+
+ Percent: function (m) {
+ return (100*m).toFixed(1).replace(/\.?0+$/,"") + "%";
+ },
+
+ Transform: function (node,trans,origin) {
+ var style = node.style;
+ style.transform = style.WebkitTransform = style.MozTransform = style["-ms-transform"] = trans;
+ if (origin)
+ style.transformOrigin = style.WebkitTransformOrigin =
+ style.MozTransformOrigin = style["-ms-transform-origin"] = origin;
+ },
+
+ /********************************************************/
+
+ arrayEntry: function (a,i) {return a[Math.max(0,Math.min(i,a.length-1))]},
+
+ //
+ // Styles to be removed from style="..." attributes
+ //
+ removeStyles: ["fontSize","fontFamily","fontWeight","fontStyle","fontVariant","font"]
+
+ });
+
+ /**********************************************************/
+
+ CHTML.BBOX = MathJax.Object.Subclass({
+ Init: function (def) {
+ for (var id in def) {
+ if (def.hasOwnProperty(id)) this[id] = def[id];
+ }
+ },
+ clean: function () {
+ if (this.h === -BIGDIMEN) this.h = 0;
+ if (this.d === -BIGDIMEN) this.d = 0;
+ if (this.l === BIGDIMEN) this.l = 0;
+ if (this.r === -BIGDIMEN) this.r = 0;
+ if (this.t === -BIGDIMEN) this.t = 0;
+ if (this.b === -BIGDIMEN) this.b = 0;
+ if (this.D && this.d > 0) delete this.D;
+ },
+ rescale: function (scale) {
+ this.w *= scale; this.h *= scale; this.d *= scale;
+ this.l *= scale; this.r *= scale; this.t *= scale; this.b *= scale;
+ if (this.L) this.L *= scale;
+ if (this.R) this.R *= scale;
+ if (this.D) this.D *= scale;
+ },
+ combine: function (cbox,x,y) {
+ cbox.X = x; cbox.Y = y; // save for use with line breaking
+ var scale = cbox.rscale;
+ if (x + scale*cbox.r > this.r) this.r = x + scale*cbox.r;
+ if (x + scale*cbox.l < this.l) this.l = x + scale*cbox.l;
+ if (x + scale*(cbox.w+(cbox.L||0)+(cbox.R||0)) > this.w)
+ this.w = x + scale*(cbox.w + (cbox.L||0) + (cbox.R||0));
+ if (y + scale*cbox.h > this.h) this.h = y + scale*cbox.h;
+ if (cbox.D && (this.D == null || scale*cbox.D - y > this.D) && scale*cbox.D > this.d) this.D = scale*cbox.D - y;
+ else if (cbox.D == null && this.D) delete this.D;
+ if (scale*cbox.d - y > this.d) this.d = scale*cbox.d - y;
+ if (y + scale*cbox.t > this.t) this.t = y + scale*cbox.t;
+ if (scale*cbox.b - y > this.b) this.b = scale*cbox.b - y;
+ },
+ append: function (cbox) {
+ var scale = cbox.rscale; var x = this.w;
+ if (x + scale*cbox.r > this.r) this.r = x + scale*cbox.r;
+ if (x + scale*cbox.l < this.l) this.l = x + scale*cbox.l;
+ this.w += scale*(cbox.w+(cbox.L||0)+(cbox.R||0)) ;
+ if (scale*cbox.h > this.h) this.h = scale*cbox.h;
+ if (cbox.D && (this.D == null || scale*cbox.D > this.D) && scale*cbox.D > this.d) this.D = scale*cbox.D;
+ else if (cbox.D == null && this.D) delete this.D;
+ if (scale*cbox.d > this.d) this.d = scale*cbox.d;
+ if (scale*cbox.t > this.t) this.t = scale*cbox.t;
+ if (scale*cbox.b > this.b) this.b = scale*cbox.b;
+ },
+ updateFrom: function (cbox) {
+ this.h = cbox.h; this.d = cbox.d; this.w = cbox.w; this.r = cbox.r; this.l = cbox.l;
+ this.t = cbox.t; this.b = cbox.b;
+ if (cbox.pwidth) this.pwidth = cbox.pwidth;
+ if (cbox.D) this.D = cbox.D; else delete this.D;
+ },
+ adjust: function (m,x,X,M) {
+ this[x] += CHTML.length2em(m,1,this.scale);
+ if (M == null) {
+ if (this[x] > this[X]) this[X] = this[x];
+ } else {
+ if (this[X] < M) this[X] = M;
+ }
+ }
+ },{
+ zero: function () {
+ return CHTML.BBOX({h:0, d:0, w:0, l:0, r:0, t:0, b:0, scale:1, rscale:1});
+ },
+ empty: function (bbox) {
+ if (!bbox) bbox = CHTML.BBOX.zero();
+ bbox.h = bbox.d = bbox.r = bbox.t = bbox.b = -BIGDIMEN;
+ bbox.w = 0; bbox.l = BIGDIMEN;
+ delete bbox.pwidth;
+ return bbox;
+ },
+ //
+ // CSS styles that affect BBOXes
+ //
+ styleAdjust: [
+ ["borderTopWidth","h","t"],
+ ["borderRightWidth","w","r"],
+ ["borderBottomWidth","d","b"],
+ ["borderLeftWidth","w","l",0],
+ ["paddingTop","h","t"],
+ ["paddingRight","w","r"],
+ ["paddingBottom","d","b"],
+ ["paddingLeft","w","l",0],
+ ]
+ });
+
+ /**********************************************************/
+
+ MathJax.Hub.Register.StartupHook("mml Jax Ready",function () {
+ MML = MathJax.ElementJax.mml;
+
+ /********************************************************/
+
+ MML.mbase.Augment({
+ toCommonHTML: function (node,options) {
+ return this.CHTMLdefaultNode(node,options);
+ },
+ CHTMLmultiline: function () {MML.mbase.CHTMLautoloadFile("multiline")},
+
+ CHTMLdefaultNode: function (node,options) {
+ if (!options) options = {};
+ node = this.CHTMLcreateNode(node); this.CHTML = CHTML.BBOX.empty();
+ this.CHTMLhandleStyle(node);
+ if (this.isToken) this.CHTMLgetVariant();
+ this.CHTMLhandleScale(node);
+ var m = Math.max((options.minChildren||0),this.data.length);
+ for (var i = 0; i < m; i++) this.CHTMLaddChild(node,i,options);
+ if (!options.noBBox) this.CHTML.clean();
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ return node;
+ },
+ CHTMLaddChild: function (node,i,options) {
+ var child = this.data[i], cnode;
+ var type = options.childNodes;
+ if (type instanceof Array) type = type[i]||"span";
+ if (child) {
+ if (type) node = CHTML.addElement(node,type);
+ cnode = child.toCommonHTML(node,options.childOptions);
+ if (type && child.CHTML.rscale !== 1) {
+ // move scale factor to outer container (which seems to be more accurate)
+ node.style.fontSize = node.firstChild.style.fontSize;
+ node.firstChild.style.fontSize = "";
+ }
+ if (!options.noBBox) {
+ var bbox = this.CHTML, cbox = child.CHTML;
+ bbox.append(cbox);
+ if (this.data.length === 1) {
+ if (cbox.ic) bbox.ic = cbox.ic;
+ if (cbox.skew) bbox.skew = cbox.skew;
+ } else {
+ delete bbox.ic;
+ delete bbox.skew;
+ }
+ if (cbox.pwidth) bbox.pwidth = cbox.pwidth;
+ }
+ } else if (options.forceChild) {
+ cnode = CHTML.addElement(node,(type||"mjx-box"));
+ }
+ return cnode;
+ },
+
+ CHTMLchildNode: function (node,i) {
+ node = node.childNodes[i];
+ if (node.nodeName.toLowerCase() === "a") node = node.firstChild;
+ return node;
+ },
+ CHTMLcoreNode: function (node) {
+ if (this.inferRow && this.data[0]) return this.data[0].CHTMLcoreNode(node.firstChild);
+ return this.CHTMLchildNode(node,this.CoreIndex());
+ },
+
+ CHTMLstretchChildV: function (i,H,D) {
+ var data = this.data[i];
+ if (data) {
+ var bbox = this.CHTML, dbox = data.CHTML;
+ if (dbox.stretch || (dbox.stretch == null && data.CHTMLcanStretch("Vertical",H,D))) {
+ var w = dbox.w;
+ dbox = data.CHTMLstretchV(H,D);
+ bbox.w += dbox.w - w;
+ if (bbox.w > bbox.r) bbox.r = bbox.w;
+ if (dbox.h > bbox.h) bbox.h = dbox.h;
+ if (dbox.d > bbox.d) bbox.d = dbox.d;
+ if (dbox.t > bbox.t) bbox.t = dbox.t;
+ if (dbox.b > bbox.b) bbox.b = dbox.b;
+ }
+ }
+ },
+ CHTMLstretchChildH: function (i,W,node) {
+ var data = this.data[i];
+ if (data) {
+ var bbox = this.CHTML, dbox = data.CHTML;
+ if (dbox.stretch || (dbox.stretch == null && data.CHTMLcanStretch("Horizontal",W))) {
+ var w = dbox.w;
+ dbox = data.CHTMLstretchH(this.CHTMLchildNode(node,i),W);
+ bbox.w += dbox.w - w;
+ if (bbox.w > bbox.r) bbox.r = bbox.w;
+ if (dbox.h > bbox.h) bbox.h = dbox.h;
+ if (dbox.d > bbox.d) bbox.d = dbox.d;
+ if (dbox.t > bbox.t) bbox.t = dbox.t;
+ if (dbox.b > bbox.b) bbox.b = dbox.b;
+ }
+ }
+ },
+ CHTMLupdateFrom: function (bbox) {
+ this.CHTML.updateFrom(bbox);
+ if (this.inferRow) this.data[0].CHTML.updateFrom(bbox);
+ },
+
+ CHTMLcanStretch: function (direction,H,D) {
+ var stretch = false;
+ if (this.isEmbellished()) {
+ var core = this.Core();
+ if (core && core !== this) stretch = core.CHTMLcanStretch(direction,H,D);
+ }
+ this.CHTML.stretch = stretch;
+ return stretch;
+ },
+ CHTMLstretchV: function (h,d) {
+ this.CHTMLupdateFrom(this.Core().CHTMLstretchV(h,d));
+ return this.CHTML;
+ },
+ CHTMLstretchH: function (node,w) {
+ this.CHTMLupdateFrom(this.CHTMLstretchCoreH(node,w));
+ return this.CHTML;
+ },
+ CHTMLstretchCoreH: function (node,w) {
+ return this.Core().CHTMLstretchH(this.CHTMLcoreNode(node),w);
+ },
+
+ CHTMLcreateNode: function (node) {
+ if (!this.CHTML) this.CHTML = {};
+ this.CHTML = CHTML.BBOX.zero();
+ if (this.href) node = CHTML.addElement(node,"a",{href:this.href, isMathJax:true});
+ if (!this.CHTMLnodeID) this.CHTMLnodeID = CHTML.GetID();
+ var id = (this.id || "MJXc-Node-"+this.CHTMLnodeID)+CHTML.idPostfix;
+ return this.CHTMLhandleAttributes(CHTML.addElement(node,"mjx-"+this.type,{id:id}));
+ },
+ CHTMLnodeElement: function () {
+ if (!this.CHTMLnodeID) {return null}
+ return document.getElementById((this.id||"MJXc-Node-"+this.CHTMLnodeID)+CHTML.idPostfix);
+ },
+
+ CHTMLlength2em: function (length,size) {
+ return CHTML.length2em(length,size,this.CHTML.scale);
+ },
+
+ CHTMLhandleAttributes: function (node) {
+ if (this["class"]) {
+ if (node.className) node.className += " "+this["class"];
+ else node.className = this["class"];
+ }
+ //
+ // Copy RDFa, aria, and other tags from the MathML to the CHTML
+ // output nodes. Don't copy those in the MML.nocopyAttributes list,
+ // the ignoreMMLattributes configuration list, or anything that
+ // already exists as a property of the node (e.g., no "onlick", etc.)
+ // If a name in the ignoreMMLattributes object is set to false, then
+ // the attribute WILL be copied.
+ //
+ if (this.attrNames) {
+ var copy = this.attrNames, skip = MML.nocopyAttributes, ignore = HUB.config.ignoreMMLattributes;
+ var defaults = (this.type === "mstyle" ? MML.math.prototype.defaults : this.defaults);
+ for (var i = 0, m = copy.length; i < m; i++) {
+ var id = copy[i];
+ if (ignore[id] == false || (!skip[id] && !ignore[id] &&
+ defaults[id] == null && typeof(node[id]) === "undefined")) {
+ node.setAttribute(id,this.attr[id])
+ }
+ }
+ }
+ return node;
+ },
+
+ CHTMLhandleScale: function (node) {
+ var scale = 1, parent = this.parent, pscale = (parent ? parent.CHTML.scale : 1);
+ var values = this.getValues("scriptlevel","fontsize");
+ values.mathsize = this.Get("mathsize",null,!this.isToken);
+ if (values.scriptlevel !== 0) {
+ if (values.scriptlevel > 2) values.scriptlevel = 2;
+ scale = Math.pow(this.Get("scriptsizemultiplier"),values.scriptlevel);
+ values.scriptminsize = CHTML.length2em(this.Get("scriptminsize"),.8,1);
+ if (scale < values.scriptminsize) scale = values.scriptminsize;
+ }
+ if (this.removedStyles && this.removedStyles.fontSize && !values.fontsize)
+ values.fontsize = this.removedStyles.fontSize;
+ if (values.fontsize && !this.mathsize) values.mathsize = values.fontsize;
+ if (values.mathsize !== 1) scale *= CHTML.length2em(values.mathsize,1,1);
+ var variant = this.CHTMLvariant;
+ if (variant && variant.style && variant.style["font-family"])
+ scale *= (CHTML.config.scale/100)/CHTML.scale;
+ this.CHTML.scale = scale; pscale = this.CHTML.rscale = scale/pscale;
+ if (Math.abs(pscale-1) < .001) pscale = 1;
+ if (node && pscale !== 1) node.style.fontSize = CHTML.Percent(pscale);
+ return scale;
+ },
+
+ CHTMLhandleStyle: function (node) {
+ if (!this.style) return;
+ var style = node.style;
+ style.cssText = this.style; this.removedStyles = {};
+ for (var i = 0, m = CHTML.removeStyles.length; i < m; i++) {
+ var id = CHTML.removeStyles[i];
+ if (style[id]) {
+ this.removedStyles[id] = style[id];
+ style[id] = "";
+ }
+ }
+ },
+
+ CHTMLhandleBBox: function (node) {
+ var BBOX = this.CHTML, style = node.style;
+ if (this.data.length === 1 && (this.data[0].CHTML||{}).pwidth) {
+ BBOX.pwidth = this.data[0].CHTML.pwidth;
+ BBOX.mwidth = this.data[0].CHTML.mwidth;
+ style.width = "100%";
+ } else if (BBOX.pwidth) {
+ BBOX.mwidth = CHTML.Em(BBOX.w);
+ style.width = "100%";
+ } else if (BBOX.w < 0) {
+ style.width = "0px";
+ style.marginRight = CHTML.Em(BBOX.w);
+ }
+ if (!this.style) return;
+ // ### FIXME: adjust for width, height, vertical-align?
+ for (var i = 0, m = CHTML.BBOX.styleAdjust.length; i < m; i++) {
+ var data = CHTML.BBOX.styleAdjust[i];
+ if (data && style[data[0]]) BBOX.adjust(style[data[0]],data[1],data[2],data[3]);
+ }
+ },
+
+ CHTMLhandleColor: function (node) {
+ if (this.mathcolor) {node.style.color = this.mathcolor}
+ else if (this.color) {node.style.color = this.color}
+ if (this.mathbackground) {node.style.backgroundColor = this.mathbackground}
+ else if (this.background) {node.style.backgroundColor = this.background}
+ },
+
+ CHTMLhandleSpace: function (node) {
+ if (!this.useMMLspacing) {
+ var space = this.texSpacing();
+ if (space !== "") {
+ this.CHTML.L = this.CHTMLlength2em(space);
+ node.className += " "+CHTML.SPACECLASS[space];
+ }
+ }
+ },
+
+ CHTMLhandleText: function (node,text,variant) {
+ if (node.firstChild && !this.CHTML) this.CHTML = CHTML.BBOX.empty();
+ this.CHTML = CHTML.handleText(node,text,variant,this.CHTML);
+ },
+
+ CHTMLgetVariant: function () {
+ var values = this.getValues("mathvariant","fontfamily","fontweight","fontstyle"), style;
+ values.hasVariant = this.Get("mathvariant",true); // null if not explicitly specified
+ if (this.removedStyles) {
+ style = this.removedStyles;
+ if (style.fontFamily) values.family = style.fontFamily;
+ if (style.fontWeight) values.weight = style.fontWeight;
+ if (style.fontStyle) values.style = style.fontStyle;
+ }
+ if (!values.hasVariant) {
+ if (values.fontfamily) values.family = values.fontfamily;
+ if (values.fontweight) values.weight = values.fontweight;
+ if (values.fontstyle) values.style = values.fontstyle;
+ }
+ if (values.weight && values.weight.match(/^\d+$/))
+ values.weight = (parseInt(values.weight) > 600 ? "bold" : "normal");
+ var variant = values.mathvariant; if (this.variantForm) variant = "-TeX-variant";
+ if (values.family && !values.hasVariant) {
+ if (!values.weight && values.mathvariant.match(/bold/)) values.weight = "bold";
+ if (!values.style && values.mathvariant.match(/italic/)) values.style = "italic";
+ this.CHTMLvariant = {fonts:[], noRemap:true, cache:{}, style: {
+ "font-family":values.family, "font-weight":values.weight||"normal", "font-style":values.style||"normal"
+ }};
+ return;
+ }
+ if (values.weight === "bold") {
+ variant = {
+ normal:MML.VARIANT.BOLD, italic:MML.VARIANT.BOLDITALIC,
+ fraktur:MML.VARIANT.BOLDFRAKTUR, script:MML.VARIANT.BOLDSCRIPT,
+ "sans-serif":MML.VARIANT.BOLDSANSSERIF,
+ "sans-serif-italic":MML.VARIANT.SANSSERIFBOLDITALIC
+ }[variant]||variant;
+ } else if (values.weight === "normal") {
+ variant = {
+ bold:MML.VARIANT.normal, "bold-italic":MML.VARIANT.ITALIC,
+ "bold-fraktur":MML.VARIANT.FRAKTUR, "bold-script":MML.VARIANT.SCRIPT,
+ "bold-sans-serif":MML.VARIANT.SANSSERIF,
+ "sans-serif-bold-italic":MML.VARIANT.SANSSERIFITALIC
+ }[variant]||variant;
+ }
+ if (values.style === "italic") {
+ variant = {
+ normal:MML.VARIANT.ITALIC, bold:MML.VARIANT.BOLDITALIC,
+ "sans-serif":MML.VARIANT.SANSSERIFITALIC,
+ "bold-sans-serif":MML.VARIANT.SANSSERIFBOLDITALIC
+ }[variant]||variant;
+ } else if (values.style === "normal") {
+ variant = {
+ italic:MML.VARIANT.NORMAL, "bold-italic":MML.VARIANT.BOLD,
+ "sans-serif-italic":MML.VARIANT.SANSSERIF,
+ "sans-serif-bold-italic":MML.VARIANT.BOLDSANSSERIF
+ }[variant]||variant;
+ }
+ this.CHTMLvariant = CHTML.FONTDATA.VARIANT[variant] ||
+ CHTML.FONTDATA.VARIANT[MML.VARIANT.NORMAL];
+ },
+
+ CHTMLbboxFor: function (n) {
+ if (this.data[n] && this.data[n].CHTML) return this.data[n].CHTML;
+ return CHTML.BBOX.zero();
+ },
+ //
+ // Debugging function to see if internal BBox matches actual bbox
+ //
+ CHTMLdrawBBox: function (node,bbox) {
+ if (!bbox) bbox = this.CHTML;
+ var box = CHTML.Element("mjx-box",
+ {style:{opacity:.25,"margin-left":CHTML.Em(-(bbox.w+(bbox.R||0)))}},[
+ ["mjx-box",{style:{
+ height:CHTML.Em(bbox.h),width:CHTML.Em(bbox.w),
+ "background-color":"red"
+ }}],
+ ["mjx-box",{style:{
+ height:CHTML.Em(bbox.d),width:CHTML.Em(bbox.w),
+ "margin-left":CHTML.Em(-bbox.w),"vertical-align":CHTML.Em(-bbox.d),
+ "background-color":"green"
+ }}]
+ ]);
+ if (node.nextSibling) {node.parentNode.insertBefore(box,node.nextSibling)}
+ else {node.parentNode.appendChild(box)}
+ },
+
+ CHTMLnotEmpty: function (mml) {
+ while (mml && mml.data.length < 2 && (mml.type === "mrow" || mml.type === "texatom"))
+ mml = mml.data[0];
+ return !!mml;
+ }
+
+ },{
+ //
+ // Autoload files based on node type or file name
+ //
+ CHTMLautoload: function () {
+ this.constructor.Augment({toCommonHTML: MML.mbase.CHTMLautoloadFail});
+ var file = CHTML.autoloadDir+"/"+this.type+".js";
+ HUB.RestartAfter(AJAX.Require(file));
+ },
+ CHTMLautoloadFail: function () {
+ throw Error("CommonHTML can't autoload '"+ this.type + "'");
+ },
+ CHTMLautoloadList: {},
+ CHTMLautoloadFile: function (name) {
+ if (MML.mbase.CHTMLautoloadList.hasOwnProperty(name)) {
+ throw Error("CommonHTML can't autoload file '"+name+"'");
+ }
+ MML.mbase.CHTMLautoloadList[name] = true;
+ var file = CHTML.autoloadDir+"/"+name+".js";
+ HUB.RestartAfter(AJAX.Require(file));
+ },
+ //
+ // For use with embellished operators
+ //
+ CHTMLstretchV: function (h,d) {
+ this.Core().CHTMLstretchV(h,d);
+ this.toCommonHTML(this.CHTMLnodeElement(),{stretch:true});
+ return this.CHTML;
+ },
+ CHTMLstretchH: function (node,w) {
+ this.CHTMLupdateFrom(this.CHTMLstretchCoreH(node,w));
+ this.toCommonHTML(node,{stretch:true});
+ return this.CHTML;
+ }
+ });
+
+ /********************************************************/
+
+ MML.chars.Augment({
+ toCommonHTML: function (node,options) {
+ this.CHTML = null;
+ if (options == null) options = {};
+ var text = this.toString();
+ if (options.remap) text = options.remap(text,options.remapchars);
+ this.CHTMLhandleText(node,text,options.variant||this.parent.CHTMLvariant);
+ }
+ });
+ MML.entity.Augment({
+ toCommonHTML: function (node,options) {
+ if (options == null) options = {};
+ var text = this.toString();
+ if (options.remapchars) text = options.remap(text,options.remapchars);
+ this.CHTMLhandleText(node,text,options.variant||this.parent.CHTMLvariant);
+ }
+ });
+
+ /********************************************************/
+
+ MML.math.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLdefaultNode(node);
+ if (this.CHTML.w < 0) {
+ node.parentNode.style.width = "0px";
+ node.parentNode.style.marginRight = CHTML.Em(this.CHTML.w);
+ }
+ var alttext = this.Get("alttext");
+ if (alttext && !node.getAttribute("aria-label")) node.setAttribute("aria-label",alttext);
+ if (this.CHTML.pwidth) {
+ node.parentNode.style.minWidth = this.CHTML.mwidth||CHTML.Em(this.CHTML.w);
+ node.parentNode.className = "mjx-full-width "+node.parentNode.className;
+ node.style.width = this.CHTML.pwidth;
+ } else if (!this.isMultiline && this.Get("display") === "block") {
+ var values = this.getValues("indentalignfirst","indentshiftfirst","indentalign","indentshift");
+ if (values.indentalignfirst !== MML.INDENTALIGN.INDENTALIGN) values.indentalign = values.indentalignfirst;
+ if (values.indentalign === MML.INDENTALIGN.AUTO) values.indentalign = CONFIG.displayAlign;
+ if (values.indentshiftfirst !== MML.INDENTSHIFT.INDENTSHIFT) values.indentshift = values.indentshiftfirst;
+ if (values.indentshift === "auto") values.indentshift = "0";
+ var shift = this.CHTMLlength2em(values.indentshift,CHTML.cwidth);
+ if (CONFIG.displayIndent !== "0") {
+ var indent = this.CHTMLlength2em(CONFIG.displayIndent,CHTML.cwidth);
+ shift += (values.indentalign === MML.INDENTALIGN.RIGHT ? -indent : indent);
+ }
+ var styles = node.parentNode.parentNode.style;
+ node.parentNode.style.textAlign = styles.textAlign = values.indentalign;
+ // ### FIXME: make percentage widths respond to changes in container
+ if (shift) {
+ if (values.indentalign === 'right') node.style.marginRight = CHTML.Em(-shift);
+ shift *= CHTML.em/CHTML.outerEm;
+ HUB.Insert(styles,({
+ left: {textIndent: CHTML.Em(shift)},
+ right: {display: 'flex', flexDirection: 'row-reverse'},
+ center: {textIndent: CHTML.Em(2*shift)}
+ })[values.indentalign]);
+ }
+ }
+ return node;
+ }
+ });
+
+ /********************************************************/
+
+ MML.mi.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLdefaultNode(node);
+ var bbox = this.CHTML, text = this.data.join("");
+ if (bbox.skew != null && !CHTML.isChar(text)) delete bbox.skew;
+ if (bbox.r > bbox.w && CHTML.isChar(text) && !this.CHTMLvariant.noIC) {
+ bbox.ic = bbox.r - bbox.w; bbox.w = bbox.r;
+ node.lastChild.style.paddingRight = CHTML.Em(bbox.ic);
+ }
+ return node;
+ }
+ });
+
+ /********************************************************/
+
+ MML.mn.Augment({
+ CHTMLremapMinus: function (text) {return text.replace(/^-/,"\u2212")},
+ toCommonHTML: function (node) {
+ node = this.CHTMLdefaultNode(node,{childOptions:{remap:this.CHTMLremapMinus}});
+ var bbox = this.CHTML, text = this.data.join("");
+ if (bbox.skew != null && !CHTML.isChar(text)) delete bbox.skew;
+ if (bbox.r > bbox.w && CHTML.isChar(text) && !this.CHTMLvariant.noIC) {
+ bbox.ic = bbox.r - bbox.w; bbox.w = bbox.r;
+ node.lastChild.style.paddingRight = CHTML.Em(bbox.ic);
+ }
+ return node;
+ }
+ });
+
+ /********************************************************/
+
+ MML.mo.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLgetVariant();
+ this.CHTMLhandleScale(node);
+ CHTML.BBOX.empty(this.CHTML);
+
+ var values = this.getValues("displaystyle","largeop");
+ values.variant = this.CHTMLvariant;
+ values.text = this.data.join("");
+ if (values.text == "") {
+ if (this.fence) node.style.width = CHTML.Em(CHTML.TEX.nulldelimiterspace);
+ } else {
+ this.CHTMLadjustAccent(values);
+ this.CHTMLadjustVariant(values);
+
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ this.CHTMLaddChild(node,i,{childOptions:{
+ variant: values.mathvariant,
+ remap: this.remap,
+ remapchars: values.remapchars
+ }});
+ }
+ if (!CHTML.isChar(values.text)) delete this.CHTML.skew;
+ else if (this.CHTML.w === 0 && this.CHTML.l < 0) this.CHTMLfixCombiningChar(node);
+ if (values.largeop) this.CHTMLcenterOp(node);
+ }
+
+ this.CHTML.clean();
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleColor(node);
+
+ return node;
+ },
+ CHTMLhandleSpace: function (node) {
+ if (this.hasMMLspacing()) {
+ var values = this.getValues("scriptlevel","lspace","rspace");
+ values.lspace = Math.max(0,this.CHTMLlength2em(values.lspace));
+ values.rspace = Math.max(0,this.CHTMLlength2em(values.rspace));
+ if (values.scriptlevel > 0) {
+ if (!this.hasValue("lspace")) values.lspace = .15;
+ if (!this.hasValue("rspace")) values.rspace = .15;
+ }
+ var core = this, parent = this.Parent();
+ while (parent && parent.isEmbellished() && parent.Core() === core)
+ {core = parent; parent = parent.Parent(); node = core.CHTMLnodeElement()}
+ if (values.lspace) node.style.paddingLeft = CHTML.Em(values.lspace);
+ if (values.rspace) node.style.paddingRight = CHTML.Em(values.rspace);
+ this.CHTML.L = values.lspace; this.CHTML.R = values.rspace;
+ } else {
+ this.SUPER(arguments).CHTMLhandleSpace.apply(this,arguments);
+ }
+ },
+ CHTMLadjustAccent: function (data) {
+ var parent = this.CoreParent(); data.parent = parent;
+ if (CHTML.isChar(data.text) && parent && parent.isa(MML.munderover)) {
+ var over = parent.data[parent.over], under = parent.data[parent.under];
+ if (over && this === over.CoreMO() && parent.Get("accent")) {
+ data.remapchars = CHTML.FONTDATA.REMAPACCENT;
+ } else if (under && this === under.CoreMO() && parent.Get("accentunder")) {
+ data.remapchars = CHTML.FONTDATA.REMAPACCENTUNDER;
+ }
+ }
+ },
+ CHTMLadjustVariant: function (data) {
+ var parent = data.parent,
+ isScript = (parent && parent.isa(MML.msubsup) && this !== parent.data[parent.base]);
+ if (data.largeop) data.mathvariant = (data.displaystyle ? "-largeOp" : "-smallOp");
+ if (isScript) {
+ data.remapchars = this.remapChars;
+ if (data.text.match(/['`"\u00B4\u2032-\u2037\u2057]/))
+ data.mathvariant = "-TeX-variant"; // ### FIXME: handle other fonts
+ }
+ },
+ CHTMLfixCombiningChar: function (node) {
+ //
+ // IE doesn't display combining chararacters unless they combine with
+ // something, so put them over a space and remove the space's width
+ //
+ node = node.firstChild;
+ var space = CHTML.Element("mjx-box",{style:{width:".25em","margin-left":"-.25em"}});
+ node.insertBefore(space,node.firstChild);
+ },
+ CHTMLcenterOp: function (node) {
+ var bbox = this.CHTML;
+ var p = (bbox.h - bbox.d)/2 - CHTML.TEX.axis_height;
+ if (Math.abs(p) > .001) node.style.verticalAlign = CHTML.Em(-p);
+ bbox.h -= p; bbox.d += p;
+ if (bbox.r > bbox.w) {
+ bbox.ic = bbox.r - bbox.w; bbox.w = bbox.r;
+ node.style.paddingRight = CHTML.Em(bbox.ic);
+ }
+ },
+ CHTMLcanStretch: function (direction,H,D) {
+ if (!this.Get("stretchy")) return false;
+ var c = this.data.join(""); if (!CHTML.isChar(c)) return false;
+ var values = {text: c};
+ this.CHTMLadjustAccent(values);
+ if (values.remapchars) c = values.remapchars[c]||c;
+ c = CHTML.FONTDATA.DELIMITERS[c.charCodeAt(0)];
+ var stretch = (c && c.dir === direction.substr(0,1));
+ if (stretch) {
+ stretch = (this.CHTML.h !== H || this.CHTML.d !== D ||
+ !!this.Get("minsize",true) || !!this.Get("maxsize",true));
+ if (stretch) this.CHTML.stretch = true;
+ }
+ return stretch;
+ },
+ CHTMLstretchV: function (h,d) {
+ var node = this.CHTMLnodeElement(), bbox = this.CHTML;
+ var values = this.getValues("symmetric","maxsize","minsize");
+ //
+ // Determine the height needed
+ //
+ var H, a = CHTML.TEX.axis_height;
+ if (values.symmetric) {H = 2*Math.max(h-a,d+a)} else {H = h + d}
+ values.maxsize = this.CHTMLlength2em(values.maxsize,bbox.h+bbox.d);
+ values.minsize = this.CHTMLlength2em(values.minsize,bbox.h+bbox.d);
+ H = Math.max(values.minsize,Math.min(values.maxsize,H));
+ //
+ // If we are not already stretched to this height
+ //
+ if (H !== bbox.sH) {
+ //
+ // Get a delimiter of the proper height and save the height
+ //
+ if (H != values.minsize)
+ {H = [Math.max(H*CHTML.TEX.delimiterfactor/1000,H-CHTML.TEX.delimitershortfall),H]}
+ while (node.firstChild) node.removeChild(node.firstChild);
+ this.CHTML = bbox = CHTML.createDelimiter(node,this.data.join("").charCodeAt(0),H,bbox);
+ bbox.sH = (H instanceof Array ? H[1] : H);
+ //
+ // Reposition as needed
+ //
+ if (values.symmetric) {H = (bbox.h + bbox.d)/2 + a}
+ else {H = (bbox.h + bbox.d) * h/(h + d)}
+ H -= bbox.h;
+ if (Math.abs(H) > .05) {
+ node.style.verticalAlign = CHTML.Em(H);
+ bbox.h += H; bbox.d -= H; bbox.t += H; bbox.b -= H;
+ }
+ }
+ return this.CHTML;
+ },
+ CHTMLstretchH: function (node,W) {
+ var bbox = this.CHTML;
+ var values = this.getValues("maxsize","minsize","mathvariant","fontweight");
+ if ((values.fontweight === "bold" || (this.removedStyles||{}).fontWeight === "bold" ||
+ parseInt(values.fontweight) >= 600) && !this.Get("mathvariant",true))
+ values.mathvariant = MML.VARIANT.BOLD;
+ values.maxsize = this.CHTMLlength2em(values.maxsize,bbox.w);
+ values.minsize = this.CHTMLlength2em(values.minsize,bbox.w);
+ W = Math.max(values.minsize,Math.min(values.maxsize,W));
+ if (W !== bbox.sW) {
+ while (node.firstChild) node.removeChild(node.firstChild);
+ this.CHTML = bbox = CHTML.createDelimiter(node,this.data.join("").charCodeAt(0),W,bbox,values.mathvariant);
+ bbox.sW = W;
+ }
+ return this.CHTML;
+ }
+
+ });
+
+ /********************************************************/
+
+ MML.mtext.Augment({
+ CHTMLgetVariant: function () {
+ if (CHTML.config.mtextFontInherit || this.Parent().type === "merror") {
+ var scale = (CHTML.config.scale/100)/CHTML.scale;
+ var variant = {cache:{}, fonts:[], className:"MJXc-font-inherit", rscale:scale,
+ style:{"font-size":CHTML.Percent(scale)}};
+ var name = this.Get("mathvariant");
+ if (name.match(/bold/)) variant.style["font-weight"] = "bold";
+ if (name.match(/italic|-tex-mathit/)) variant.style["font-style"] = "italic";
+ if (name === "monospace") variant.className += " MJXc-monospace-font";
+ if (name === "double-struck") variant.className += " MJXc-double-struck-font";
+ if (name.match(/fraktur/)) variant.className += " MJXc-fraktur-font";
+ if (name.match(/sans-serif/)) variant.className += " MJXc-sans-serif-font";
+ if (name.match(/script/)) variant.className += " MJXc-script-font";
+ this.CHTMLvariant = variant;
+ } else {
+ this.SUPER(arguments).CHTMLgetVariant.call(this);
+ }
+ }
+ });
+
+ /********************************************************/
+
+ MML.merror.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLdefaultNode(node);
+ var bbox = this.CHTML;
+ //
+ // Adjust for font-size: 90%
+ //
+ bbox.rescale(.9);
+ //
+ // Adjust for padding and border
+ //
+ bbox.h += 3/CHTML.em; if (bbox.h > bbox.t) bbox.t = bbox.h;
+ bbox.d += 3/CHTML.em; if (bbox.d > bbox.b) bbox.b = bbox.d;
+ bbox.w += 8/CHTML.em; bbox.r = bbox.w; bbox.l = 0;
+ return node;
+ }
+ });
+
+ /********************************************************/
+
+ MML.mspace.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLhandleScale(node);
+ var values = this.getValues("height","depth","width");
+ var w = this.CHTMLlength2em(values.width),
+ h = this.CHTMLlength2em(values.height),
+ d = this.CHTMLlength2em(values.depth);
+ var bbox = this.CHTML;
+ bbox.w = bbox.r = w; bbox.h = bbox.t = h; bbox.d = bbox.b = d; bbox.l = 0;
+ if (w < 0) {node.style.marginRight = CHTML.Em(w); w = 0}
+ node.style.width = CHTML.Em(w);
+ node.style.height = CHTML.Em(Math.max(0,h+d));
+ if (d) node.style.verticalAlign = CHTML.Em(-d);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ return node;
+ }
+ });
+
+ /********************************************************/
+
+ MML.mpadded.Augment({
+ toCommonHTML: function (node,options) {
+ var child;
+ if (options && options.stretch) {
+ node = node.firstChild; child = node.firstChild;
+ } else {
+ node = this.CHTMLdefaultNode(node,{childNodes:"mjx-box", forceChild:true});
+ child = node.firstChild; node = CHTML.addElement(node,"mjx-block");
+ node.appendChild(child); CHTML.addElement(node,"mjx-strut"); // force proper alignment of short heights
+ }
+ var cbox = this.CHTMLbboxFor(0);
+ var values = this.getValues("width","height","depth","lspace","voffset");
+ var x = 0, y = 0, w = cbox.w, h = cbox.h, d = cbox.d;
+ child.style.width = 0; child.style.margin = CHTML.Em(-h)+" 0 "+CHTML.Em(-d);
+ if (values.width !== "") w = this.CHTMLdimen(values.width,"w",w,0);
+ if (values.height !== "") h = this.CHTMLdimen(values.height,"h",h,0);
+ if (values.depth !== "") d = this.CHTMLdimen(values.depth,"d",d,0);
+ if (values.voffset !== "") {
+ y = this.CHTMLdimen(values.voffset);
+ if (y) {
+ child.style.position = "relative";
+ child.style.top = CHTML.Em(-y);
+ }
+ }
+ if (values.lspace !== "") {
+ x = this.CHTMLdimen(values.lspace);
+ if (x) {
+ child.style.position = "relative";
+ child.style.left = CHTML.Em(x);
+ }
+ }
+ node.style.width = 0;
+ node.style.marginTop = CHTML.Em(h-STRUTHEIGHT);
+ node.style.padding = "0 "+CHTML.Em(w)+" "+CHTML.Em(d)+" 0";
+ var bbox = CHTML.BBOX({w:w, h:h, d:d, l:0, r:w, t:h, b:d,
+ scale:this.CHTML.scale, rscale:this.CHTML.rscale});
+ bbox.combine(cbox,x,y);
+ bbox.w = w; bbox.h = h; bbox.d = d;
+ this.CHTML = bbox;
+ return node.parentNode;
+ },
+ CHTMLstretchV: MML.mbase.CHTMLstretchV,
+ CHTMLstretchH: MML.mbase.CHTMLstretchH,
+ CHTMLdimen: function (length,d,D,m) {
+ if (m == null) {m = -BIGDIMEN}
+ length = String(length);
+ var match = length.match(/width|height|depth/);
+ var size = (match ? this.CHTML[match[0].charAt(0)] : (d ? this.CHTML[d] : 0));
+ var dimen = (this.CHTMLlength2em(length,size)||0);
+ if (length.match(/^[-+]/) && D != null) dimen += D;
+ if (m != null) dimen = Math.max(m,dimen);
+ return dimen;
+ }
+ });
+
+ /********************************************************/
+
+ MML.munderover.Augment({
+ toCommonHTML: function (node,options) {
+ var values = this.getValues("displaystyle","accent","accentunder","align");
+ var base = this.data[this.base];
+ if (!values.displaystyle && base != null &&
+ (base.movablelimits || base.CoreMO().Get("movablelimits")))
+ return MML.msubsup.prototype.toCommonHTML.call(this,node,stretch);
+ //
+ // Get the nodes for base and limits
+ //
+ var under, over, nodes = [], stretch = false;
+ if (options && options.stretch) {
+ if (this.data[this.base]) base = CHTML.getNode(node,"mjx-op");
+ if (this.data[this.under]) under = CHTML.getNode(node,"mjx-under");
+ if (this.data[this.over]) over = CHTML.getNode(node,"mjx-over");
+ nodes[0] = base; nodes[1] = under||over; nodes[2] = over;
+ stretch = true;
+ } else {
+ var types = ["mjx-op","mjx-under","mjx-over"];
+ if (this.over === 1) types[1] = types[2];
+ node = this.CHTMLdefaultNode(node,{
+ childNodes:types, noBBox:true, forceChild:true, minChildren: 2
+ });
+ nodes[0] = base = node.removeChild(node.firstChild);
+ nodes[1] = under = over = node.removeChild(node.firstChild);
+ if (node.firstChild) nodes[2] = over = node.removeChild(node.firstChild);
+ }
+ //
+ // Get the bounding boxes and the maximum width
+ //
+ var boxes = [], W = this.CHTMLgetBBoxes(boxes,nodes,values);
+ var bbox = boxes[this.base], BBOX = this.CHTML;
+ BBOX.w = W; BBOX.h = bbox.h; BBOX.d = bbox.d; // modified below
+ //
+ // Adjust for bases shorter than the center line (#1657)
+ // (the center line really depends on the surrounding font, so
+ // it should be measured along with ems and exs, but currently isn't.
+ // so this value is an approximation that is reasonable for most fonts.)
+ //
+ if (bbox.h < .35) base.style.marginTop = CHTML.Em(bbox.h - .35);
+ //
+ // Use a minimum height for accents (#1706)
+ // (same issues with the center line as above)
+ //
+ if (values.accent && bbox.h < CHTML.TEX.x_height) {
+ BBOX.h += CHTML.TEX.x_height - bbox.h;
+ base.style.marginTop = CHTML.Em(CHTML.TEX.x_height - Math.max(bbox.h,.35));
+ bbox.h = CHTML.TEX.x_height;
+ }
+ //
+ // Add over- and under-scripts
+ //
+ var stack = base, delta = 0;
+ if (bbox.ic) {delta = 1.3*bbox.ic + .05} // make faked IC be closer to expeted results
+ if (this.data[this.over]) stack = this.CHTMLaddOverscript(over,boxes,values,delta,base,stretch);
+ if (this.data[this.under]) this.CHTMLaddUnderscript(under,boxes,values,delta,node,stack,stretch);
+ else if (!stretch) node.appendChild(stack);
+ //
+ // Handle horizontal positions
+ //
+ this.CHTMLplaceBoxes(base,under,over,values,boxes);
+ return node;
+ },
+ //
+ // Get the bounding boxes for the children, stretch
+ // any stretchable elements, and compute the maximum width
+ //
+ CHTMLgetBBoxes: function (bbox,nodes,values) {
+ var i, m = this.data.length, scale,
+ w = -BIGDIMEN, // maximum width of non-stretchy items
+ W = w; // maximum width of all items
+ //
+ // Get the maximum width
+ //
+ for (i = 0; i < m; i++) {
+ bbox[i] = this.CHTMLbboxFor(i); bbox[i].x = bbox[i].y = 0;
+ if (this.data[i]) bbox[i].stretch = this.data[i].CHTMLcanStretch("Horizontal");
+ scale = (i === this.base ? 1 : bbox[i].rscale);
+ if (i !== this.base) {delete bbox[i].L; delete bbox[i].R} // these are overridden by CSS
+ W = Math.max(W,scale*(bbox[i].w + (bbox[i].L||0) + (bbox[i].R||0)));
+ if (!bbox[i].stretch && W > w) w = W;
+ }
+ if (w === -BIGDIMEN) w = W;
+ //
+ // Stretch those parts that need it
+ //
+ for (i = 0; i < m; i++) {
+ if (bbox[i].stretch) {
+ scale = (i === this.base ? 1 : bbox[i].rscale);
+ bbox[i] = this.data[i].CHTMLstretchH(nodes[i].firstChild,w/scale);
+ bbox[i].x = bbox[i].y = 0;
+ W = Math.max(W,scale*(bbox[i].w + (bbox[i].L||0) + (bbox[i].R||0)));
+ }
+ }
+ if (!bbox[this.base]) bbox[this.base] = CHTML.BBOX.empty();
+ return W;
+ },
+ //
+ // Add an overscript
+ //
+ CHTMLaddOverscript: function (over,boxes,values,delta,base,stretch) {
+ var BBOX = this.CHTML;
+ var z1, z2, z3 = CHTML.TEX.big_op_spacing5, k;
+ var obox = boxes[this.over], bbox = boxes[this.base], scale = obox.rscale;
+ //
+ // Put the base and script into a stack
+ //
+ if (!stretch) {
+ var stack = CHTML.Element("mjx-stack");
+ stack.appendChild(over); stack.appendChild(base);
+ }
+ if (obox.D) obox.d = obox.D;
+ if (obox.d < 0) {
+ //
+ // For negative depths, set the height and align to top
+ // in order to avoid extra baseline space
+ //
+ over.firstChild.style.verticalAlign = "top";
+ over.style.height = CHTML.Em(obox.h+obox.d);
+ }
+ //
+ // Determine the spacing
+ //
+ obox.x = 0;
+ if (values.accent) {
+ if (obox.w < .001) obox.x += (obox.r - obox.l)/2; // center combining accents
+ k = CHTML.TEX.rule_thickness; z3 = 0;
+ if (bbox.skew) {
+ obox.x += scale*bbox.skew; BBOX.skew = scale*bbox.skew;
+ if (obox.x+scale*obox.w > BBOX.w) BBOX.skew += (BBOX.w - (obox.x+scale*obox.w))/2;
+ }
+ } else {
+ z1 = CHTML.TEX.big_op_spacing1;
+ z2 = CHTML.TEX.big_op_spacing3;
+ k = Math.max(z1,z2-Math.max(0,scale*obox.d));
+ }
+ obox.x += delta/2; obox.y = BBOX.h + k + z3 + scale*obox.d;
+ //
+ // Position the overscript
+ //
+ if (k) over.style.paddingBottom = CHTML.Em(k/scale);
+ if (z3) over.style.paddingTop = CHTML.Em(z3/scale);
+ return stack;
+ },
+ //
+ // Add an underscript
+ //
+ CHTMLaddUnderscript: function (under,boxes,values,delta,node,stack,stretch) {
+ var BBOX = this.CHTML;
+ var z1, z2, z3 = CHTML.TEX.big_op_spacing5, k;
+ var ubox = boxes[this.under], scale = ubox.rscale;
+ //
+ // Create a table for the underscript
+ //
+ if (!stretch) {
+ CHTML.addElement(node,"mjx-itable",{},[
+ ["mjx-row",{},[["mjx-cell"]]],
+ ["mjx-row"]
+ ]);
+ node.firstChild.firstChild.firstChild.appendChild(stack);
+ node.firstChild.lastChild.appendChild(under);
+ }
+ if (ubox.D) ubox.d = ubox.D;
+ if (ubox.d < 0) {
+ //
+ // For negative depths, set the height and align to top
+ // in order to avoid extra baseline space
+ //
+ under.firstChild.style.verticalAlign = "top";
+ node.firstChild.style.marginBottom = CHTML.Em(ubox.d);
+ }
+ //
+ // determine the spacing
+ //
+ if (values.accentunder) {
+ k = 2*CHTML.TEX.rule_thickness; z3 = 0;
+ } else {
+ z1 = CHTML.TEX.big_op_spacing2;
+ z2 = CHTML.TEX.big_op_spacing4;
+ k = Math.max(z1,z2-scale*ubox.h);
+ }
+ ubox.x = -delta/2; ubox.y = -(BBOX.d + k + z3 + scale*ubox.h);
+ //
+ // Position the underscript
+ //
+ if (k) under.style.paddingTop = CHTML.Em(k/scale);
+ if (z3) under.style.paddingBottom = CHTML.Em(z3/scale);
+ },
+ //
+ // Center boxes horizontally, taking offsets into account
+ //
+ CHTMLplaceBoxes: function (base,under,over,values,boxes) {
+ var W = this.CHTML.w, i, m = boxes.length, scale;
+ var BBOX = CHTML.BBOX.zero();
+ BBOX.scale = this.CHTML.scale; BBOX.rscale = this.CHTML.rscale;
+ boxes[this.base].x = boxes[this.base].y = 0; var dx = BIGDIMEN;
+ for (i = 0; i < m; i++) {
+ scale = (i === this.base ? 1 : boxes[i].rscale);
+ var w = scale*(boxes[i].w + (boxes[i].L||0) + (boxes[i].R||0));
+ boxes[i].x += {left:0, center:(W-w)/2, right:W-w}[values.align];
+ if (boxes[i].x < dx) dx = boxes[i].x;
+ }
+ for (i = 0; i < m; i++) {
+ if (this.data[i]) {
+ scale = (i === this.base ? 1 : boxes[i].rscale);
+ if (boxes[i].x - dx) {
+ var node = (i === this.base ? base : i === this.over ? over : under);
+ node.style.paddingLeft = CHTML.Em((boxes[i].x-dx)/scale);
+ }
+ BBOX.combine(boxes[i],boxes[i].x-dx,boxes[i].y);
+ }
+ }
+ this.CHTML = BBOX;
+ },
+ CHTMLstretchV: MML.mbase.CHTMLstretchV,
+ CHTMLstretchH: MML.mbase.CHTMLstretchH,
+ CHTMLchildNode: function (node,i) {
+ var types = ["mjx-op","mjx-under","mjx-over"];
+ if (this.over === 1) types[1] = types[2];
+ return CHTML.getNode(node,types[i]);
+ }
+ });
+
+ /********************************************************/
+
+ MML.msubsup.Augment({
+ toCommonHTML: function (node,options) {
+ var values = this.getValues(
+ "displaystyle","subscriptshift","superscriptshift","texprimestyle"
+ );
+ //
+ // Get the nodes for base and limits
+ //
+ var base, sub, sup;
+ if (options && options.stretch) {
+ if (this.data[this.base]) base = CHTML.getNode(node,"mjx-base");
+ if (this.data[this.sub]) sub = CHTML.getNode(node,"mjx-sub");
+ if (this.data[this.sup]) sup = CHTML.getNode(node,"mjx-sup");
+ stack = CHTML.getNode(node,"mjx-stack");
+ } else {
+ var types = ["mjx-base","mjx-sub","mjx-sup"];
+ if (this.sup === 1) types[1] = types[2];
+ node = this.CHTMLdefaultNode(node,{
+ childNodes:types, noBBox:true, forceChild:true, minChildren: 3
+ });
+ base = node.childNodes[this.base];
+ sub = node.childNodes[this.sub]; sup = node.childNodes[this.sup];
+ if (!this.CHTMLnotEmpty(this.data[this.sub])) {node.removeChild(sub); sub = null}
+ if (!this.CHTMLnotEmpty(this.data[this.sup])) {node.removeChild(sup); sup = null}
+ if (node.childNodes.length === 3) {
+ var stack = CHTML.addElement(node,"mjx-stack");
+ stack.appendChild(sup); stack.appendChild(sub);
+ }
+ }
+ //
+ // Get the bounding boxes and maximum width of scripts
+ //
+ var boxes = [], BBOX = CHTML.BBOX.empty(this.CHTML);
+ for (var i = 0, m = this.data.length; i < m; i++) boxes[i] = this.CHTMLbboxFor(i);
+ var bbox = boxes[this.base] || CHTML.BBOX.empty(),
+ sbox = boxes[this.sub], Sbox = boxes[this.sup];
+ var sscale = (sub ? sbox.rscale : 1), Sscale = (sup ? Sbox.rscale : 1);
+ BBOX.combine(bbox,0,0);
+ //
+ // Get initial values for parameters
+ //
+ var ex = CHTML.TEX.x_height, s = CHTML.TEX.scriptspace;
+ var q = CHTML.TEX.sup_drop * Sscale, r = CHTML.TEX.sub_drop * sscale;
+ var u = bbox.h - q, v = bbox.d + r, delta = 0, p;
+ if (bbox.ic) {
+ BBOX.w -= bbox.ic; // remove IC (added by mo and mi)
+ base.style.marginRight = CHTML.Em(-bbox.ic);
+ delta = 1.3*bbox.ic + .05; // make faked IC be closer to expeted results
+ }
+ var bmml = this.data[this.base];
+ if (bmml) {
+ if ((bmml.type === "mrow" || bmml.type === "mstyle") && bmml.data.length === 1) bmml = bmml.data[0];
+ if (bmml.type === "mi" || bmml.type === "mo") {
+ if (CHTML.isChar(bmml.data.join("")) && bbox.rscale === 1 && !bbox.sH &&
+ !bmml.Get("largeop")) {u = v = 0}
+ }
+ }
+ values.subscriptshift = (values.subscriptshift === "" ? 0 : this.CHTMLlength2em(values.subscriptshift));
+ values.superscriptshift = (values.superscriptshift === "" ? 0 : this.CHTMLlength2em(values.superscriptshift));
+ //
+ // Add the super- and subscripts
+ //
+ var x = BBOX.w; if (sub) sbox.w += s; if (sup) Sbox.w += s;
+ if (!sup) {
+ if (sub) {
+ v = Math.max(v,CHTML.TEX.sub1,sscale*sbox.h-(4/5)*ex,values.subscriptshift);
+ sub.style.verticalAlign = CHTML.Em(-v/sscale);
+ sub.style.paddingRight = CHTML.Em(s/sscale);
+ BBOX.combine(sbox,x,-v);
+ }
+ } else {
+ if (!sub) {
+ p = CHTML.TEX[(values.displaystyle ? "sup1" : (values.texprimestyle ? "sup3" : "sup2"))];
+ u = Math.max(u,p,Sscale*Sbox.d+(1/4)*ex,values.superscriptshift);
+ sup.style.verticalAlign = CHTML.Em(u/Sscale);
+ sup.style.paddingLeft = CHTML.Em(delta/Sscale);
+ sup.style.paddingRight = CHTML.Em(s/Sscale);
+ BBOX.combine(Sbox,x+delta,u);
+ } else {
+ v = Math.max(v,CHTML.TEX.sub2);
+ var t = CHTML.TEX.rule_thickness;
+ if ((u - Sscale*Sbox.d) - (sscale*sbox.h - v) < 3*t) {
+ v = 3*t - u + Sscale*Sbox.d + sscale*sbox.h;
+ q = (4/5)*ex - (u - Sscale*Sbox.d);
+ if (q > 0) {u += q; v -= q}
+ }
+ u = Math.max(u,values.superscriptshift);
+ v = Math.max(v,values.subscriptshift);
+ sub.style.paddingRight = CHTML.Em(s/sscale);
+ sup.style.paddingBottom = CHTML.Em(u/Sscale+v/sscale-Sbox.d-sbox.h/sscale*Sscale);
+ sup.style.paddingLeft = CHTML.Em(delta/Sscale);
+ sup.style.paddingRight = CHTML.Em(s/Sscale);
+ stack.style.verticalAlign = CHTML.Em(-v);
+ BBOX.combine(Sbox,x+delta,u);
+ BBOX.combine(sbox,x,-v);
+ }
+ }
+ BBOX.clean();
+ return node;
+ },
+ CHTMLstretchV: MML.mbase.CHTMLstretchV,
+ CHTMLstretchH: MML.mbase.CHTMLstretchH,
+ CHTMLchildNode: function (node,i) {
+ var types = ["mjx-base","mjx-sub","mjx-sup"];
+ if (this.over === 1) types[1] = types[2];
+ return CHTML.getNode(node,types[i]);
+ }
+ });
+
+ /********************************************************/
+
+ MML.mfrac.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLdefaultNode(node,{
+ childNodes:["mjx-numerator","mjx-denominator"],
+ childOptions: {autowidth: true},
+ forceChild:true, noBBox:true, minChildren:2
+ });
+ var values = this.getValues("linethickness","displaystyle",
+ "numalign","denomalign","bevelled");
+ var isDisplay = values.displaystyle;
+ //
+ // Create the table for the fraction and set the alignment
+ //
+ var num = node.firstChild, denom = node.lastChild;
+ var frac = CHTML.addElement(node,"mjx-box");
+ frac.appendChild(num); frac.appendChild(denom); node.appendChild(frac);
+ if (values.numalign !== "center") num.style.textAlign = values.numalign;
+ if (values.denomalign !== "center") denom.style.textAlign = values.denomalign;
+ //
+ // Get the bounding boxes for the parts, and determine the placement
+ // of the numerator and denominator
+ //
+ var nbox = this.CHTMLbboxFor(0), dbox = this.CHTMLbboxFor(1),
+ BBOX = CHTML.BBOX.empty(this.CHTML), nscale = nbox.rscale, dscale = dbox.rscale;
+ values.linethickness = Math.max(0,CHTML.thickness2em(values.linethickness||"0",BBOX.scale));
+ var mt = CHTML.TEX.min_rule_thickness/CHTML.em, a = CHTML.TEX.axis_height;
+ var t = values.linethickness, p,q, u,v;
+ if (values.bevelled) {
+ frac.className += " MJXc-bevelled";
+ var delta = (isDisplay ? .4 : .15);
+ var H = Math.max(nscale*(nbox.h+nbox.d),dscale*(dbox.h+dbox.d)) + 2*delta;
+ var bevel = CHTML.Element("mjx-bevel"); frac.insertBefore(bevel,denom);
+ var bbox = CHTML.createDelimiter(bevel,0x2F,H);
+ u = nscale*(nbox.d-nbox.h)/2+a+delta;
+ v = dscale*(dbox.d-dbox.h)/2+a-delta;
+ if (u) num.style.verticalAlign = CHTML.Em(u/nscale);
+ if (v) denom.style.verticalAlign = CHTML.Em(v/dscale);
+ bevel.style.marginLeft = bevel.style.marginRight = CHTML.Em(-delta/2);
+ BBOX.combine(nbox,0,u);
+ BBOX.combine(bbox,nscale*nbox.w-delta/2,0);
+ BBOX.combine(dbox,nscale*nbox.w+bbox.w-delta,v);
+ BBOX.clean();
+ } else {
+ frac.className += " MJXc-stacked";
+ if (isDisplay) {u = CHTML.TEX.num1; v = CHTML.TEX.denom1}
+ else {u = (t === 0 ? CHTML.TEX.num3 : CHTML.TEX.num2); v = CHTML.TEX.denom2}
+ if (t === 0) { // \atop
+ p = Math.max((isDisplay ? 7 : 3) * CHTML.TEX.rule_thickness, 2*mt); // force to at least 2 px
+ q = (u - nbox.d*nscale) - (dbox.h*dscale - v);
+ if (q < p) {u += (p - q)/2; v += (p - q)/2}
+ } else { // \over
+ p = Math.max((isDisplay ? 2 : 0) * mt + t, t/2 + 1.5*mt);
+ t = Math.max(t,mt);
+ q = (u - nbox.d*nscale) - (a + t/2); if (q < p) u += (p - q);
+ q = (a - t/2) - (dbox.h*dscale - v); if (q < p) v += (p - q);
+ nbox.L = nbox.R = dbox.L = dbox.R = .1; // account for padding in BBOX width
+ var rule = CHTML.addElement(frac,"mjx-line",{style: {
+ "border-bottom":CHTML.Px(t*BBOX.scale,1)+" solid", top: CHTML.Em(-t/2-a)
+ }});
+ }
+ //
+ // Determine the new bounding box and place the parts
+ //
+ BBOX.combine(nbox,0,u);
+ BBOX.combine(dbox,0,-v);
+ BBOX.clean();
+ //
+ // Force elements to the correct width
+ //
+ frac.style.width = CHTML.Em(BBOX.w);
+ num.style.width = CHTML.Em(BBOX.w/nscale);
+ denom.style.width = CHTML.Em(BBOX.w/dscale);
+ if (rule) rule.style.width = frac.style.width;
+ //
+ // Place the numerator and denominator in relation to the baseline
+ //
+ num.style.top = CHTML.Em(-BBOX.h/nscale);
+ denom.style.bottom = CHTML.Em(-BBOX.d/dscale);
+ //
+ // Force the size of the surrounding box, since everything is absolutely positioned
+ //
+ CHTML.addElement(node,"mjx-vsize",{style: {
+ height: CHTML.Em(BBOX.h+BBOX.d), verticalAlign: CHTML.Em(-BBOX.d)
+ }});
+ }
+ //
+ // Add nulldelimiterspace around the fraction
+ // (TeXBook pg 150 and Appendix G rule 15e)
+ //
+ if (!this.texWithDelims) {
+ var space = CHTML.TEX.nulldelimiterspace;
+ frac.style.padding = "0 "+CHTML.Em(space);
+ BBOX.l += space; BBOX.r += space; BBOX.w += 2*space;
+ }
+ //
+ // Return the completed fraction
+ //
+ return node;
+ },
+ CHTMLcanStretch: function (direction) {return false}
+ });
+
+ /********************************************************/
+
+ MML.msqrt.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLdefaultNode(node,{
+ childNodes:["mjx-box","mjx-root"], forceChild:true, noBBox:true
+ });
+ var base = node.firstChild || CHTML.Element("mjx-box");
+ var sqrt = CHTML.addElement(node,"mjx-box"); sqrt.appendChild(base);
+ var bbox = this.CHTMLbboxFor(0), BBOX = CHTML.BBOX.empty(this.CHTML);
+ var t = CHTML.TEX.rule_thickness, T = CHTML.TEX.surd_height, p = t, q, H;
+ if (this.Get("displaystyle")) p = CHTML.TEX.x_height;
+ q = t + p/4;
+ H = bbox.h + bbox.d + q + t;
+ var surd = CHTML.Element("mjx-surd"); sqrt.insertBefore(surd,base);
+ var sbox = CHTML.createDelimiter(surd,0x221A,[H-.04,H]);
+ if (sbox.h + sbox.d > H) q = ((sbox.h+sbox.d) - (H-t))/2;
+ H = bbox.h + q + t;
+ var x = this.CHTMLaddRoot(node,sbox,sbox.h+sbox.d-H);
+ base.style.paddingTop = CHTML.Em(q);
+ base.style.borderTop = CHTML.Px(T*bbox.scale,1)+" solid";
+ sqrt.style.paddingTop = CHTML.Em(2*t-T); // use wider line, but don't affect height
+ bbox.h += q + 2*t;
+ BBOX.combine(sbox,x,H-sbox.h);
+ BBOX.combine(bbox,x+sbox.w,0);
+ BBOX.clean();
+ return node;
+ },
+ CHTMLaddRoot: function () {return 0},
+ CHTMLhandleBBox: function (node) {
+ var bbox = this.CHTMLbboxFor(0);
+ delete bbox.pwidth;
+ this.SUPER(arguments).CHTMLhandleBBox.apply(this,arguments);
+ }
+ });
+
+ /********************************************************/
+
+ MML.mroot.Augment({
+ toCommonHTML: MML.msqrt.prototype.toCommonHTML,
+ CHTMLhandleBBox: MML.msqrt.prototype.CHTMLhandleBBox,
+ CHTMLaddRoot: function (sqrt,sbox,d) {
+ if (!this.data[1]) return;
+ var BBOX = this.CHTML, bbox = this.data[1].CHTML, root = sqrt.firstChild;
+ var scale = bbox.rscale;
+ var h = this.CHTMLrootHeight(bbox,sbox,BBOX.scale)-d;
+ var w = Math.min(bbox.w,bbox.r); // remove extra right-hand padding, if any
+ var dx = Math.max(w,sbox.offset/scale);
+ if (h) root.style.verticalAlign = CHTML.Em(h/scale);
+ if (dx > w) root.firstChild.style.paddingLeft = CHTML.Em(dx-w);
+ dx -= sbox.offset/scale;
+ root.style.width = CHTML.Em(dx);
+ BBOX.combine(bbox,0,h);
+ return dx*scale;
+ },
+ CHTMLrootHeight: function (bbox,sbox,scale) {
+ return .45*(sbox.h+sbox.d-.9*scale) + .6*scale + Math.max(0,bbox.d*bbox.scale-.075);
+ }
+ });
+
+ /********************************************************/
+
+ MML.mfenced.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLcreateNode(node);
+ this.CHTMLhandleStyle(node);
+ this.CHTMLhandleScale(node);
+ //
+ // Make row of open, data, sep, ... data, close
+ //
+ this.CHTMLaddChild(node,"open",{});
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ this.CHTMLaddChild(node,"sep"+i,{});
+ this.CHTMLaddChild(node,i,{});
+ }
+ this.CHTMLaddChild(node,"close",{});
+ //
+ // Check for stretching the elements
+ //
+ var H = this.CHTML.h, D = this.CHTML.d;
+ this.CHTMLstretchChildV("open",H,D);
+ for (i = 0, m = this.data.length; i < m; i++) {
+ this.CHTMLstretchChildV("sep"+i,H,D);
+ this.CHTMLstretchChildV(i,H,D);
+ }
+ this.CHTMLstretchChildV("close",H,D);
+ this.CHTMLhandleSpace(node);
+ this.CHTMLhandleBBox(node);
+ this.CHTMLhandleColor(node);
+ return node;
+ }
+ });
+
+ /********************************************************/
+
+ MML.mrow.Augment({
+ toCommonHTML: function (node,options) {
+ options = options || {};
+ node = this.CHTMLdefaultNode(node);
+ var bbox = this.CHTML, H = bbox.h, D = bbox.d, hasNegative;
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ this.CHTMLstretchChildV(i,H,D);
+ if (this.data[i] && this.data[i].CHTML && this.data[i].CHTML.w < 0) hasNegative = true;
+ }
+ if (this.CHTMLlineBreaks()) {
+ this.CHTMLmultiline(node);
+ if (options.autowidth) node.style.width = "";
+ } else {
+ if (hasNegative && bbox.w) node.style.width = CHTML.Em(Math.max(0,bbox.w));
+ if (bbox.w < 0) node.style.marginRight = CHTML.Em(bbox.w);
+ }
+ return node;
+ },
+ CHTMLlineBreaks: function () {
+ if (!this.parent.linebreakContainer) return false;
+ return (LINEBREAKS.automatic && this.CHTML.w > CHTML.linebreakWidth) || this.hasNewline();
+ },
+ CHTMLstretchV: function (h,d) {
+ this.CHTMLstretchChildV(this.CoreIndex(),h,d);
+ return this.CHTML;
+ },
+ CHTMLstretchH: function (node,w) {
+ this.CHTMLstretchChildH(this.CoreIndex(),w,node);
+ return this.CHTML;
+ }
+ });
+
+ /********************************************************/
+
+ MML.TeXAtom.Augment({
+ toCommonHTML: function (node,options) {
+ if (!options || !options.stretch) node = this.CHTMLdefaultNode(node);
+ if (this.texClass === MML.TEXCLASS.VCENTER) {
+ var a = CHTML.TEX.axis_height, BBOX = this.CHTML;
+ var v = a-(BBOX.h+BBOX.d)/2+BBOX.d;
+ if (Math.abs(v) > .001) {
+ node.style.verticalAlign = CHTML.Em(v);
+ BBOX.h += v; BBOX.t += v; BBOX.d -= v; BBOX.b -= v;
+ }
+ }
+ return node;
+ },
+ CHTMLstretchV: function (h,d) {
+ this.CHTMLupdateFrom(this.Core().CHTMLstretchV(h,d));
+ this.toCommonHTML(this.CHTMLnodeElement(),{stretch:true});
+ return this.CHTML;
+ },
+ CHTMLstretchH: function (node,w) {
+ this.CHTMLupdateFrom(this.CHTMLstretchCoreH(node,w));
+ this.toCommonHTML(node,{stretch:true});
+ return this.CHTML;
+ }
+ });
+
+ /********************************************************/
+
+ MML.semantics.Augment({
+ toCommonHTML: function (node) {
+ node = this.CHTMLcreateNode(node);
+ if (this.data[0]) {
+ this.data[0].toCommonHTML(node);
+ this.CHTMLupdateFrom(this.data[0].CHTML);
+ this.CHTMLhandleBBox(node);
+ }
+ return node;
+ }
+ });
+ MML.annotation.Augment({toCommonHTML: function(node) {return this.CHTMLcreateNode(node)}});
+ MML["annotation-xml"].Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+
+ /********************************************************/
+
+ MML.ms.Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+ MML.mglyph.Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+ MML.menclose.Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+ MML.maction.Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+ MML.mmultiscripts.Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+ MML.mtable.Augment({toCommonHTML: MML.mbase.CHTMLautoload});
+
+ /********************************************************/
+
+ //
+ // Loading isn't complete until the element jax is modified,
+ // but can't call loadComplete within the callback for "mml Jax Ready"
+ // (it would call CommonHTML's Require routine, asking for the mml jax again)
+ // so wait until after the mml jax has finished processing.
+ //
+ // We also need to wait for the onload handler to run, since the loadComplete
+ // will call Config and Startup, which need to modify the body.
+ //
+ MathJax.Hub.Register.StartupHook("onLoad",function () {
+ setTimeout(MathJax.Callback(["loadComplete",CHTML,"jax.js"]),0);
+ });
+ });
+
+ MathJax.Hub.Register.StartupHook("End Cookie", function () {
+ if (HUB.config.menuSettings.zoom !== "None")
+ {AJAX.Require("[MathJax]/extensions/MathZoom.js")}
+ });
+
+})(MathJax.Ajax,MathJax.Hub,MathJax.HTML,MathJax.OutputJax.CommonHTML);
+// @license-end
diff --git a/js/mathjax/jax/output/NativeMML/config.js b/js/mathjax/jax/output/NativeMML/config.js
new file mode 100644
index 0000000..a0f7480
--- /dev/null
+++ b/js/mathjax/jax/output/NativeMML/config.js
@@ -0,0 +1,54 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/NativeMML/config.js
+ *
+ * Initializes the NativeMML OutputJax (the main definition is in
+ * MathJax/jax/input/NativeMML/jax.js, which is loaded when needed).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2009-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.OutputJax.NativeMML = MathJax.OutputJax({
+ id: "NativeMML",
+ version: "2.7.9",
+ directory: MathJax.OutputJax.directory + "/NativeMML",
+ extensionDir: MathJax.OutputJax.extensionDir + "/NativeMML",
+
+ config: {
+ matchFontHeight: true, // try to match math font height to surrounding font?
+ scale: 100, // scaling factor for all math
+ minScaleAdjust: 50, // minimum scaling to adjust to surrounding text
+ // (since the code for that is a bit delicate)
+
+ styles: {
+ "div.MathJax_MathML": {
+ "text-align": "center",
+ margin: ".75em 0px"
+ }
+ }
+ }
+});
+
+if (!MathJax.Hub.config.delayJaxRegistration)
+ MathJax.OutputJax.NativeMML.Register("jax/mml");
+
+MathJax.OutputJax.NativeMML.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/output/NativeMML/jax.js b/js/mathjax/jax/output/NativeMML/jax.js
new file mode 100644
index 0000000..75da9f5
--- /dev/null
+++ b/js/mathjax/jax/output/NativeMML/jax.js
@@ -0,0 +1,1433 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/NativeMML/jax.js
+ *
+ * Implements the NativeMML OutputJax that displays mathematics
+ * using a browser's native MathML capabilities (if any).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2010-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+(function (nMML,HUB,AJAX,HTML) {
+ var MML, isMSIE = HUB.Browser.isMSIE;
+
+ var EVENT, TOUCH, HOVER, ZOOM; // filled in later
+
+ HUB.Register.StartupHook("MathZoom Ready",function () {ZOOM = MathJax.Extension.MathZoom});
+
+ var NOPADDING = function (side,obj) {
+ var span = HTML.Element("span"); side = "padding"+side;
+ if (obj) {
+ span.style.cssText = (obj.getAttribute("style")||"");
+ if (span.style.padding === "" && (span.style[side]||"") === "") {
+ span.style[side] = "0px"; obj.setAttribute("style",span.style.cssText)
+ }
+ }
+ };
+
+ var CELLSPACING = function (obj,rowSpacing,columnSpacing) {
+ //
+ // Webkit default padding on mtd cells is simply
+ //
+ // mtd {padding: 0.5ex;}
+ //
+ // Gecko default padding on mtd cells is
+ //
+ // mtd {padding-right: 0.4em;
+ // padding-left: 0.4em;
+ // padding-bottom: 0.5ex;
+ // padding-top: 0.5ex;}
+ // mtr:first-child > mtd {padding-top: 0ex;}
+ // mtr:last-child > mtd {padding-bottom: 0ex;}
+ // mtd:first-child {padding-left: 0em;}
+ // mtd:last-child {padding-right: 0em;}
+ //
+ // that is the columnspacing/rowspacing is split into two adjacent cells,
+ // and the periphery of boundary cells is set to zero.
+ //
+ // Here, we will set the left/top padding of each cell to
+ // rowSpacing/columnSpacing (or 0px for the leftmost/topmost cells) and
+ // reset the right/bottom padding to zero.
+ //
+ if (obj) {
+ var span = HTML.Element("span");
+ span.style.cssText = (obj.getAttribute("style")||"");
+ if (span.style.padding === "") {
+ var padding = { paddingLeft: columnSpacing, paddingTop: rowSpacing,
+ paddingRight: "0px", paddingBottom: "0px" };
+ for (var side in padding) {if (padding.hasOwnProperty(side)) {
+ if ((span.style[side]||"") === "") {span.style[side] = padding[side];}
+ }}
+ }
+ obj.setAttribute("style",span.style.cssText);
+ }
+ };
+
+ nMML.Augment({
+ //
+ // User can configure styles
+ //
+ config: {
+ styles: {
+ ".MathJax_MathML": {
+ "font-style": "normal",
+ "font-weight": "normal",
+ "line-height": "normal",
+ "font-size": "100%",
+ "font-size-adjust":"none",
+ "text-indent": 0,
+ "text-align": "left",
+ "text-transform": "none",
+ "letter-spacing": "normal",
+ "word-spacing": "normal",
+ "word-wrap": "normal",
+ "white-space": "nowrap",
+ "float": "none",
+ "direction": "ltr",
+ "max-width": "none", "max-height": "none",
+ "min-width": 0, "min-height": 0,
+ border: 0, padding: 0, margin: 0
+ },
+
+ "span.MathJax_MathML": {
+ display: "inline!important"
+ },
+
+ "div.MathJax_MathML": {
+ display: "block!important"
+ },
+
+ ".MathJax_mmlExBox": {
+ display:"block!important", overflow:"hidden",
+ height:"1px", width:"60ex",
+ "min-height": 0, "max-height":"none",
+ padding:0, border: 0, margin: 0
+ }
+ }
+ },
+ handlesVariants: false, // true if native support for mathvariants
+ settings: HUB.config.menuSettings,
+ ex: 1, scale: 1, // filled in later
+ adjustWidths: [], // array of elements to have their widths adjusted
+
+ Config: function () {
+ this.SUPER(arguments).Config.call(this);
+ if (this.settings.scale) {this.config.scale = this.settings.scale}
+ //
+ // Insert styling to take account of displayAlign and displayIndent
+ //
+ if (HUB.config.displayAlign !== "center") {
+ var align = HUB.config.displayAlign, indent = HUB.config.displayIndent;
+ var def = {"text-align": align+"!important"}; def["margin-"+align] = indent+"!important";
+ HUB.Insert(this.config.styles,{
+ "div.MathJax_MathML": def,
+ "div.MathJax_MathML math": {"text-align": align},
+ "div.MathJax_MathContainer > span": {"text-align": align+"!important"}
+ });
+ }
+ if (!this.require) {this.require = []}
+ this.require.push(MathJax.OutputJax.extensionDir+"/MathEvents.js");
+ },
+ Startup: function () {
+ // Set up event handling
+ EVENT = MathJax.Extension.MathEvents.Event;
+ TOUCH = MathJax.Extension.MathEvents.Touch;
+ HOVER = MathJax.Extension.MathEvents.Hover;
+ this.ContextMenu = EVENT.ContextMenu;
+ this.Mousedown = EVENT.AltContextMenu;
+ this.Mouseover = HOVER.Mouseover;
+ this.Mouseout = HOVER.Mouseout;
+ this.Mousemove = HOVER.Mousemove;
+
+ if (!HUB.Browser.hasMathPlayer) {
+ // Used in preTranslate to get scaling factors
+ this.EmExSpan = HTML.Element("span",
+ {style:{position:"absolute","font-size-adjust":"none"}},
+ [
+ ["div",{className:"MathJax_mmlExBox"}],
+ ["span",{className:"MathJax_MathML"}]
+ ]
+ );
+ MML.math(MML.mspace().With({width:"60ex"})).toNativeMML(this.EmExSpan.lastChild);
+ }
+
+ // Set up styles
+ return AJAX.Styles(this.config.styles);
+ },
+ //
+ // Set up MathPlayer for IE on the first time through.
+ // Get the ex and em sizes.
+ //
+ InitializeMML: function () {
+ this.initialized = true;
+ if (HUB.Browser.hasMathPlayer) {
+ try {
+ //
+ // Insert data needed to use MathPlayer for MathML output
+ //
+ if (!HUB.Browser.mpNamespace) {
+ var mathplayer = document.createElement("object");
+ mathplayer.id = "mathplayer"; mathplayer.classid = "clsid:32F66A20-7614-11D4-BD11-00104BD3F987";
+ document.getElementsByTagName("head")[0].appendChild(mathplayer);
+ document.namespaces.add("m","http://www.w3.org/1998/Math/MathML");
+ HUB.Browser.mpNamespace = true;
+ }
+ if (!HUB.Browser.mpImported) {
+ document.namespaces.m.doImport("#mathplayer");
+ HUB.Browser.mpImported = true;
+ }
+ } catch (err) {
+ //
+ // If that fails, give an alert about security settings
+ //
+ if (!this.config.noMathPlayerWarning) {
+ alert(MathJax.Localization._(["MathML", "MathPlayer"],
+ "MathJax was not able to set up MathPlayer.\n\n"+
+ "If MathPlayer is not installed, you need to install it first.\n"+
+ "Otherwise, your security settings may be preventing ActiveX \n"+
+ "controls from running. Use the Internet Options item under\n"+
+ "the Tools menu and select the Security tab, then press the\n"+
+ "Custom Level button. Check that the settings for\n"+
+ "'Run ActiveX Controls', and 'Binary and script behaviors'\n"+
+ "are enabled.\n\n"+
+ "Currently you will see error messages rather than\n"+
+ "typeset mathematics."));
+ }
+ }
+ } else {
+ //
+ // Get the default sizes (need styles in place to do this)
+ //
+ document.body.appendChild(this.EmExSpan);
+ this.defaultEx = this.EmExSpan.firstChild.offsetWidth/60;
+ this.defaultMEx = this.EmExSpan.lastChild.offsetWidth/60;
+ document.body.removeChild(this.EmExSpan);
+ }
+ },
+
+ preTranslate: function (state) {
+ var scripts = state.jax[this.id], i, m = scripts.length,
+ script, prev, span, test, math, jax, ex, mex, scale;
+ for (i = 0; i < m; i++) {
+ script = scripts[i]; if (!script.parentNode) continue;
+ if (!this.initialized) {this.InitializeMML()}
+ //
+ // Remove any existing output
+ //
+ prev = script.previousSibling;
+ if (prev && prev.className === "MathJax_MathML") {prev.parentNode.removeChild(prev)}
+ //
+ // Add the MathJax span
+ //
+ jax = script.MathJax.elementJax; if (!jax) continue;
+ math = jax.root; jax.NativeMML = {};
+ var type = (math.Get("display") === "block" ? "div" : "span");
+ span = HTML.Element(type,{
+ className: "MathJax_MathML", id:jax.inputID+"-Frame"
+ },[["span",{
+ className:"MathJax_MathContainer", isMathJax: true, jaxID:this.id,
+ style:{position:"relative", display:"inline-block", "white-space":"nowrap"}
+ }, [["span",{isMathJax:true, style:{display:"inline-block"}}]] // for Firefox hover and zoom
+ ]]);
+ script.parentNode.insertBefore(span,script);
+ //
+ // Add the test span for determining scales
+ //
+ if (!isMSIE) {script.parentNode.insertBefore(this.EmExSpan.cloneNode(true),script)}
+ }
+ //
+ // Determine the scaling factors for each script
+ // (this only requires one reflow rather than a reflow for each equation)
+ //
+ for (i = 0; i < m; i++) {
+ script = scripts[i]; if (!script.parentNode) continue;
+ jax = script.MathJax.elementJax; if (!jax) continue;
+ if (!isMSIE) {
+ test = script.previousSibling;
+ ex = test.firstChild.offsetWidth/60;
+ mex = test.lastChild.offsetWidth/60;
+ if (ex === 0 || ex === "NaN") {ex = this.defaultEx; mex = this.defaultMEx}
+ scale = (this.config.matchFontHeight && mex > 1 ? ex/mex : 1);
+ scale = Math.floor(Math.max(this.config.minScaleAdjust/100,scale) * this.config.scale);
+ jax.NativeMML.ex = ex; jax.NativeMML.mex = mex;
+ } else {scale = 100}
+ jax.NativeMML.fontSize = scale+"%";
+ jax.NativeMML.scale = scale/100;
+ }
+ //
+ // Remove the test spans used for determining scales
+ //
+ if (!isMSIE) {
+ for (i = 0; i < m; i++) {
+ script = scripts[i];
+ if (script.parentNode && script.MathJax.elementJax) {
+ script.parentNode.removeChild(script.previousSibling);
+ }
+ }
+ }
+ },
+
+ //
+ // Add a SPAN to use as a container, and render the math into it
+ //
+ Translate: function (script) {
+ if (!script.parentNode) return;
+ //
+ // Get the jax and the container and set the size
+ //
+ var jax = script.MathJax.elementJax, math = jax.root;
+ var span = document.getElementById(jax.inputID+"-Frame"); if (!span) return;
+ var container = span.firstChild, mspan = container.firstChild;
+ this.ex = jax.NativeMML.ex || this.defaultEx;
+ this.scale = jax.NativeMML.scale || 1;
+ if (this.scale !== 1) {span.style.fontSize = jax.NativeMML.fontSize}
+ //
+ // Convert to MathML (if restarted, remove any partial math)
+ //
+ try {math.toNativeMML(mspan,jax)} catch (err) {
+ if (err.restart) {while (mspan.firstChild) {mspan.removeChild(mspan.firstChild)}}
+ throw err;
+ }
+ //
+ // Add event handlers
+ //
+ if (isMSIE) {
+ if (container.addEventListener) {
+ for (var id in this.MSIE9events) {if (this.MSIE9events.hasOwnProperty(id)) {
+ container.addEventListener(id,this.MSIE9event,true);
+ }}
+ } else {
+ var config = (this.config.showMathMenuMSIE != null ? this : HUB).config;
+ if (config.showMathMenuMSIE && !this.settings.mpContext && !this.settings.mpMouse)
+ {this.MSIEoverlay(container)} else
+ {container.style.position = ""; mspan.firstChild.onmousedown = this.MSIEaltMenu}
+ }
+ } else {
+ container.oncontextmenu = EVENT.Menu;
+ container.onmouseover = EVENT.Mouseover;
+ container.onmouseout = EVENT.Mouseout;
+ container.onmousedown = EVENT.Mousedown;
+ container.onclick = EVENT.Click;
+ container.ondblclick = EVENT.DblClick;
+ // Added for keyboard accessible menu.
+ container.onkeydown = EVENT.Keydown;
+ container.tabIndex = HUB.getTabOrder(jax);
+ if (HUB.Browser.noContextMenu) {
+ container.ontouchstart = TOUCH.start;
+ container.ontouchend = TOUCH.end;
+ }
+ }
+ },
+
+ postTranslate: function (state) {
+ if (this.forceReflow) {
+ //
+ // Firefox messes up some mtable's when they are dynamically created
+ // but gets them right on a reflow, so force reflow by toggling a stylesheet
+ //
+ var sheet = (document.styleSheets||[])[0]||{};
+ sheet.disabled = true; sheet.disabled = false;
+ }
+ },
+
+ //
+ // Remove MathML preceding the script
+ //
+ Remove: function (jax) {
+ var span = jax.SourceElement(); if (!span) return;
+ span = span.previousSibling; if (!span) return;
+ if (span.className.match(/MathJax_MathML/)) {span.parentNode.removeChild(span)}
+ },
+ //
+ // The namespace to use for MML
+ //
+ MMLnamespace: "http://www.w3.org/1998/Math/MathML",
+
+ isFullWidth: function (node) {
+ if (!node) return;
+ var width = node.getAttribute("width") ||
+ (String(node.getAttribute("style")).match(/(?:^| )width: *([^; ]*)/)||[])[1];
+ if (width) return !!width.match(/%/);
+ if (node.nodeName.match(/^(semantics|math|mstyle)$/)) {
+ width = this.isFullWidth(node.firstChild);
+ } else if (node.nodeName.toLowerCase() === "mrow") {
+ for (var i = 0, m = node.childNodes.length; i < m && !width; i++)
+ width = this.isFullWidth(node.childNodes[i]);
+ }
+ if (width) {
+ var style = "width:100%; "+(node.getAttribute("style")||"");
+ node.setAttribute("style",style.replace(/ +$/,""));
+ }
+ return width;
+ },
+
+ //
+ // For MSIE, we must overlay the MathPlayer object to trap the events
+ // (since they can't be cancelled when the events are on the <math> tag
+ // itself). The events we DON'T want are transferred to the math element,
+ // and the others are handled directly.
+ //
+ MSIEoverlay: function (span) {
+ var math = span.firstChild;
+ if (math.nodeName.toLowerCase() === "span") {math = math.firstChild}
+ var bbox = this.getHoverBBox(null,math,{});
+ HTML.addElement(span,"span",{
+ style:{display:"inline-block", width:0, height:0, position:"relative"}
+ },[["span",{isMathJax: true, className: "MathJax_MathPlayer_Overlay",
+ style:{
+ display:"inline-block", position:"absolute",
+ left:HOVER.Px(-bbox.w), top:HOVER.Px(-bbox.h-(bbox.y||0)-1),
+ width:HOVER.Px(bbox.w), height:HOVER.Px(bbox.h+bbox.d), cursor:"pointer",
+ "background-color":"white", filter:"alpha(opacity=0)"
+ }
+ }]]);
+ HUB.Insert(span,{
+ msieMath: math,
+ onmousedown: this.MSIEevent, oncontextmenu: this.MSIEevent, onclick: this.MSIEevent,
+ onmouseup: this.MSIEevent, onmousemove: this.MSIEevent, ondblclick: this.MSIEevent,
+ onmouseover: this.MSIEevent, onmouseout: this.MSIEevent
+ });
+ },
+ MSIEevents: {
+ mousedown:"Mousedown", contextmenu:"ContextMenu", click:"Click",
+ mouseup:"Mouseup", mousemove:"Mousemove", dblclick: "DblClick",
+ mouseover:"Mouseover", mouseout:"Mouseout"
+ },
+ MSIEevent: function () {
+ var event = window.event;
+ var type = nMML.MSIEevents[event.type];
+ if (nMML[type] && nMML[type](event,this) === false) {return false}
+ if (ZOOM && ZOOM.HandleEvent(event,type,this) === false) {return false}
+ if (event.srcElement.className === "MathJax_MathPlayer_Overlay" && this.msieMath.fireEvent) {
+ //
+ // For now, ignore all other events. This will disable MathPlayer's zoom
+ // feature, but also its <maction> support.
+ //
+ if (type === "ContextMenu" || type === "Mouseover" || type === "Mouseout")
+ {this.msieMath.fireEvent("on"+event.type,event)}
+ }
+ return EVENT.False(event);
+ },
+ MSIEaltMenu: function () {
+ var container = this.parentNode.parentNode;
+ while (!container.jaxID) {container = container.parentNode}
+ EVENT.AltContextMenu(window.event,container);
+ },
+
+ MSIE9events: {
+ contextmenu:"Menu", click:"Click", dblclick: "DblClick",
+ mouseup:"False", mouseover:"Mouseover", mouseout:"Mouseout"
+ },
+ MSIE9event: function (event) {
+ if (event.type === "contextmenu" && nMML.settings.mpContext) {return true}
+ if (event.type === "mouseup" && nMML.settings.mpMouse) {return true}
+ if (event.type === "click" && nMML.settings.mpContext)
+ {return EVENT.AltContextMenu(event,this)}
+ var type = nMML.MSIE9events[event.type];
+ return EVENT[type].call(this,event);
+ },
+
+ getJaxFromMath: function (math) {
+ math = math.parentNode;
+ do {math = math.nextSibling} while (math && math.nodeName.toLowerCase() !== "script");
+ return HUB.getJaxFor(math);
+ },
+ getHoverSpan: function (jax,math) {return math.firstChild},
+ getHoverBBox: function (jax,span,math) {return EVENT.getBBox(span.parentNode)},
+
+ Zoom: function (jax,span,math,Mw,Mh) {
+ jax.root.toNativeMML(span);
+ if (this.msieIE8HeightBug) {span.style.position = "absolute"}
+ if (nMML.widthBug) {span.style.width = span.parentNode.style.width = ""}
+ if (span.parentNode.style.width.match(/%$/))
+ {span.parentNode.style.minWidth = Math.ceil(3*Mh/4)+"px"} // for full-width tables
+ var mW = math.offsetWidth || math.scrollWidth,
+ mH = math.offsetHeight || math.scrollHeight;
+ var zW = span.offsetWidth, zH = span.offsetHeight;
+ if (nMML.widthBug || span.style.width.match(/%/)) {
+ //
+ // FF doesn't get width of <math> right, so get it from <mrow>
+ //
+ var W = span.firstChild.firstChild.scrollWidth;
+ if (W > zW) {zW = W; span.parentNode.style.width = span.style.minWidth = zW + "px";}
+ }
+ if (this.msieIE8HeightBug) {span.style.position = ""}
+ return {Y:-EVENT.getBBox(span.parentNode).h, mW:mW, mH:mH, zW:zW, zH:zH}
+ },
+
+ NAMEDSPACE: {
+ negativeveryverythinmathspace: "-.0556em",
+ negativeverythinmathspace: "-.1111em",
+ negativethinmathspace: "-.1667em",
+ negativemediummathspace: "-.2222em",
+ negativethickmathspace: "-.2778em",
+ negativeverythickmathspace: "-.3333em",
+ negativeveryverythickmathspace: "-.3889em",
+ veryverythinmathspace: ".0556em",
+ verythinmathspace: ".1111em",
+ thinmathspace: ".1667em",
+ mediummathspace: ".2222em",
+ thickmathspace: ".2778em",
+ verythickmathspace: ".3333em",
+ veryverythickmathspace: ".3889em"
+ }
+ });
+
+ HUB.Register.StartupHook("mml Jax Ready",function () {
+
+ MML = MathJax.ElementJax.mml;
+
+ MML.mbase.Augment({
+ //
+ // Add a MathML tag of the correct type, and set its attributes
+ // then populate it with its children and append it to the parent
+ //
+ toNativeMML: function (parent) {
+ var tag = this.NativeMMLelement(this.type);
+ this.NativeMMLattributes(tag);
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i]) {this.data[i].toNativeMML(tag)}
+ else {tag.appendChild(this.NativeMMLelement("mrow"))}
+ }
+ parent.appendChild(tag);
+ },
+ //
+ // Look for attributes that are different from the defaults
+ // and set those in the tag's attribute list
+ //
+ NativeMMLattributes: function (tag) {
+ var defaults = (this.type === "mstyle" ? MML.math.prototype.defaults : this.defaults);
+ var names = (this.attrNames||MML.copyAttributeNames),
+ skip = MML.skipAttributes, copy = MML.copyAttributes;
+ if (!this.attrNames) {
+ for (var id in defaults) {if (!skip[id] && !copy[id] && defaults.hasOwnProperty(id)) {
+ if (this[id] != null && this[id] !== defaults[id]) {
+ if (this.Get(id,null,1) !== this[id])
+ tag.setAttribute(id,this.NativeMMLattribute(this[id]));
+ }
+ }}
+ }
+ for (var i = 0, m = names.length; i < m; i++) {
+ if (copy[names[i]] === 1 && !defaults.hasOwnProperty(names[i])) continue;
+ var value = (this.attr||{})[names[i]]; if (value == null) {value = this[names[i]]}
+ if (value != null) {tag.setAttribute(names[i],this.NativeMMLattribute(value))}
+ }
+ this.NativeMMLclass(tag);
+ },
+ NativeMMLclass: function (tag) {
+ var CLASS = []; if (this["class"]) {CLASS.push(this["class"])}
+ if (this.isa(MML.TeXAtom)) {
+ var TEXCLASS = ["ORD","OP","BIN","REL","OPEN","CLOSE","PUNCT","INNER","VCENTER"][this.texClass];
+ if (TEXCLASS) {
+ CLASS.push("MJX-TeXAtom-"+TEXCLASS)
+ if (TEXCLASS === "OP" && !this.movablelimits) CLASS.push("MJX-fixedlimits");
+ }
+ }
+ if (this.mathvariant && this.NativeMMLvariants[this.mathvariant])
+ {CLASS.push("MJX"+this.mathvariant)}
+ if (this.variantForm) {CLASS.push("MJX-variant")}
+ if (CLASS.length) {tag.setAttribute("class",CLASS.join(" "))}
+ },
+ NativeMMLattribute: function (value) {
+ value = String(value);
+ if (nMML.NAMEDSPACE[value]) {value = nMML.NAMEDSPACE[value]} // MP doesn't do negative spaces
+ else if (value.match(/^\s*(([-+])?(\d+(\.\d*)?|\.\d+))\s*mu\s*$/))
+ {value = (RegExp.$2||"")+((1/18)*RegExp.$3).toFixed(3).replace(/\.?0+$/,"")+"em"} // FIXME: should take scriptlevel into account
+ else if (this.NativeMMLvariants[value]) {value = this.NativeMMLvariants[value]}
+ return value;
+ },
+ NativeMMLvariants: {
+ "-tex-caligraphic": MML.VARIANT.SCRIPT,
+ "-tex-caligraphic-bold": MML.VARIANT.BOLDSCRIPT,
+ "-tex-oldstyle": MML.VARIANT.NORMAL,
+ "-tex-oldstyle-bold": MML.VARIANT.BOLD,
+ "-tex-mathit": MML.VARIANT.ITALIC
+ },
+ //
+ // Create a MathML element
+ //
+ NativeMMLelement: function (type) {
+ var math = ( HUB.Browser.mpNamespace ? document.createElement("m:"+type) :
+ (document.createElementNS ? document.createElementNS(nMML.MMLnamespace,type) :
+ document.createElement(type)));
+ math.isMathJax = true;
+ return math;
+ }
+ });
+
+ MML.mrow.Augment({
+ //
+ // Make inferred rows not include an mrow tag
+ //
+ toNativeMML: function (parent) {
+ var i, m;
+ if (this.inferred && this.parent.inferRow) {
+ for (i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i]) {this.data[i].toNativeMML(parent)}
+ else {parent.appendChild(this.NativeMMLelement("mrow"))}
+ }
+ } else if (nMML.stretchyMoBug && (this.open || this.close)) {
+ //
+ // This element contains opening and/or closing fences. Opera is not
+ // able to stretch <mo> operators, so let's use an <mfenced> element
+ // instead.
+ //
+ var mfenced = this.NativeMMLelement("mfenced");
+ this.NativeMMLattributes(mfenced);
+ i = 0, m = this.data.length;
+ if (this.open) { mfenced.setAttribute("open", this.open); i++; }
+ if (this.close) { mfenced.setAttribute("close", this.close); m--; }
+ var tag = mfenced;
+ if (m - i + 1 > 1) {
+ //
+ // If there are several children, put them in an <mrow>
+ //
+ tag = this.NativeMMLelement("mrow");
+ parent.appendChild(mfenced);
+ parent = mfenced;
+ }
+ for (; i < m; i++) {
+ if (this.data[i]) {this.data[i].toNativeMML(tag)}
+ else {tag.appendChild(this.NativeMMLelement("mrow"))}
+ }
+ parent.appendChild(tag);
+ } else {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ }
+ }
+ });
+
+ MML.msubsup.Augment({
+ //
+ // Use proper version of msub, msup, or msubsup, depending on
+ // which items are present
+ //
+ toNativeMML: function (parent) {
+ var type = this.type;
+ if (this.data[this.sup] == null) {type = "msub"}
+ if (this.data[this.sub] == null) {type = "msup"}
+ var tag = this.NativeMMLelement(type);
+ this.NativeMMLattributes(tag);
+ if (this.data[0]) {delete this.data[0].inferred}
+ for (var i = 0, m = this.data.length; i < m; i++)
+ {if (this.data[i]) {this.data[i].toNativeMML(tag)}}
+ parent.appendChild(tag);
+ }
+ });
+
+ MML.munderover.Augment({
+ //
+ // Use proper version of munder, mover, or munderover, depending on
+ // which items are present. Handle movablelimits on TeXAtom base.
+ //
+ toNativeMML: function (parent) {
+ var type = this.type;
+ var base = this.data[this.base];
+ if (base && base.isa(MML.TeXAtom) && base.movablelimits && !base.Get("displaystyle")) {
+ type = "msubsup";
+ if (this.data[this.under] == null) {type = "msup"}
+ if (this.data[this.over] == null) {type = "msub"}
+ } else {
+ if (this.data[this.under] == null) {type = "mover"}
+ if (this.data[this.over] == null) {type = "munder"}
+ }
+ var tag = this.NativeMMLelement(type);
+ this.NativeMMLattributes(tag);
+ if (this.data[0]) {delete this.data[0].inferred}
+ for (var i = 0, m = this.data.length; i < m; i++)
+ {if (this.data[i]) {this.data[i].toNativeMML(tag)}}
+ parent.appendChild(tag);
+ }
+ });
+
+ if (!isMSIE) {
+ var SPLIT = HUB.SplitList;
+ MML.mtable.Augment({
+ toNativeMML: function (parent) {
+ var i, m;
+ if (nMML.tableSpacingBug) {
+ //
+ // Parse the rowspacing/columnspacing. For convenience, we convert
+ // them to a left/top padding value that will be applied to each
+ // cell. The leftmost/topmost cells will use "0px".
+ //
+ var values = this.getValues("rowspacing", "columnspacing");
+ this.nMMLtopPadding = SPLIT("0px "+values.rowspacing);
+ this.nMMLleftPadding = SPLIT("0px "+values.columnspacing);
+ //
+ // Transmit the top padding to each row.
+ // If this.parent.nMML.topPadding does not contain enough value,
+ // repeat the last one.
+ //
+ var tp = this.nMMLtopPadding, M = tp.length;
+ for (i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i])
+ {this.data[i].nMMLtopPadding = tp[i < M ? i : M-1]}
+ }
+ }
+ if (nMML.tableLabelBug) {
+ //
+ // Look for labeled rows so we know how to handle them
+ //
+ for (i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i] && this.data[i].isa(MML.mlabeledtr)) {
+ var align = HUB.config.displayAlign.charAt(0),
+ side = this.Get("side").charAt(0);
+ this.nMMLhasLabels = true;
+ this.nMMLlaMatch = (align === side);
+ this.nMMLforceWidth =
+ (align === "c" || !!((this.width||"").match("%")));
+ break;
+ }
+ }
+ }
+ //
+ // Firefox < 13 doesn't handle width, so put it in styles instead
+ //
+ if (this.width && this.ffTableWidthBug) {
+ var styles = (this.style||"").replace(/;\s*$/,"").split(";");
+ if (styles[0] === "") {styles.shift()}
+ styles.push("width:"+this.width);
+ this.style = styles.join(";");
+ }
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ //
+ if (this.nMMLhasLabels) {
+ var mtable = parent.firstChild;
+ //
+ // Add column attributes on the left when extra columns where inserted
+ //
+ if (this.nMMLforceWidth || side !== "r") {
+ var n = (align !== "l" ? 1 : 0) + (side === "l" ? 1 : 0);
+ if (n) {
+ var attr = {columnalign:"left", columnwidth:"auto",
+ columnspacing:"0px", columnlines:"none"};
+ for (var id in attr) {if (attr.hasOwnProperty(id) && this[id]) {
+ var cols = [attr[id],attr[id]].slice(2-n).join(" ")+" ";
+ mtable.setAttribute(id,cols+mtable.getAttribute(id));
+ }}
+ }
+ }
+ //
+ // Force the table width to 100% when needed
+ //
+ if (this.nMMLforceWidth || !this.nMMLlaMatch)
+ {mtable.setAttribute("width","100%")}
+ }
+ }
+ });
+ MML.mtr.Augment({
+ toNativeMML: function (parent) {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ var mtr = parent.lastChild;
+ if (nMML.tableSpacingBug) {
+ //
+ // Set the row/column spacing. If this.parent.nMMLleftPadding does
+ // not contain enough value, repeat the last one.
+ //
+ var lp = this.parent.nMMLleftPadding, M = lp.length;
+ for (var mtd = mtr.firstChild, i = 0; mtd; mtd = mtd.nextSibling, i++) {
+ CELLSPACING(mtd,this.nMMLtopPadding,lp[i < M ? i : M-1]);
+ }
+ }
+
+ if (nMML.tableLabelBug) {
+ var forceWidth = this.parent.nMMLforceWidth,
+ side = this.parent.Get("side").charAt(0),
+ align = HUB.config.displayAlign.charAt(0);
+
+ if (this.parent.nMMLhasLabels && mtr.firstChild) {
+ //
+ // If we add a label or padding column on the left of mlabeledtr,
+ // mirror that here and remove padding from first table mtd
+ // so the spacing is consistent with unlabeled equations
+ //
+ if (forceWidth || side !== "r") {
+ NOPADDING("Left",mtr.firstChild);
+ if (align !== "l") {
+ mtr.insertBefore(this.NativeMMLelement("mtd"),mtr.firstChild)
+ .setAttribute("style","padding:0");
+ }
+ if (side === "l") {
+ mtr.insertBefore(this.NativeMMLelement("mtd"),mtr.firstChild)
+ .setAttribute("style","padding:0");
+ }
+ }
+ //
+ // If columns were added on the right, remove mtd padding
+ // so that spacing is consistent with unlabled equations
+ //
+ if (forceWidth || side !== "l") {NOPADDING("Right",mtr.lastChild)}
+ }
+ }
+ }
+ });
+ MML.mlabeledtr.Augment({
+ toNativeMML: function (parent) {
+ var mtr = this.NativeMMLelement("mtr");
+ this.NativeMMLattributes(mtr);
+ //
+ // Add row data
+ //
+ for (var i = 1, m = this.data.length; i < m; i++) {
+ if (this.data[i]) {this.data[i].toNativeMML(mtr)}
+ else {mtr.appendChild(this.NativeMMLelement("mtd"))}
+ }
+
+ if (nMML.tableSpacingBug) {
+ //
+ // Set the row/column spacing. If this.parent.nMMLleftPadding does
+ // not contain enough value, repeat the last one.
+ //
+ var lp = this.parent.nMMLleftPadding, M = lp.length; i = 0;
+ for (var mtd = mtr.firstChild; mtd; mtd = mtd.nextSibling, i++) {
+ CELLSPACING(mtd,this.nMMLtopPadding,lp[i < M ? i : M-1]);
+ }
+ }
+
+ if (nMML.tableLabelBug && this.data[0]) {
+ var side = this.parent.Get("side").charAt(0),
+ align = HUB.config.displayAlign.charAt(0),
+ indent = HUB.config.displayIndent;
+ //
+ // Create label and either set the column width (if label is on the
+ // same side as the alignment), or use mpadded to hide the label
+ // width
+ //
+ this.data[0].toNativeMML(mtr);
+ var label = mtr.lastChild, pad = label;
+ if (side === align) {
+ label.setAttribute("style","width:"+indent);
+ label.setAttribute("columnalign",HUB.config.displayAlign);
+ } else {
+ pad = this.NativeMMLelement("mpadded");
+ pad.setAttribute("style","width:0");
+ pad.setAttribute("width","0px");
+ pad.appendChild(label.firstChild);
+ label.appendChild(pad);
+ }
+ NOPADDING("",label); mtr.removeChild(label);
+ //
+ // Get spacing to use for separation of label from main table
+ //
+ var width = 100, forceWidth = this.parent.nMMLforceWidth;
+ if ((this.parent.width||"").match(/%/)) {
+ width -= parseFloat(this.parent.width)
+ };
+ var w = width;
+ //
+ // Add spacing (and possibly label) at the left if needed
+ //
+ if (forceWidth || side !== "r") {
+ NOPADDING("Left",mtr.firstChild);
+ if (align !== "l") {
+ if (align === "c") {w /= 2}; width -= w;
+ mtr.insertBefore(this.NativeMMLelement("mtd"),mtr.firstChild)
+ .setAttribute("style","padding:0;width:"+w+"%");
+ }
+ if (side === "l") {mtr.insertBefore(label,mtr.firstChild)}
+ }
+ //
+ // Add spacing (and possibly label) at the right if needed
+ //
+ if (forceWidth || side !== "l") {
+ NOPADDING("Right",mtr.lastChild);
+ if (align !== "r") {
+ mtr.appendChild(this.NativeMMLelement("mtd"))
+ .setAttribute("style","padding:0;width:"+width+"%");
+ }
+ if (side === "r") {
+ if (side !== align) {pad.setAttribute("lspace","-1width")}
+ mtr.appendChild(label);
+ }
+ }
+ }
+ //
+ // Add row to table
+ //
+ parent.appendChild(mtr);
+ }
+ });
+
+ MML.mtd.Augment({
+ toNativeMML: function (parent) {
+ var tag = parent.appendChild(this.NativeMMLelement(this.type));
+ this.NativeMMLattributes(tag);
+ if (nMML.mtdWidthBug) {
+ nMML.adjustWidths.push(tag);
+ tag = tag.appendChild(this.NativeMMLelement("mrow"));
+ }
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i]) {this.data[i].toNativeMML(tag)}
+ else {tag.appendChild(this.NativeMMLelement("mrow"))}
+ }
+ }
+ });
+
+ MML.mspace.Augment({
+ toNativeMML: function (parent) {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ if (nMML.spaceWidthBug && this.width) {
+ var mspace = parent.lastChild;
+ var width = mspace.getAttribute("width");
+ var style = (mspace.getAttribute("style") || "").replace(/;?\s*/,"; ");
+ mspace.setAttribute("style",style+"width:"+width);
+ }
+ }
+ });
+
+ MML.mn.Augment({
+ NativeMMLremapMinus: function (text) {return text.replace(/^-/,"\u2212")},
+ toNativeMML: function (parent) {
+ var tag = this.NativeMMLelement(this.type);
+ this.NativeMMLattributes(tag);
+ var remap = this.NativeMMLremapMinus;
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i]) {
+ this.data[i].toNativeMML(tag,remap);
+ remap = null;
+ }
+ }
+ parent.appendChild(tag);
+ }
+ });
+
+ var fontDir = AJAX.fileURL(MathJax.OutputJax.fontDir+"/HTML-CSS/TeX/otf");
+
+ /*
+ * Add fix for mathvariant issues
+ */
+ nMML.Augment({
+ config: {
+ styles: {
+ '[class="MJX-tex-oldstyle"]': {"font-family":"MathJax_Caligraphic, MathJax_Caligraphic-WEB"},
+ '[class="MJX-tex-oldstyle-bold"]': {"font-family":"MathJax_Caligraphic, MathJax_Caligraphic-WEB", "font-weight":"bold"},
+ '[class="MJX-tex-caligraphic"]': {"font-family":"MathJax_Caligraphic, MathJax_Caligraphic-WEB"},
+ '[class="MJX-tex-caligraphic-bold"]': {"font-family":"MathJax_Caligraphic, MathJax_Caligraphic-WEB", "font-weight":"bold"},
+
+ '@font-face /*1*/': {
+ "font-family": "MathJax_Caligraphic-WEB",
+ "src": "url('"+fontDir+"/MathJax_Caligraphic-Regular.otf')"
+ },
+ '@font-face /*2*/': {
+ "font-family": "MathJax_Caligraphic-WEB", "font-weight":"bold",
+ "src": "url('"+fontDir+"/MathJax_Caligraphic-Bold.otf')"
+ }
+ }
+ }
+ });
+ if (!this.handlesVariants) {
+ nMML.Augment({
+ config: {
+ styles: {
+ '[mathvariant="double-struck"]': {"font-family":"MathJax_AMS, MathJax_AMS-WEB"},
+ '[mathvariant="script"]': {"font-family":"MathJax_Script, MathJax_Script-WEB"},
+ '[mathvariant="fraktur"]': {"font-family":"MathJax_Fraktur, MathJax_Fraktur-WEB"},
+ '[mathvariant="bold-script"]': {"font-family":"MathJax_Script, MathJax_Caligraphic-WEB", "font-weight":"bold"},
+ '[mathvariant="bold-fraktur"]': {"font-family":"MathJax_Fraktur, MathJax_Fraktur-WEB", "font-weight":"bold"},
+ '[mathvariant="monospace"]': {"font-family":"monospace"},
+ '[mathvariant="sans-serif"]': {"font-family":"sans-serif"},
+ '[mathvariant="bold-sans-serif"]': {"font-family":"sans-serif", "font-weight":"bold"},
+ '[mathvariant="sans-serif-italic"]': {"font-family":"sans-serif", "font-style":"italic"},
+ '[mathvariant="sans-serif-bold-italic"]': {"font-family":"sans-serif", "font-style":"italic", "font-weight":"bold"},
+
+ '@font-face /*3*/': {
+ "font-family": "MathJax_AMS-WEB",
+ "src": "url('"+fontDir+"/MathJax_AMS-Regular.otf')"
+ },
+ '@font-face /*4*/': {
+ "font-family": "MathJax_Script-WEB",
+ "src": "url('"+fontDir+"/MathJax_Script-Regular.otf')"
+ },
+ '@font-face /*5*/': {
+ "font-family": "MathJax_Fraktur-WEB",
+ "src": "url('"+fontDir+"/MathJax_Fraktur-Regular.otf')"
+ },
+ '@font-face /*6*/': {
+ "font-family": "MathJax_Fraktur-WEB", "font-weight":"bold",
+ "src": "url('"+fontDir+"/MathJax_Fraktur-Bold.otf')"
+ }
+ }
+ }
+ });
+ }
+ }
+
+ MML.math.Augment({
+ toNativeMML: function (parent,jax) {
+ var tag = this.NativeMMLelement(this.type), math = tag;
+ var annotate = (jax ? MathJax.InputJax[jax.inputJax].annotationEncoding : null);
+ var i, m;
+ nMML.adjustWidths = [];
+ //
+ // Some browsers don't seem to add the xmlns attribute, so do it by hand.
+ //
+ tag.setAttribute("xmlns",nMML.MMLnamespace);
+ this.NativeMMLattributes(tag);
+ //
+ // Use an extra <mrow> in FF so that we can get the correct width
+ // (the math element doesn't always have an accurate one, see below)
+ //
+ if (nMML.widthBug) {tag = tag.appendChild(this.NativeMMLelement("mrow"))}
+ //
+ // Addannotation if the input jax provides an annotation encoding
+ //
+ if (annotate) {
+ tag = tag.appendChild(this.NativeMMLelement("semantics"))
+ tag.appendChild(this.NativeMMLelement("mrow"));
+ var annotation = tag.appendChild(this.NativeMMLelement("annotation"));
+ annotation.appendChild(document.createTextNode(jax.originalText));
+ annotation.setAttribute("encoding",annotate);
+ tag = tag.firstChild; // mrow
+ }
+ //
+ // Add the children
+ //
+ for (i = 0, m = this.data.length; i < m; i++) {
+ if (this.data[i]) {this.data[i].toNativeMML(tag)}
+ else {tag.appendChild(this.NativeMMLelement("mrow"))}
+ }
+ //
+ // Look for a top-level mtable and if it has labels
+ // Make sure the containers have 100% width, when needed.
+ // If the label is on the same side as alignment,
+ // override the margin set by the stylesheet.
+ //
+ var mtable = ((this.data[0]||{data:[]}).data[0]||{});
+ if (mtable.nMMLhasLabels) {
+ if (mtable.nMMLforceWidth || !mtable.nMMLlaMatch) {
+ tag.setAttribute("style","width:100%") // mrow node
+ if (annotate) tag.parentNode.setAttribute("style","width:100%"); // semantics node
+ };
+ if (mtable.nMMLlaMatch) {
+ if (parent.parentNode.parentNode.nodeName.toLowerCase() === "div") {
+ parent.parentNode.parentNode.style
+ .setProperty("margin-"+HUB.config.displayAlign,"0px","important");
+ }
+ }
+ }
+ //
+ // Check if container must have width set to 100%
+ //
+ var fullWidth = nMML.isFullWidth(math);
+ if (fullWidth) {parent.style.width = parent.parentNode.style.width = "100%"}
+ //
+ // Add the math to the page
+ //
+ parent.appendChild(math);
+ //
+ // Firefox can't seem to get the width of <math> elements right, so
+ // use an <mrow> to get the actual width and set the style on the
+ // parent element to match. Even if we set the <math> width properly,
+ // it doesn't seem to propagate up to the <span> correctly.
+ //
+ if (nMML.widthBug &&!fullWidth) {
+ //
+ // Convert size to ex's so that it scales properly if the print media
+ // has a different font size.
+ //
+ parent.style.width = (math.firstChild.scrollWidth/nMML.ex/nMML.scale).toFixed(3) + "ex";
+ //
+ // Save size for later when we check if Web fonts have arrived
+ //
+ if (jax) {jax.NativeMML.scrollWidth = math.firstChild.scrollWidth}
+ }
+ if (nMML.adjustWidths.length) {
+ //
+ // Firefox gets the widths of <mtd> elements wrong, so run
+ // through them (now that the math is part of the page) and
+ // fix them up. Use ex's so that they print properly (see above).
+ //
+ var mtd = [];
+ for (i = 0, m = nMML.adjustWidths.length; i < m; i++) {
+ tag = nMML.adjustWidths[i];
+ var style = tag.getAttribute("style") || "";
+ if (!style.match(/(^|;)\s*min-width:/)) {
+ var width = tag.firstChild.scrollWidth;
+ mtd.push(width);
+ width = (width/nMML.ex).toFixed(3)+"ex";
+ style = style.replace(/;?\s*$/,"; ");
+ tag.setAttribute("style",style+"min-width:"+width);
+ }
+ }
+ //
+ // Save the lists so that we can check them later for web font downloads
+ //
+ if (!jax) {jax = HUB.getJaxFor(parent)}
+ if (jax) {jax.NativeMML.mtds = mtd}
+ math.MathJaxMtds = nMML.adjustWidths;
+ nMML.adjustWidths = []; // clear it so we don't hold onto the DOM elements
+ }
+ }
+ });
+
+ MML.mfenced.Augment({
+ toNativeMML: function (parent) {
+ if (!nMML.mfencedBug) {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ return;
+ }
+
+ //
+ // Some browsers do not handle <mfenced> very well. The MathML spec
+ // suggests this equivalent construction instead, so let's use it:
+ // <mrow> open, child1, sep1, child2, ... sep(N-1), childN, close</mrow>
+ // Opera is a bit special: it does not support stretchy <mo>, does not
+ // parse mfenced@open/mfenced@close very well, does not support
+ // mfenced@separators and only displays the first child of the <mfenced>
+ // element... For this browser, we will use this construction:
+ // <mfenced open="open" close="close">
+ // <mrow>child1, sep1, child2, sep2, ..., sep(N-1), childN</mrow>
+ // </mfenced>
+ //
+ var isOpera = HUB.Browser.isOpera;
+ var i, m, operator;
+
+ //
+ // parse the open, close and separators attributes.
+ //
+ var values = this.getValues("open","close","separators");
+ values.open = values.open.replace(/^\s+/,"").replace(/\s+$/,"");
+ values.close = values.close.replace(/^\s+/,"").replace(/\s+$/,"");
+ values.separators = values.separators.replace(/\s+/g,"").split("");
+ if (values.separators.length == 0) {
+ //
+ // No separators specified, do not use separators at all.
+ //
+ values.separators = null;
+ } else if (values.separators.length < this.data.length-1) {
+ //
+ // There are not enough separators, repeat the last one.
+ //
+ var s = values.separators[values.separators.length-1];
+ for (i = this.data.length-1-values.separators.length; i > 0; i--)
+ {values.separators.push(s)}
+ }
+
+ //
+ // Create an <mrow> container and attach the attributes of the
+ // <mfenced> element to it. Note: removeAttribute does not raise any
+ // exception when the attributes is absent.
+ //
+ var tag = this.NativeMMLelement(isOpera ? this.type : "mrow");
+ this.NativeMMLattributes(tag);
+ tag.removeAttribute("separators");
+ if (isOpera) {
+ tag.setAttribute("open", values.open);
+ tag.setAttribute("close", values.close);
+ if (this.data.length > 1) {
+ parent.appendChild(tag); parent = tag;
+ tag = this.NativeMMLelement("mrow");
+ }
+ } else {
+ tag.removeAttribute("open");
+ tag.removeAttribute("close");
+ }
+
+ if (!isOpera) {
+ //
+ // Append the opening fence
+ //
+ operator = this.NativeMMLelement("mo");
+ operator.setAttribute("fence", "true");
+ operator.textContent = values.open;
+ tag.appendChild(operator);
+ }
+
+ //
+ // Append the content of the <mfenced>
+ //
+ for (i = 0, m = this.data.length; i < m; i++) {
+ if (values.separators && i > 0) {
+ operator = this.NativeMMLelement("mo");
+ operator.setAttribute("separator", "true");
+ operator.textContent = values.separators[i-1];
+ tag.appendChild(operator);
+ }
+ if (this.data[i]) {this.data[i].toNativeMML(tag)}
+ else {tag.appendChild(this.NativeMMLelement("mrow"))}
+ }
+
+ if (!isOpera) {
+ //
+ // Append the closing fence
+ //
+ operator = this.NativeMMLelement("mo");
+ operator.setAttribute("fence", "true");
+ operator.textContent = values.close;
+ tag.appendChild(operator);
+ }
+
+ // finally, append the new element to the parent.
+ parent.appendChild(tag);
+ }
+ });
+
+ MML.TeXAtom.Augment({
+ //
+ // Convert TeXatom to an mrow
+ //
+ toNativeMML: function (parent) {
+ // FIXME: Handle spacing using mpadded?
+ var tag = this.NativeMMLelement("mrow");
+ this.NativeMMLattributes(tag);
+ this.data[0].toNativeMML(tag);
+ parent.appendChild(tag);
+ }
+ });
+
+ MML.chars.Augment({
+ //
+ // Add a text node
+ //
+ toNativeMML: function (parent,remap) {
+ var text = this.toString();
+ if (remap) text = remap(text);
+ parent.appendChild(document.createTextNode(text));
+ }
+ });
+
+ MML.entity.Augment({
+ //
+ // Add a text node
+ //
+ toNativeMML: function (parent) {
+ parent.appendChild(document.createTextNode(this.toString()));
+ }
+ });
+
+ MML.xml.Augment({
+ //
+ // Insert the XML verbatim
+ //
+ toNativeMML: function (parent) {
+ for (var i = 0, m = this.data.length; i < m; i++)
+ {parent.appendChild(this.data[i].cloneNode(true))}
+ }
+ });
+
+ MML.mi.Augment({
+ toNativeMML: function (parent) {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ if (nMML.miItalicBug) {
+ if (this.Get("mathvariant") === MML.VARIANT.NORMAL) {
+ //
+ // When not explicitly specified, mathvariant is set to "italic"
+ // with single char mi and to "normal" with multiple char mi.
+ // Some browsers always set the default to "italic", so let's
+ // attach an explicit mathvariant="normal" attribute.
+ //
+ var mi = parent.lastChild;
+ mi.setAttribute("mathvariant",MML.VARIANT.NORMAL);
+ }
+ }
+ }
+ });
+
+ MML.mo.Augment({
+ toNativeMML: function (parent) {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ if (nMML.webkitMoSpacingBug) {
+ //
+ // WebKit does not support lspace/rspace values around operators
+ // (neither explicit nor given by the operator dictionary) and uses
+ // constant values instead. So let's modify the CSS properties here.
+ //
+
+ var lspace = 0, rspace = 0, p = this.parent;
+ if (p && p.type === "mrow" && (p.inferred || !p.isEmbellished())) {
+ //
+ // Retrieve the values of lspace/rspace and convert named spaces.
+ // Other values (except unitless) will be parsed by the CSS engine.
+ //
+ var values = this.getValues("lspace", "rspace");
+ lspace = values.lspace, rspace = values.rspace;
+ if (nMML.NAMEDSPACE[lspace]) {lspace = nMML.NAMEDSPACE[lspace]}
+ if (nMML.NAMEDSPACE[rspace]) {rspace = nMML.NAMEDSPACE[rspace]}
+ }
+
+ //
+ // Now update -webkit-margin-start and -webkit-margin-end.
+ //
+ var mo = parent.lastChild;
+ var span = HTML.Element("span");
+ span.style.cssText = (mo.getAttribute("style")||"");
+ span.style.setProperty("-webkit-margin-start", lspace);
+ span.style.setProperty("-webkit-margin-end", rspace);
+ mo.setAttribute("style",span.style.cssText);
+ }
+ }
+ });
+
+ MML.mmultiscripts.Augment({
+ toNativeMML: function (parent) {
+ //
+ // Some browsers do not implement the mmultiscripts element.
+ // Try to emulate the support using basic script elements.
+ //
+ if (!nMML.mmultiscriptsBug || this.data.length === 0) {
+ this.SUPER(arguments).toNativeMML.call(this,parent);
+ return;
+ }
+
+ //
+ // The children of the mmultiscripts will be wrapped in an mrow so that
+ // attributes and properties set on the original mmultiscripts will
+ // be reflected on this mrow element.
+ //
+ var tag = this.NativeMMLelement("mrow");
+ this.NativeMMLattributes(tag);
+
+ //
+ // Create the base
+ //
+ if (this.data[0]) {this.data[0].toNativeMML(tag)}
+ else {tag.appendChild(this.NativeMMLelement("mrow"))}
+ var base = tag.removeChild(tag.lastChild);
+
+ //
+ // Process the postscript pairs
+ //
+ var m = this.data.length, i, msubsup;
+ for (i = 1; i < m; i+=2) {
+ if (this.data[i].type === "mprescripts") break;
+
+ msubsup = this.NativeMMLelement("msubsup");
+ msubsup.appendChild(base);
+
+ //
+ // append the subscript
+ //
+ if (this.data[i]) {this.data[i].toNativeMML(msubsup)}
+ else {msubsup.appendChild(this.NativeMMLelement("mrow"))}
+
+ //
+ // append the supscript
+ //
+ if (i+1 < m && this.data[i+1]) {this.data[i+1].toNativeMML(msubsup)}
+ else {msubsup.appendChild(this.NativeMMLelement("mrow"))}
+
+ base = msubsup;
+ }
+
+ tag.appendChild(base);
+
+ //
+ // Process the prescript pairs
+ //
+ for (i++; i < m; i+=2) {
+ msubsup = this.NativeMMLelement("msubsup");
+ msubsup.appendChild(this.NativeMMLelement("mrow"));
+
+ //
+ // append the presubscript
+ //
+ if (this.data[i]) {this.data[i].toNativeMML(msubsup)}
+ else {msubsup.appendChild(this.NativeMMLelement("mrow"))}
+
+ //
+ // append the presupscript
+ //
+ if (i+1 < m && this.data[i+1]) {this.data[i+1].toNativeMML(msubsup)}
+ else {msubsup.appendChild(this.NativeMMLelement("mrow"))}
+
+ tag.insertBefore(msubsup, base);
+ }
+
+ parent.appendChild(tag);
+ }
+ });
+
+ HUB.Register.StartupHook("TeX mathchoice Ready",function () {
+ MML.TeXmathchoice.Augment({
+ //
+ // Get the MathML for the selected choice
+ //
+ toNativeMML: function (parent) {this.Core().toNativeMML(parent)}
+ });
+ });
+
+ //
+ // Loading isn't complete until the element jax is modified,
+ // but can't call loadComplete within the callback for "mml Jax Ready"
+ // (it would call NativeMML's Require routine, asking for the mml jax again)
+ // so wait until after the mml jax has finished processing.
+ //
+ setTimeout(MathJax.Callback(["loadComplete",nMML,"jax.js"]),0);
+ });
+
+
+ //
+ // Determine browser characteristics
+ //
+ HUB.Browser.Select({
+ MSIE: function (browser) {
+ var mode = (document.documentMode || 0);
+ nMML.msieIE8HeightBug = (mode === 8);
+ },
+ Opera: function (browser) {
+ nMML.stretchyMoBug = true;
+ nMML.tableLabelBug = true;
+ nMML.mfencedBug = true;
+ nMML.miBug = true;
+ nMML.mmultiscriptsBug = true;
+ },
+ Firefox: function (browser) {
+ var is29 = browser.versionAtLeast("29.0");
+ nMML.ffTableWidthBug = !browser.versionAtLeast("13.0"); // <mtable width="xx"> not implemented
+ nMML.forceReflow = !is29; // <mtable> with alignments set don't display properly without a reflow
+ nMML.widthBug = !is29; // <math> elements don't always get the correct width
+ nMML.mtdWidthBug = true; // <mtd> widths not properly determined
+ nMML.handlesVariants = is29; // FF >=29 handles all math variants
+
+ // In Firefox < 20, the intrinsic width of <mspace> is not computed
+ // correctly and thus the element is displayed incorrectly in <mtable>.
+ nMML.spaceWidthBug = !browser.versionAtLeast("20.0");
+
+ // mtable@rowspacing/mtable@columnspacing not supported.
+ nMML.tableSpacingBug = !browser.versionAtLeast("33.0");
+ nMML.tableLabelBug = true; // mlabeledtr is not implemented.
+ nMML.mfencedBug = true; // mfenced not displayed correctly
+ },
+ Chrome: function (browser) {
+ nMML.tableSpacingBug = true;
+ nMML.tableLabelBug = true;
+ nMML.mfencedBug = true;
+ },
+ Safari: function (browser) {
+ nMML.tableSpacingBug = true;
+ nMML.tableLabelBug = true;
+ nMML.mfencedBug = true;
+ nMML.miItalicBug = true;
+ nMML.webkitMoSpacingBug = true;
+ nMML.spaceWidthBug = true;
+ nMML.mmultiscriptsBug = true;
+ }
+ });
+
+
+ HUB.Register.StartupHook("End Cookie",function () {
+ if (HUB.config.menuSettings.zoom !== "None")
+ {AJAX.Require("[MathJax]/extensions/MathZoom.js")}
+ });
+
+})(MathJax.OutputJax.NativeMML, MathJax.Hub, MathJax.Ajax, MathJax.HTML);
+// @license-end
diff --git a/js/mathjax/jax/output/PlainSource/config.js b/js/mathjax/jax/output/PlainSource/config.js
new file mode 100644
index 0000000..3d6d6be
--- /dev/null
+++ b/js/mathjax/jax/output/PlainSource/config.js
@@ -0,0 +1,51 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/PlainSource/config.js
+ *
+ * Initializes the PlainSource OutputJax (the main definition is in
+ * MathJax/jax/input/PlainSource/jax.js, which is loaded when needed).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.OutputJax.PlainSource = MathJax.OutputJax({
+ id: "PlainSource",
+ version: "2.7.9",
+ directory: MathJax.OutputJax.directory + "/PlainSource",
+ extensionDir: MathJax.OutputJax.extensionDir + "/PlainSource",
+
+ config: {
+ styles: {
+ ".MathJax_PlainSource_Display": {
+ "text-align": "center",
+ margin: ".75em 0px",
+ "white-space":"pre"
+ },
+ ".MathJax_PlainSource_Display > span": {
+ display: "inline-block",
+ "text-align": "left"
+ }
+ }
+ }
+});
+
+if (!MathJax.Hub.config.delayJaxRegistration)
+ MathJax.OutputJax.PlainSource.Register("jax/mml");
+
+MathJax.OutputJax.PlainSource.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/output/PlainSource/jax.js b/js/mathjax/jax/output/PlainSource/jax.js
new file mode 100644
index 0000000..fb62d44
--- /dev/null
+++ b/js/mathjax/jax/output/PlainSource/jax.js
@@ -0,0 +1,186 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/*************************************************************
+ *
+ * MathJax/jax/output/PlainSource/jax.js
+ *
+ * Implements the PlainSource OutputJax that displays whatever
+ * source there was, for assistive technology users who prefer this.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(function(AJAX, HUB, HTML, PlainSource) {
+
+ var EVENT, TOUCH, HOVER; // filled in later
+
+ PlainSource.Augment({
+ settings: HUB.config.menuSettings,
+
+ Config: function() {
+ if (!this.require) this.require = [];
+ this.SUPER(arguments).Config.call(this);
+ this.require.push(MathJax.OutputJax.extensionDir + "/MathEvents.js");
+ },
+
+ Startup: function() {
+ //
+ // Set up event handling
+ //
+ EVENT = MathJax.Extension.MathEvents.Event;
+ TOUCH = MathJax.Extension.MathEvents.Touch;
+ HOVER = MathJax.Extension.MathEvents.Hover;
+ this.ContextMenu = EVENT.ContextMenu;
+ this.Mousedown = EVENT.AltContextMenu;
+ this.Mouseover = HOVER.Mouseover;
+ this.Mouseout = HOVER.Mouseout;
+ this.Mousemove = HOVER.Mousemove;
+ return AJAX.Styles(this.config.styles);
+ },
+
+ preTranslate: function(state) {
+ var scripts = state.jax[this.id],
+ i, m = scripts.length,
+ script, prev, span, div, jax;
+ //
+ // Loop through the scripts
+ //
+ for (i = 0; i < m; i++) {
+ script = scripts[i];
+ if (!script.parentNode) continue;
+ //
+ // Remove any existing output
+ //
+ prev = script.previousSibling;
+ if (prev && String(prev.className).match(/^MathJax(_PlainSource)?(_Display)?( MathJax_Process(ing|ed))?$/)) {
+ prev.parentNode.removeChild(prev);
+ }
+ //
+ // Add the span, and a div if in display mode
+ //
+ jax = script.MathJax.elementJax;
+ if (!jax) continue;
+ jax.PlainSource = {
+ display: (jax.root.Get("display") === "block")
+ }
+ span = div = HTML.Element("span", {
+ className: "MathJax_PlainSource",
+ id: jax.inputID + "-Frame",
+ isMathJax: true,
+ jaxID: this.id,
+ oncontextmenu: EVENT.Menu,
+ onmousedown: EVENT.Mousedown,
+ onmouseover: EVENT.Mouseover,
+ onmouseout: EVENT.Mouseout,
+ onmousemove: EVENT.Mousemove,
+ onclick: EVENT.Click,
+ ondblclick: EVENT.DblClick,
+ // Added for keyboard accessible menu.
+ onkeydown: EVENT.Keydown,
+ tabIndex: HUB.getTabOrder(jax)
+ },[["span"]]);
+ if (HUB.Browser.noContextMenu) {
+ span.ontouchstart = TOUCH.start;
+ span.ontouchend = TOUCH.end;
+ }
+ if (jax.PlainSource.display) {
+ div = HTML.Element("div", {
+ className: "MathJax_PlainSource_Display"
+ });
+ div.appendChild(span);
+ }
+ script.parentNode.insertBefore(div, script);
+ }
+ },
+
+ Translate: function(script, state) {
+ if (!script.parentNode) return;
+
+ //
+ // Get the data about the math
+ //
+ var jax = script.MathJax.elementJax,
+ math = jax.root,
+ span = document.getElementById(jax.inputID + "-Frame");
+ //
+ // Typeset the math
+ //
+ this.initPlainSource(math, span);
+ var source = jax.originalText;
+ if (jax.inputJax === "MathML") {
+ if ((jax.root.data[0].data.length > 0) && (jax.root.data[0].data[0].type === "semantics")) {
+ var annotations = jax.root.data[0].data[0].data;
+ for (var a = 0; a < annotations.length; a++){
+ if (annotations[a].attr.encoding === "application/x-tex"){
+ source = jax.root.data[0].data[0].data[a].data[0].data[0];
+ break;
+ }
+ if (annotations[a].attr.encoding === "text/x-asciimath") {
+ source = jax.root.data[0].data[0].data[a].data[0].data[0];
+ }
+ }
+ }
+ }
+ jax.PlainSource.source = source;
+ HTML.addText(span.firstChild,source);
+ },
+
+ postTranslate: function(state) {},
+
+ getJaxFromMath: function(math) {
+ if (math.parentNode.className.match(/MathJax_PlainSource_Display/)) math = math.parentNode;
+ do {math = math.nextSibling} while (math && math.nodeName.toLowerCase() !== "script");
+ return HUB.getJaxFor(math);
+ },
+
+ Zoom: function (jax,span,math,Mw,Mh) {
+ var pad = Math.round(span.parentNode.offsetWidth / 2);
+ span.style.whiteSpace = "pre";
+ HTML.addText(span,jax.PlainSource.source);
+ var mW = math.offsetWidth, mH = math.offsetHeight,
+ zW = span.offsetWidth, zH = span.offsetHeight;
+ var Y = -Math.round((zH+mH)/2) - (jax.PlainSource.display ? 0 : pad);
+ return {mW:mW, mH:mH, zW:zW, zH:zH, Y:Y};
+ },
+
+ initPlainSource: function(math, span) {},
+
+ Remove: function(jax) {
+ var span = document.getElementById(jax.inputID + "-Frame");
+ if (span) {
+ if (jax.PlainSource.display) span = span.parentNode;
+ span.parentNode.removeChild(span);
+ }
+ delete jax.PlainSource;
+ }
+
+ });
+
+ MathJax.Hub.Register.StartupHook("mml Jax Ready", function() {
+ MathJax.Hub.Register.StartupHook("onLoad", function() {
+ setTimeout(MathJax.Callback(["loadComplete", PlainSource, "jax.js"]), 0);
+ });
+ });
+
+ MathJax.Hub.Register.StartupHook("End Cookie", function() {
+ if (HUB.config.menuSettings.zoom !== "None") {
+ AJAX.Require("[MathJax]/extensions/MathZoom.js")
+ }
+ });
+
+})(MathJax.Ajax, MathJax.Hub, MathJax.HTML, MathJax.OutputJax.PlainSource);
+// @license-end
diff --git a/js/mathjax/jax/output/PreviewHTML/config.js b/js/mathjax/jax/output/PreviewHTML/config.js
new file mode 100644
index 0000000..866f2f0
--- /dev/null
+++ b/js/mathjax/jax/output/PreviewHTML/config.js
@@ -0,0 +1,56 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/PreviewHTML/config.js
+ *
+ * Initializes the PreviewHTML OutputJax (the main definition is in
+ * MathJax/jax/input/PreviewHTML/jax.js, which is loaded when needed).
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2013-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+MathJax.OutputJax.PreviewHTML = MathJax.OutputJax({
+ id: "PreviewHTML",
+ version: "2.7.9",
+ directory: MathJax.OutputJax.directory + "/PreviewHTML",
+ extensionDir: MathJax.OutputJax.extensionDir + "/PreviewHTML",
+ noFastPreview: true, // don't do fast preview for this output jax
+
+ config: {
+ scale: 100, minScaleAdjust: 50, // global math scaling factor, and minimum adjusted scale factor
+ mtextFontInherit: false, // to make <mtext> be in page font rather than MathJax font
+
+ linebreaks: {
+ automatic: false, // when false, only process linebreak="newline",
+ // when true, insert line breaks automatically in long expressions.
+
+ width: "container" // maximum width of a line for automatic line breaks (e.g. "30em").
+ // use "container" to compute size from containing element,
+ // use "nn% container" for a portion of the container,
+ // use "nn%" for a portion of the window size
+ }
+
+ }
+});
+
+if (!MathJax.Hub.config.delayJaxRegistration) {MathJax.OutputJax.PreviewHTML.Register("jax/mml")}
+
+MathJax.OutputJax.PreviewHTML.loadComplete("config.js");
+// @license-end
diff --git a/js/mathjax/jax/output/PreviewHTML/jax.js b/js/mathjax/jax/output/PreviewHTML/jax.js
new file mode 100644
index 0000000..9fc3b4c
--- /dev/null
+++ b/js/mathjax/jax/output/PreviewHTML/jax.js
@@ -0,0 +1,1098 @@
+// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0
+/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+
+/*************************************************************
+ *
+ * MathJax/jax/output/PreviewHTML/jax.js
+ *
+ * Implements the PreviewHTML OutputJax that displays mathematics
+ * using HTML to position the characters from math fonts
+ * in their proper locations.
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2013-2020 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(function (AJAX,HUB,HTML,PHTML) {
+ var MML;
+
+ var EVENT, TOUCH, HOVER; // filled in later
+
+ var FONTS = "'Times New Roman',Times,STIXGeneral,serif";
+ var STYLES = {
+ ".MJXp-script": {"font-size":".8em"},
+
+ ".MJXp-right": {
+ "-webkit-transform-origin":"right",
+ "-moz-transform-origin":"right",
+ "-ms-transform-origin":"right",
+ "-o-transform-origin":"right",
+ "transform-origin":"right"
+ },
+
+ ".MJXp-bold": {"font-weight":"bold"},
+ ".MJXp-italic": {"font-style":"italic"},
+ ".MJXp-scr": {"font-family":"MathJax_Script,"+FONTS},
+ ".MJXp-frak": {"font-family":"MathJax_Fraktur,"+FONTS},
+ ".MJXp-sf": {"font-family":"MathJax_SansSerif,"+FONTS},
+ ".MJXp-cal": {"font-family":"MathJax_Caligraphic,"+FONTS},
+ ".MJXp-mono": {"font-family":"MathJax_Typewriter,"+FONTS},
+ ".MJXp-largeop": {"font-size":"150%"},
+ ".MJXp-largeop.MJXp-int": {"vertical-align":"-.2em"},
+
+ ".MJXp-math": {
+ "display": "inline-block",
+ "line-height": "1.2",
+ "text-indent": "0",
+ "font-family": FONTS,
+ "white-space":"nowrap",
+ "border-collapse":"collapse"
+ },
+ ".MJXp-display": {
+ "display": "block",
+ "text-align": "center",
+ "margin": "1em 0"
+ },
+ ".MJXp-math span": {"display": "inline-block"},
+ ".MJXp-box": {"display":"block!important", "text-align": "center"},
+ ".MJXp-box:after": {"content": '" "'}, // needed for when there is no DOCTYPE
+ ".MJXp-rule": {"display":"block!important", "margin-top":".1em"},
+ ".MJXp-char": {"display":"block!important"},
+
+ ".MJXp-mo": {"margin": "0 .15em"},
+
+ ".MJXp-mfrac": {"margin": "0 .125em", "vertical-align":".25em"},
+ ".MJXp-denom": {"display": "inline-table!important", "width":"100%"},
+ ".MJXp-denom > *": {"display": "table-row!important"},
+
+ ".MJXp-surd": {"vertical-align":"top"},
+ ".MJXp-surd > *": {"display":"block!important"},
+
+ ".MJXp-script-box > * ": {"display":"table!important", "height":"50%"},
+ ".MJXp-script-box > * > *": {"display":"table-cell!important","vertical-align":"top"},
+ ".MJXp-script-box > *:last-child > *": {"vertical-align":"bottom"},
+ ".MJXp-script-box > * > * > *": {"display":"block!important"},
+
+ ".MJXp-mphantom": {"visibility": "hidden"},
+
+ ".MJXp-munderover, .MJXp-munder": {"display":"inline-table!important"},
+ ".MJXp-over": {"display":"inline-block!important","text-align":"center"},
+ ".MJXp-over > *": {"display":"block!important"},
+ ".MJXp-munderover > *, .MJXp-munder > *": {"display":"table-row!important"},
+
+ ".MJXp-mtable": {"vertical-align":".25em", "margin":"0 .125em"},
+ ".MJXp-mtable > *": {"display":"inline-table!important", "vertical-align":"middle"},
+ ".MJXp-mtr": {"display":"table-row!important"},
+ ".MJXp-mtd": {"display":"table-cell!important","text-align":"center","padding":".5em 0 0 .5em"},
+ ".MJXp-mtr > .MJXp-mtd:first-child": {"padding-left":0},
+ ".MJXp-mtr:first-child > .MJXp-mtd": {"padding-top":0},
+ ".MJXp-mlabeledtr": {"display":"table-row!important"},
+ ".MJXp-mlabeledtr > .MJXp-mtd:first-child": {"padding-left":0},
+ ".MJXp-mlabeledtr:first-child > .MJXp-mtd": {"padding-top":0},
+
+ ".MJXp-merror": {
+ "background-color": "#FFFF88",
+ color: "#CC0000",
+ border: "1px solid #CC0000",
+ padding: "1px 3px",
+ "font-style": "normal",
+ "font-size": "90%"
+ }
+ };
+
+ (function () {
+ for (var i = 0; i < 10; i++) {
+ var scale = "scaleX(."+i+")";
+ STYLES[".MJXp-scale"+i] = {
+ "-webkit-transform":scale,
+ "-moz-transform":scale,
+ "-ms-transform":scale,
+ "-o-transform":scale,
+ "transform":scale
+ }
+ }
+ })();
+
+ var BIGDIMEN = 1000000;
+ var V = "V", H = "H";
+
+ PHTML.Augment({
+ settings: HUB.config.menuSettings,
+ config: {styles: STYLES},
+
+ hideProcessedMath: false, // use display:none until all math is processed
+
+ maxStretchyParts: 1000, // limit the number of parts allowed for
+ // stretchy operators. See issue 366.
+
+ Config: function () {
+ if (!this.require) {this.require = []}
+ this.SUPER(arguments).Config.call(this); var settings = this.settings;
+ if (settings.scale) {this.config.scale = settings.scale}
+ this.require.push(MathJax.OutputJax.extensionDir+"/MathEvents.js");
+ },
+
+ Startup: function () {
+ //
+ // Set up event handling
+ //
+ EVENT = MathJax.Extension.MathEvents.Event;
+ TOUCH = MathJax.Extension.MathEvents.Touch;
+ HOVER = MathJax.Extension.MathEvents.Hover;
+ this.ContextMenu = EVENT.ContextMenu;
+ this.Mousedown = EVENT.AltContextMenu;
+ this.Mouseover = HOVER.Mouseover;
+ this.Mouseout = HOVER.Mouseout;
+ this.Mousemove = HOVER.Mousemove;
+
+ //
+ // Determine pixels per inch
+ //
+ var div = HTML.addElement(document.body,"div",{style:{width:"5in"}});
+ this.pxPerInch = div.offsetWidth/5; div.parentNode.removeChild(div);
+
+ //
+ // Set up styles and preload web fonts
+ //
+ return AJAX.Styles(this.config.styles,["InitializePHTML",this]);
+ },
+ InitializePHTML: function () {
+ },
+
+ preTranslate: function (state) {
+ var scripts = state.jax[this.id], i, m = scripts.length,
+ script, prev, span, div, jax;
+ //
+ // Loop through the scripts
+ //
+ for (i = 0; i < m; i++) {
+ script = scripts[i]; if (!script.parentNode) continue;
+ //
+ // Remove any existing output
+ //
+ prev = script.previousSibling;
+ if (prev && String(prev.className).match(/^MathJax(_PHTML)?(_Display)?( MathJax_Process(ing|ed))?$/))
+ {prev.parentNode.removeChild(prev)}
+ //
+ // Add the span, and a div if in display mode,
+ // then mark it as being processed
+ //
+ jax = script.MathJax.elementJax; if (!jax) continue;
+ jax.PHTML = {display: (jax.root.Get("display") === "block")}
+ span = div = HTML.Element("span",{
+ className:"MathJax_PHTML", id:jax.inputID+"-Frame", isMathJax:true, jaxID:this.id,
+ oncontextmenu:EVENT.Menu, onmousedown: EVENT.Mousedown,
+ onmouseover:EVENT.Mouseover, onmouseout:EVENT.Mouseout, onmousemove:EVENT.Mousemove,
+ onclick:EVENT.Click, ondblclick:EVENT.DblClick,
+ // Added for keyboard accessible menu.
+ onkeydown: EVENT.Keydown, tabIndex: HUB.getTabOrder(jax)
+ });
+ if (HUB.Browser.noContextMenu) {
+ span.ontouchstart = TOUCH.start;
+ span.ontouchend = TOUCH.end;
+ }
+ if (jax.PHTML.display) {
+ div = HTML.Element("div",{className:"MathJax_PHTML_Display"});
+ div.appendChild(span);
+ }
+ //
+ div.className += " MathJax_Processing";
+ script.parentNode.insertBefore(div,script);
+ }
+ },
+
+ Translate: function (script,state) {
+ if (!script.parentNode) return;
+
+ //
+ // Get the data about the math
+ //
+ var jax = script.MathJax.elementJax, math = jax.root,
+ span = document.getElementById(jax.inputID+"-Frame"),
+ div = (jax.PHTML.display ? span.parentNode : span);
+ //
+ // Typeset the math
+ //
+ this.initPHTML(math,span);
+// math.setTeXclass();
+ try {math.toPreviewHTML(span)} catch (err) {
+ if (err.restart) {while (span.firstChild) {span.removeChild(span.firstChild)}}
+ throw err;
+ }
+ //
+ // Put it in place, and remove the processing marker
+ //
+ div.className = div.className.split(/ /)[0];
+ //
+ // Check if we are hiding the math until more is processed
+ //
+ if (this.hideProcessedMath) {
+ //
+ // Hide the math and don't let its preview be removed
+ //
+ div.className += " MathJax_Processed";
+ if (script.MathJax.preview) {
+ jax.PHTML.preview = script.MathJax.preview;
+ delete script.MathJax.preview;
+ }
+ }
+ },
+
+ postTranslate: function (state) {
+ var scripts = state.jax[this.id];
+ if (!this.hideProcessedMath) return;
+ for (var i = 0, m = scripts.length; i < m; i++) {
+ var script = scripts[i];
+ if (script && script.MathJax.elementJax) {
+ //
+ // Remove the processed marker
+ //
+ script.previousSibling.className = script.previousSibling.className.split(/ /)[0];
+ var data = script.MathJax.elementJax.PHTML;
+ //
+ // Remove the preview, if any
+ //
+ if (data.preview) {
+ data.preview.innerHTML = "";
+ script.MathJax.preview = data.preview;
+ delete data.preview;
+ }
+ }
+ }
+ },
+
+ getJaxFromMath: function (math) {
+ if (math.parentNode.className.match(/MathJax_PHTML_Display/)) {math = math.parentNode}
+ do {math = math.nextSibling} while (math && math.nodeName.toLowerCase() !== "script");
+ return HUB.getJaxFor(math);
+ },
+ getHoverSpan: function (jax,math) {return jax.root.PHTMLspanElement()},
+ getHoverBBox: function (jax,span,math) {
+ var bbox = jax.root.PHTML, em = jax.PHTML.outerEm;
+ var BBOX = {w:bbox.w*em, h:bbox.h*em, d:bbox.d*em};
+ if (bbox.width) {BBOX.width = bbox.width}
+ return BBOX;
+ },
+
+ Zoom: function (jax,span,math,Mw,Mh) {
+ //
+ // Re-render at larger size
+ //
+ span.className = "MathJax";
+ this.idPostfix = "-zoom"; jax.root.toPHTML(span,span); this.idPostfix = "";
+ //
+ // Get height and width of zoomed math and original math
+ //
+ span.style.position = "absolute";
+ if (!width) {math.style.position = "absolute"}
+ var zW = span.offsetWidth, zH = span.offsetHeight,
+ mH = math.offsetHeight, mW = math.offsetWidth;
+ if (mW === 0) {mW = math.parentNode.offsetWidth}; // IE7 gets mW == 0?
+ span.style.position = math.style.position = "";
+ //
+ return {Y:-EVENT.getBBox(span).h, mW:mW, mH:mH, zW:zW, zH:zH};
+ },
+
+ initPHTML: function (math,span) {},
+
+ Remove: function (jax) {
+ var span = document.getElementById(jax.inputID+"-Frame");
+ if (span) {
+ if (jax.PHTML.display) {span = span.parentNode}
+ span.parentNode.removeChild(span);
+ }
+ delete jax.PHTML;
+ },
+
+ ID: 0, idPostfix: "",
+ GetID: function () {this.ID++; return this.ID},
+
+ VARIANT: {
+ "bold": "MJXp-bold",
+ "italic": "MJXp-italic",
+ "bold-italic": "MJXp-bold MJXp-italic",
+ "script": "MJXp-scr",
+ "bold-script": "MJXp-scr MJXp-bold",
+ "fraktur": "MJXp-frak",
+ "bold-fraktur": "MJXp-frak MJXp-bold",
+ "monospace": "MJXp-mono",
+ "sans-serif": "MJXp-sf",
+ "-tex-caligraphic": "MJXp-cal"
+ },
+ MATHSPACE: {
+ veryverythinmathspace: 1/18,
+ verythinmathspace: 2/18,
+ thinmathspace: 3/18,
+ mediummathspace: 4/18,
+ thickmathspace: 5/18,
+ verythickmathspace: 6/18,
+ veryverythickmathspace: 7/18,
+ negativeveryverythinmathspace: -1/18,
+ negativeverythinmathspace: -2/18,
+ negativethinmathspace: -3/18,
+ negativemediummathspace: -4/18,
+ negativethickmathspace: -5/18,
+ negativeverythickmathspace: -6/18,
+ negativeveryverythickmathspace: -7/18,
+
+ thin: .08,
+ medium: .1,
+ thick: .15,
+
+ infinity: BIGDIMEN
+ },
+ TeX: {
+ x_height: .430554
+ },
+ pxPerInch: 72,
+ em: 16,
+
+ // ### FIXME: add more here
+
+ DELIMITERS: {
+ "(": {dir:V},
+ "{": {dir:V, w:.58},
+ "[": {dir:V},
+ "|": {dir:V, w:.275},
+ ")": {dir:V},
+ "}": {dir:V, w:.58},
+ "]": {dir:V},
+ "/": {dir:V},
+ "\\": {dir:V},
+ "\u2223": {dir:V, w:.275},
+ "\u2225": {dir:V, w:.55},
+ "\u230A": {dir:V, w:.5},
+ "\u230B": {dir:V, w:.5},
+ "\u2308": {dir:V, w:.5},
+ "\u2309": {dir:V, w:.5},
+ "\u27E8": {dir:V, w:.5},
+ "\u27E9": {dir:V, w:.5},
+ "\u2191": {dir:V, w:.65},
+ "\u2193": {dir:V, w:.65},
+ "\u21D1": {dir:V, w:.75},
+ "\u21D3": {dir:V, w:.75},
+ "\u2195": {dir:V, w:.65},
+ "\u21D5": {dir:V, w:.75},
+ "\u27EE": {dir:V, w:.275},
+ "\u27EF": {dir:V, w:.275},
+ "\u23B0": {dir:V, w:.6},
+ "\u23B1": {dir:V, w:.6}
+ },
+
+ REMAPACCENT: {
+ "\u20D7":"\u2192", // vector arrow
+ "'": "\u02CB",
+ "`": "\u02CA",
+ ".": "\u02D9",
+ "^": "\u02C6",
+ "-": "\u02C9",
+ "~": "\u02DC",
+ "\u00AF": "\u02C9", // macron
+ "\u00B0": "\u02DA", // degree sign
+ "\u00B4": "\u02CA", // acute accent
+ "\u0300": "\u02CB", // combining grave
+ "\u0301": "\u02CA", // combining acute
+ "\u0302": "\u02C6", // combining circumflex
+ "\u0303": "\u02DC", // combinig tilde
+ "\u0304": "\u02C9", // combining macron
+ "\u0305": "\u02C9", // combining overline
+ "\u0306": "\u02D8", // combining breve
+ "\u0307": "\u02D9", // combining dot
+ "\u0308": "\u00A8", // combining double dot
+ "\u030C": "\u02C7" // combining caron
+ },
+ REMAPACCENTUNDER: {
+ },
+
+ length2em: function (length,size) {
+ if (typeof(length) !== "string") {length = length.toString()}
+ if (length === "") {return ""}
+ if (length === MML.SIZE.NORMAL) {return 1}
+ if (length === MML.SIZE.BIG) {return 2}
+ if (length === MML.SIZE.SMALL) {return .71}
+ if (this.MATHSPACE[length]) {return this.MATHSPACE[length]}
+ var match = length.match(/^\s*([-+]?(?:\.\d+|\d+(?:\.\d*)?))?(pt|em|ex|mu|px|pc|in|mm|cm|%)?/);
+ var m = parseFloat(match[1]||"1"), unit = match[2];
+ if (size == null) {size = 1}
+ if (unit === "em") {return m}
+ if (unit === "ex") {return m * this.TeX.x_height}
+ if (unit === "%") {return m / 100 * size}
+ if (unit === "px") {return m / this.em}
+ if (unit === "pt") {return m / 10} // 10 pt to an em
+ if (unit === "pc") {return m * 1.2} // 12 pt to a pc
+ if (unit === "in") {return m * this.pxPerInch / this.em}
+ if (unit === "cm") {return m * this.pxPerInch / this.em / 2.54} // 2.54 cm to an inch
+ if (unit === "mm") {return m * this.pxPerInch / this.em / 25.4} // 10 mm to a cm
+ if (unit === "mu") {return m / 18} // 18mu to an em for the scriptlevel
+ return m*size; // relative to given size (or 1em as default)
+ },
+
+ Em: function (m) {
+ if (Math.abs(m) < .001) return "0em";
+ return (m.toFixed(3).replace(/\.?0+$/,""))+"em";
+ },
+
+ arrayEntry: function (a,i) {return a[Math.max(0,Math.min(i,a.length-1))]}
+
+ });
+
+ MathJax.Hub.Register.StartupHook("mml Jax Ready",function () {
+ MML = MathJax.ElementJax.mml;
+
+ MML.mbase.Augment({
+ toPreviewHTML: function (span,options) {
+ return this.PHTMLdefaultSpan(span,options);
+ },
+
+ PHTMLdefaultSpan: function (span,options) {
+ if (!options) options = {};
+ span = this.PHTMLcreateSpan(span);
+ this.PHTMLhandleStyle(span);
+ this.PHTMLhandleColor(span);
+ if (this.isToken) this.PHTMLhandleToken(span);
+ for (var i = 0, m = this.data.length; i < m; i++) this.PHTMLaddChild(span,i,options);
+ return span;
+ },
+ PHTMLaddChild: function (span,i,options) {
+ var child = this.data[i];
+ if (child) {
+ if (options.childSpans)
+ span = HTML.addElement(span,"span",{className:options.className});
+ child.toPreviewHTML(span);
+ if (!options.noBBox) {
+ this.PHTML.w += child.PHTML.w + child.PHTML.l + child.PHTML.r;
+ if (child.PHTML.h > this.PHTML.h) this.PHTML.h = child.PHTML.h;
+ if (child.PHTML.d > this.PHTML.d) this.PHTML.d = child.PHTML.d;
+ if (child.PHTML.t > this.PHTML.t) this.PHTML.t = child.PHTML.t;
+ if (child.PHTML.b > this.PHTML.b) this.PHTML.b = child.PHTML.b;
+ }
+ } else if (options.forceChild) {HTML.addElement(span,"span")}
+ },
+ PHTMLstretchChild: function (i,H,D) {
+ var data = this.data[i];
+ if (data && data.PHTMLcanStretch("Vertical",H,D)) {
+ var bbox = this.PHTML, dbox = data.PHTML, w = dbox.w;
+ data.PHTMLstretchV(H,D);
+ bbox.w += dbox.w - w;
+ if (dbox.h > bbox.h) bbox.h = dbox.h;
+ if (dbox.d > bbox.d) bbox.d = dbox.d;
+ }
+ },
+
+ PHTMLcreateSpan: function (span) {
+ if (!this.PHTML) this.PHTML = {};
+ this.PHTML = {w:0, h:0, d:0, l:0, r:0, t:0, b:0};
+ if (this.inferred) return span;
+ // ### FIXME: This is a hack to handle the different spacing of the
+ // ### integral sign in Times compared to CM fonts
+ if (this.type === "mo" && this.data.join("") === "\u222B") {PHTML.lastIsInt = true}
+ else if (this.type !== "mspace" || this.width !== "negativethinmathspace") {PHTML.lastIsInt = false}
+ // ###
+ if (!this.PHTMLspanID) {this.PHTMLspanID = PHTML.GetID()};
+ var id = (this.id || "MJXp-Span-"+this.PHTMLspanID);
+ return HTML.addElement(span,"span",{className:"MJXp-"+this.type, id:id});
+ },
+ PHTMLspanElement: function () {
+ if (!this.PHTMLspanID) {return null}
+ return document.getElementById(this.id||"MJXp-Span-"+this.PHTMLspanID);
+ },
+
+ PHTMLhandleToken: function (span) {
+ var values = this.getValues("mathvariant");
+ if (values.mathvariant !== MML.VARIANT.NORMAL) {
+ span.className += " "+PHTML.VARIANT[values.mathvariant];
+ }
+ },
+
+ PHTMLhandleStyle: function (span) {
+ if (this.style) span.style.cssText = this.style;
+ },
+
+ PHTMLhandleColor: function (span) {
+ if (this.mathcolor) {span.style.color = this.mathcolor}
+ if (this.mathbackground) {span.style.backgroundColor = this.mathbackground}
+ },
+
+ PHTMLhandleScriptlevel: function (span) {
+ // ### FIXME: Need to prevent getting too small
+ // ### and should keep track of scaling so it can be compensated for
+ var level = this.Get("scriptlevel");
+ if (level) span.className += " MJXp-script";
+ },
+
+ PHTMLhandleText: function (span,text) {
+ var c, n;
+ var H = 0, D = 0, W = 0;
+ for (var i = 0, m = text.length; i < m; i++) {
+ n = text.charCodeAt(i); c = text.charAt(i);
+ if (n >= 0xD800 && n < 0xDBFF) {
+ i++; n = (((n-0xD800)<<10)+(text.charCodeAt(i)-0xDC00))+0x10000;
+ }
+ var h = .7, d = .22, w = .5;
+ if (n < 127) {
+ if (c.match(/[A-Za-ehik-or-xz0-9]/)) d = 0;
+ if (c.match(/[A-HK-Z]/)) {w = .67} else if (c.match(/[IJ]/)) {w = .36}
+ if (c.match(/[acegm-su-z]/)) {h = .45} else if (c.match(/[ij]/)) {h = .75}
+ if (c.match(/[ijlt]/)) w = .28;
+ }
+ if (PHTML.DELIMITERS[c]) {w = PHTML.DELIMITERS[c].w || .4}
+ // ### FIXME: handle Greek
+ // ### Combining diacriticals (all sets), spacing modifiers
+ // ### arrows (all sets), widths of braces
+ if (h > H) H = h; if (d > D) D = d; W += w;
+ }
+ if (!this.CHML) this.PHTML = {};
+ this.PHTML = {h:.9, d:.3, w:W, l:0, r:0, t:H, b:D};
+ HTML.addText(span,text);
+ },
+
+ PHTMLbboxFor: function (n) {
+ if (this.data[n] && this.data[n].PHTML) return this.data[n].PHTML;
+ return {w:0, h:0, d:0, l:0, r:0, t:0, b:0};
+ },
+
+ PHTMLcanStretch: function (direction,H,D) {
+ if (this.isEmbellished()) {
+ var core = this.Core();
+ if (core && core !== this) {return core.PHTMLcanStretch(direction,H,D)}
+ }
+ return false;
+ },
+ PHTMLstretchV: function (h,d) {},
+ PHTMLstretchH: function (w) {},
+
+ CoreParent: function () {
+ var parent = this;
+ while (parent && parent.isEmbellished() &&
+ parent.CoreMO() === this && !parent.isa(MML.math)) {parent = parent.Parent()}
+ return parent;
+ },
+ CoreText: function (parent) {
+ if (!parent) {return ""}
+ if (parent.isEmbellished()) {return parent.CoreMO().data.join("")}
+ while ((parent.isa(MML.mrow) || parent.isa(MML.TeXAtom) ||
+ parent.isa(MML.mstyle) || parent.isa(MML.mphantom)) &&
+ parent.data.length === 1 && parent.data[0]) {parent = parent.data[0]}
+ if (!parent.isToken) {return ""} else {return parent.data.join("")}
+ }
+
+ });
+
+ MML.chars.Augment({
+ toPreviewHTML: function (span) {
+ var text = this.toString().replace(/[\u2061-\u2064]/g,"");
+ this.PHTMLhandleText(span,text);
+ }
+ });
+ MML.entity.Augment({
+ toPreviewHTML: function (span) {
+ var text = this.toString().replace(/[\u2061-\u2064]/g,"");
+ this.PHTMLhandleText(span,text);
+ }
+ });
+
+ MML.math.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span);
+ if (this.Get("display") === "block") {span.className += " MJXp-display"}
+ return span;
+ }
+ });
+
+ MML.mo.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span);
+ this.PHTMLadjustAccent(span);
+ var values = this.getValues("lspace","rspace","scriptlevel","displaystyle","largeop");
+ if (values.scriptlevel === 0) {
+ this.PHTML.l = PHTML.length2em(values.lspace);
+ this.PHTML.r = PHTML.length2em(values.rspace);
+ span.style.marginLeft = PHTML.Em(this.PHTML.l);
+ span.style.marginRight = PHTML.Em(this.PHTML.r);
+ } else {
+ this.PHTML.l = .15;
+ this.PHTML.r = .1;
+ }
+ if (values.displaystyle && values.largeop) {
+ var box = HTML.Element("span",{className:"MJXp-largeop"});
+ box.appendChild(span.firstChild); span.appendChild(box);
+ this.PHTML.h *= 1.2; this.PHTML.d *= 1.2;
+ if (this.data.join("") === "\u222B") box.className += " MJXp-int";
+ }
+ // ### FIXME: Handle embellished op spacing
+ // ### FIXME: Remap minus signs
+ return span;
+ },
+ PHTMLadjustAccent: function (span) {
+ var parent = this.CoreParent();
+ if (parent && parent.isa(MML.munderover) &&
+ this.CoreText(parent.data[parent.base]).length === 1) {
+ var over = parent.data[parent.over], under = parent.data[parent.under];
+ var c = this.data.join(""), C;
+ if (over && this === over.CoreMO() && parent.Get("accent")) {C = PHTML.REMAPACCENT[c]}
+ else if (under && this === under.CoreMO() && parent.Get("accentunder")) {C = PHTML.REMAPACCENTUNDER[c]}
+ if (C) c = span.innerHTML = C;
+ if (c.match(/[\u02C6-\u02DC\u00A8]/)) {this.PHTML.acc = -.52}
+ else if (c === "\u2192") {this.PHTML.acc = -.15; this.PHTML.vec = true}
+ }
+ },
+ PHTMLcanStretch: function (direction,H,D) {
+ if (!this.Get("stretchy")) {return false}
+ var c = this.data.join("");
+ if (c.length > 1) {return false}
+ c = PHTML.DELIMITERS[c];
+ var stretch = (c && c.dir === direction.substr(0,1));
+ if (stretch) {
+ stretch = (this.PHTML.h !== H || this.PHTML.d !== D ||
+ (this.Get("minsize",true) || this.Get("maxsize",true)));
+ }
+ return stretch;
+ },
+ PHTMLstretchV: function (h,d) {
+ var span = this.PHTMLspanElement(), bbox = this.PHTML; //bbox.w = .4; // ## adjust width
+ var values = this.getValues("symmetric","maxsize","minsize");
+ if (values.symmetric) {H = 2*Math.max(h-.25,d+.25)} else {H = h + d}
+ values.maxsize = PHTML.length2em(values.maxsize,bbox.h+bbox.d);
+ values.minsize = PHTML.length2em(values.minsize,bbox.h+bbox.d);
+ H = Math.max(values.minsize,Math.min(values.maxsize,H));
+ var scale = H/(bbox.h+bbox.d-.3); // ### adjusted for extra tall bbox
+ var box = HTML.Element("span",{style:{"font-size":PHTML.Em(scale)}});
+ if (scale > 1.25) {
+ var sX = Math.ceil(1.25/scale * 10);
+ box.className = "MJXp-right MJXp-scale"+sX;
+ box.style.marginLeft = PHTML.Em(bbox.w*(sX/10-1)+.07);
+ bbox.w *= scale*sX/10;
+ }
+ box.appendChild(span.firstChild); span.appendChild(box);
+ if (values.symmetric) span.style.verticalAlign = PHTML.Em(.25*(1-scale));
+ }
+ });
+
+ MML.mspace.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span);
+ var values = this.getValues("height","depth","width");
+ var w = PHTML.length2em(values.width),
+ h = PHTML.length2em(values.height),
+ d = PHTML.length2em(values.depth);
+ var bbox = this.PHTML;
+ bbox.w = w; bbox.h = h; bbox.d = d;
+ if (w < 0) {
+ // ### FIXME: lastIsInt hack
+ if (!PHTML.lastIsInt) span.style.marginLeft = PHTML.Em(w);
+ w = 0;
+ }
+ span.style.width = PHTML.Em(w);
+ span.style.height = PHTML.Em(h+d);
+ if (d) span.style.verticalAlign = PHTML.Em(-d);
+ return span;
+ }
+ });
+
+ MML.mpadded.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span,{
+ childSpans:true, className:"MJXp-box", forceChild:true
+ });
+ var child = span.firstChild;
+ var values = this.getValues("width","height","depth","lspace","voffset");
+ var dimen = this.PHTMLdimen(values.lspace);
+ var T = 0, B = 0, L = dimen.len, R = -dimen.len, V = 0;
+ if (values.width !== "") {
+ dimen = this.PHTMLdimen(values.width,"w",0);
+ if (dimen.pm) {R += dimen.len} else {span.style.width = PHTML.Em(dimen.len)}
+ }
+ if (values.height !== "") {
+ dimen = this.PHTMLdimen(values.height,"h",0);
+ if (!dimen.pm) T += -this.PHTMLbboxFor(0).h;
+ T += dimen.len;
+ }
+ if (values.depth !== "") {
+ dimen = this.PHTMLdimen(values.depth,"d",0);
+ if (!dimen.pm) {B += -this.PHTMLbboxFor(0).d; V += -dimen.len}
+ B += dimen.len;
+ }
+ if (values.voffset !== "") {
+ dimen = this.PHTMLdimen(values.voffset);
+ T -= dimen.len; B += dimen.len;
+ V += dimen.len;
+ }
+ if (T) child.style.marginTop = PHTML.Em(T);
+ if (B) child.style.marginBottom = PHTML.Em(B);
+ if (L) child.style.marginLeft = PHTML.Em(L);
+ if (R) child.style.marginRight = PHTML.Em(R);
+ if (V) span.style.verticalAlign = PHTML.Em(V);
+ return span;
+ },
+ PHTMLdimen: function (length,d,m) {
+ if (m == null) {m = -BIGDIMEN}
+ length = String(length);
+ var match = length.match(/width|height|depth/);
+ var size = (match ? this.PHTML[match[0].charAt(0)] : (d ? this.PHTML[d] : 0));
+ return {len: PHTML.length2em(length,size)||0, pm: !!length.match(/^[-+]/)};
+ }
+ });
+
+ MML.munderover.Augment({
+ toPreviewHTML: function (span) {
+ var values = this.getValues("displaystyle","accent","accentunder","align");
+ var base = this.data[this.base];
+ if (!values.displaystyle && base != null &&
+ (base.movablelimits || base.CoreMO().Get("movablelimits"))) {
+ span = MML.msubsup.prototype.toPreviewHTML.call(this,span);
+ //
+ // Change class to msubsup for CSS rules.
+ // ### FIXME: should this be handled via adding another class instead?
+ //
+ span.className = span.className.replace(/munderover/,"msubsup");
+ return span;
+ }
+ span = this.PHTMLdefaultSpan(span,{childSpans:true, className:"", noBBox:true});
+ var obox = this.PHTMLbboxFor(this.over),
+ ubox = this.PHTMLbboxFor(this.under),
+ bbox = this.PHTMLbboxFor(this.base),
+ BBOX = this.PHTML, acc = obox.acc;
+ if (this.data[this.over]) {
+ if (span.lastChild.firstChild){
+ span.lastChild.firstChild.style.marginLeft = obox.l =
+ span.lastChild.firstChild.style.marginRight = obox.r = 0;
+ }
+ var over = HTML.Element("span",{},[["span",{className:"MJXp-over"}]]);
+ over.firstChild.appendChild(span.lastChild);
+ if (span.childNodes.length > (this.data[this.under] ? 1 : 0))
+ over.firstChild.appendChild(span.firstChild);
+ this.data[this.over].PHTMLhandleScriptlevel(over.firstChild.firstChild);
+ if (acc != null) {
+ if (obox.vec) {
+ over.firstChild.firstChild.firstChild.style.fontSize = "60%";
+ obox.h *= .6; obox.d *= .6; obox.w *= .6;
+ }
+ acc = acc - obox.d + .1; if (bbox.t != null) {acc += bbox.t - bbox.h}
+ over.firstChild.firstChild.style.marginBottom = PHTML.Em(acc);
+ }
+ if (span.firstChild) {span.insertBefore(over,span.firstChild)}
+ else {span.appendChild(over)}
+ }
+ if (this.data[this.under]) {
+ if (span.lastChild.firstChild) {
+ span.lastChild.firstChild.style.marginLeft = ubox.l =
+ span.lastChild.firstChild.marginRight = ubox.r = 0;
+ }
+ this.data[this.under].PHTMLhandleScriptlevel(span.lastChild);
+ }
+ BBOX.w = Math.max(.8*obox.w,.8*ubox.w,bbox.w);
+ BBOX.h = .8*(obox.h+obox.d+(acc||0)) + bbox.h;
+ BBOX.d = bbox.d + .8*(ubox.h+ubox.d);
+ return span;
+ }
+ });
+
+ MML.msubsup.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span,{noBBox:true});
+ if (!this.data[this.base]) {
+ if (span.firstChild) {span.insertBefore(HTML.Element("span"),span.firstChild)}
+ else {span.appendChild(HTML.Element("span"))}
+ }
+ var base = this.data[this.base], sub = this.data[this.sub], sup = this.data[this.sup];
+ if (!base) base = {bbox: {h:.8, d:.2}};
+ span.firstChild.style.marginRight = ".05em";
+ var h = Math.max(.4,base.PHTML.h-.4),
+ d = Math.max(.2,base.PHTML.d+.1);
+ var bbox = this.PHTML;
+ if (sup && sub) {
+ var box = HTML.Element("span",{className:"MJXp-script-box", style:{
+ height: PHTML.Em(h+sup.PHTML.h*.8 + d+sub.PHTML.d*.8),
+ "vertical-align": PHTML.Em(-d-sub.PHTML.d*.8)
+ }},[
+ ["span",{},[["span",{},[["span",{
+ style:{"margin-bottom":PHTML.Em(-(sup.PHTML.d-.05))}
+ }]]]]],
+ ["span",{},[["span",{},[["span",{
+ style:{"margin-top":PHTML.Em(-(sup.PHTML.h-.05))}
+ }]]]]]
+ ]);
+ sub.PHTMLhandleScriptlevel(box.firstChild);
+ sup.PHTMLhandleScriptlevel(box.lastChild);
+ box.firstChild.firstChild.firstChild.appendChild(span.lastChild);
+ box.lastChild.firstChild.firstChild.appendChild(span.lastChild);
+ span.appendChild(box);
+ bbox.h = Math.max(base.PHTML.h,sup.PHTML.h*.8+h);
+ bbox.d = Math.max(base.PHTML.d,sub.PHTML.d*.8+d);
+ bbox.w = base.PHTML.w + Math.max(sup.PHTML.w,sub.PHTML.w) + .07;
+ } else if (sup) {
+ span.lastChild.style.verticalAlign = PHTML.Em(h);
+ sup.PHTMLhandleScriptlevel(span.lastChild);
+ bbox.h = Math.max(base.PHTML.h,sup.PHTML.h*.8+h);
+ bbox.d = Math.max(base.PHTML.d,sup.PHTML.d*.8-h);
+ bbox.w = base.PHTML.w + sup.PHTML.w + .07;
+ } else if (sub) {
+ span.lastChild.style.verticalAlign = PHTML.Em(-d);
+ sub.PHTMLhandleScriptlevel(span.lastChild);
+ bbox.h = Math.max(base.PHTML.h,sub.PHTML.h*.8-d);
+ bbox.d = Math.max(base.PHTML.d,sub.PHTML.d*.8+d);
+ bbox.w = base.PHTML.w + sub.PHTML.w + .07;
+ }
+ return span;
+ }
+ });
+
+ MML.mfrac.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span,{
+ childSpans:true, className:"MJXp-box", forceChild:true, noBBox:true
+ });
+ var values = this.getValues("linethickness","displaystyle");
+ if (!values.displaystyle) {
+ if (this.data[0]) this.data[0].PHTMLhandleScriptlevel(span.firstChild);
+ if (this.data[1]) this.data[1].PHTMLhandleScriptlevel(span.lastChild);
+ }
+ var denom = HTML.Element("span",{className:"MJXp-box"},[
+ ["span",{className:"MJXp-denom"},[ // inline-table
+ ["span",{},[["span",{className:"MJXp-rule",style:{height:"1em"}}]]],
+ ["span"] // spans are table-row
+ ]]
+ ]);
+ denom.firstChild.lastChild.appendChild(span.lastChild);
+ span.appendChild(denom);
+ var nbox = this.PHTMLbboxFor(0), dbox = this.PHTMLbboxFor(1), bbox = this.PHTML;
+ bbox.w = Math.max(nbox.w,dbox.w) * .8;
+ bbox.h = nbox.h+nbox.d + .1 + .25;
+ bbox.d = dbox.h+dbox.d - .25;
+ bbox.l = bbox.r = .125;
+ values.linethickness = Math.max(0,PHTML.length2em(values.linethickness||"0",0));
+ if (values.linethickness) {
+ var rule = denom.firstChild.firstChild.firstChild;
+ var t = PHTML.Em(values.linethickness);
+ rule.style.borderTop = "none";
+ rule.style.borderBottom = (values.linethickness < .15 ? "1px" : t)+" solid";
+ rule.style.margin = t+" 0";
+ t = values.linethickness;
+ denom.style.marginTop = PHTML.Em(3*t-1.2);
+ span.style.verticalAlign = PHTML.Em(1.5*t + .1);
+ bbox.h += 1.5*t - .1; bbox.d += 1.5*t;
+ } else {
+ denom.style.marginTop = "-.7em";
+ }
+ return span;
+ }
+ });
+
+ MML.msqrt.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span,{
+ childSpans:true, className:"MJXp-box", forceChild:true, noBBox:true
+ });
+ this.PHTMLlayoutRoot(span,span.firstChild);
+ return span;
+ },
+ PHTMLlayoutRoot: function (span,base) {
+ var bbox = this.PHTMLbboxFor(0);
+ var scale = Math.ceil((bbox.h+bbox.d+.14)*100), t = PHTML.Em(14/scale);
+ var surd = HTML.Element("span",{className:"MJXp-surd"},[
+ ["span",{style:{"font-size":scale+"%","margin-top":t}},["\u221A"]]
+ ]);
+ var root = HTML.Element("span",{className:"MJXp-root"},[
+ ["span",{className:"MJXp-rule",style:{"border-top":".08em solid"}}]
+ ]);
+ var W = (1.2/2.2)*scale/100; // width-of-surd = (height/H-to-W-ratio)
+ if (scale > 150) {
+ var sX = Math.ceil(150/scale * 10);
+ surd.firstChild.className = "MJXp-right MJXp-scale"+sX;
+ surd.firstChild.style.marginLeft = PHTML.Em(W*(sX/10-1)/scale*100);
+ W = W*sX/10;
+ root.firstChild.style.borderTopWidth = PHTML.Em(.08/Math.sqrt(sX/10));
+ }
+ root.appendChild(base);
+ span.appendChild(surd);
+ span.appendChild(root);
+ this.PHTML.h = bbox.h + .18; this.PHTML.d = bbox.d;
+ this.PHTML.w = bbox.w + W;
+ return span;
+ }
+ });
+
+ MML.mroot.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span,{
+ childSpans:true, className:"MJXp-box", forceChild:true, noBBox:true
+ });
+ var rbox = this.PHTMLbboxFor(1), root = span.removeChild(span.lastChild);
+ var sqrt = this.PHTMLlayoutRoot(HTML.Element("span"),span.firstChild);
+ root.className = "MJXp-script"; // ### FIXME: should be scriptscript
+ var scale = parseInt(sqrt.firstChild.firstChild.style.fontSize);
+ var v = .55*(scale/120) + rbox.d*.8, r = -.6*(scale/120);
+ if (scale > 150) {r *= .95*Math.ceil(150/scale*10)/10}
+ root.style.marginRight = PHTML.Em(r); root.style.verticalAlign = PHTML.Em(v);
+ if (-r > rbox.w*.8) root.style.marginLeft = PHTML.Em(-r-rbox.w*.8); // ### depends on rbox.w
+ span.appendChild(root); span.appendChild(sqrt);
+ this.PHTML.w += Math.max(0,rbox.w*.8+r);
+ this.PHTML.h = Math.max(this.PHTML.h,rbox.h*.8+v);
+ return span;
+ },
+ PHTMLlayoutRoot: MML.msqrt.prototype.PHTMLlayoutRoot
+ });
+
+ MML.mfenced.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLcreateSpan(span);
+ this.PHTMLhandleStyle(span);
+ this.PHTMLhandleColor(span);
+ //
+ // Make row of open, data, sep, ... data, close
+ //
+ this.addFakeNodes();
+ this.PHTMLaddChild(span,"open",{});
+ for (var i = 0, m = this.data.length; i < m; i++) {
+ this.PHTMLaddChild(span,"sep"+i,{});
+ this.PHTMLaddChild(span,i,{});
+ }
+ this.PHTMLaddChild(span,"close",{});
+ //
+ // Check for streching the elements
+ //
+ var H = this.PHTML.h, D = this.PHTML.d;
+ this.PHTMLstretchChild("open",H,D);
+ for (i = 0, m = this.data.length; i < m; i++) {
+ this.PHTMLstretchChild("sep"+i,H,D);
+ this.PHTMLstretchChild(i,H,D);
+ }
+ this.PHTMLstretchChild("close",H,D);
+ return span;
+ }
+ });
+
+ MML.mrow.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span);
+ var H = this.PHTML.h, D = this.PHTML.d;
+ for (var i = 0, m = this.data.length; i < m; i++) this.PHTMLstretchChild(i,H,D);
+ return span;
+ }
+ });
+
+ MML.mstyle.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span);
+ this.PHTMLhandleScriptlevel(span);
+ return span;
+ }
+ });
+
+ MML.TeXAtom.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span);
+ // ### FIXME: handle TeX class?
+ span.className = "MJXp-mrow";
+ return span;
+ }
+ });
+
+ MML.mtable.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLdefaultSpan(span,{noBBox:true});
+ var values = this.getValues("columnalign","rowalign","columnspacing","rowspacing",
+ "columnwidth","equalcolumns","equalrows",
+ "columnlines","rowlines","frame","framespacing",
+ "align","width");
+ var SPLIT = MathJax.Hub.SplitList, i, m, j, n;
+ var CSPACE = SPLIT(values.columnspacing),
+ RSPACE = SPLIT(values.rowspacing),
+ CALIGN = SPLIT(values.columnalign),
+ RALIGN = SPLIT(values.rowalign);
+ for (i = 0, m = CSPACE.length; i < m; i++) {CSPACE[i] = PHTML.length2em(CSPACE[i])}
+ for (i = 0, m = RSPACE.length; i < m; i++) {RSPACE[i] = PHTML.length2em(RSPACE[i])}
+
+ var table = HTML.Element("span");
+ while (span.firstChild) table.appendChild(span.firstChild);
+ span.appendChild(table);
+ var H = 0, W = 0;
+ for (i = 0, m = this.data.length; i < m; i++) {
+ var row = this.data[i];
+ if (row) {
+ var rspace = PHTML.arrayEntry(RSPACE,i-1), ralign = PHTML.arrayEntry(RALIGN,i);
+ var rbox = row.PHTML, rspan = row.PHTMLspanElement();
+ rspan.style.verticalAlign = ralign;
+ var k = (row.type === "mlabeledtr" ? 1 : 0);
+ for (j = 0, n = row.data.length; j < n-k; j++) {
+ var cell = row.data[j+k];
+ if (cell) {
+ var cspace = PHTML.arrayEntry(CSPACE,j-1), calign = PHTML.arrayEntry(CALIGN,j);
+ var cspan = cell.PHTMLspanElement();
+ if (j) {rbox.w += cspace; cspan.style.paddingLeft = PHTML.Em(cspace)}
+ if (i) cspan.style.paddingTop = PHTML.Em(rspace);
+ cspan.style.textAlign = calign;
+ }
+ }
+ H += rbox.h + rbox.d; if (i) {H += rspace}
+ if (rbox.w > W) W = rbox.w;
+ }
+ }
+ var bbox = this.PHTML;
+ bbox.w = W; bbox.h = H/2 + .25; bbox.d = H/2 - .25;
+ bbox.l = bbox.r = .125;
+ return span;
+ }
+ });
+ MML.mlabeledtr.Augment({
+ PHTMLdefaultSpan: function (span,options) {
+ if (!options) options = {};
+ span = this.PHTMLcreateSpan(span);
+ this.PHTMLhandleStyle(span);
+ this.PHTMLhandleColor(span);
+ if (this.isToken) this.PHTMLhandleToken(span);
+ // skip label for now
+ for (var i = 1, m = this.data.length; i < m; i++) this.PHTMLaddChild(span,i,options);
+ return span;
+ }
+ });
+
+ MML.semantics.Augment({
+ toPreviewHTML: function (span) {
+ span = this.PHTMLcreateSpan(span);
+ if (this.data[0]) {
+ this.data[0].toPreviewHTML(span);
+ MathJax.Hub.Insert(this.data[0].PHTML||{},this.PHTML);
+ }
+ return span;
+ }
+ });
+ MML.annotation.Augment({toPreviewHTML: function(span) {}});
+ MML["annotation-xml"].Augment({toPreviewHTML: function(span) {}});
+
+ //
+ // Loading isn't complete until the element jax is modified,
+ // but can't call loadComplete within the callback for "mml Jax Ready"
+ // (it would call PreviewHTML's Require routine, asking for the mml jax again)
+ // so wait until after the mml jax has finished processing.
+ //
+ // We also need to wait for the onload handler to run, since the loadComplete
+ // will call Config and Startup, which need to modify the body.
+ //
+ MathJax.Hub.Register.StartupHook("onLoad",function () {
+ setTimeout(MathJax.Callback(["loadComplete",PHTML,"jax.js"]),0);
+ });
+ });
+
+ MathJax.Hub.Register.StartupHook("End Cookie", function () {
+ if (HUB.config.menuSettings.zoom !== "None")
+ {AJAX.Require("[MathJax]/extensions/MathZoom.js")}
+ });
+
+})(MathJax.Ajax,MathJax.Hub,MathJax.HTML,MathJax.OutputJax.PreviewHTML);
+// @license-end