aboutsummaryrefslogtreecommitdiff
path: root/js/mathjax/jax/output/CommonHTML
diff options
context:
space:
mode:
authorYuchen Pei <me@ypei.me>2021-06-24 17:50:34 +1000
committerYuchen Pei <me@ypei.me>2021-06-24 17:50:34 +1000
commit11011d7c373c655830053b155eeaf632c2658ac7 (patch)
tree2e7ae85b013041fef7e733ddb4c74dd197c17f56 /js/mathjax/jax/output/CommonHTML
parent4f5ad1a70089365c5b6949d06386930433e09193 (diff)
Updated.
- added mathjax (freed) - added rss.py - updated publish.el - etc.
Diffstat (limited to 'js/mathjax/jax/output/CommonHTML')
-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
23 files changed, 9160 insertions, 0 deletions
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