TomaHost/Chamilo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

upgrade

Browse Source
This commit is contained in:
Xes
2025-08-14 22:44:47 +02:00
parent 8ce45119b6
commit 791cb748ab
39112 changed files with 975901 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1813
web/assets/MathJax/unpacked/jax/element/mml/jax.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

122
web/assets/MathJax/unpacked/jax/element/mml/optable/Arrows.js vendored Normal file
View File

@@ -0,0 +1,122 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Arrows.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u219A': MO.RELACCENT, // leftwards arrow with stroke
'\u219B': MO.RELACCENT, // rightwards arrow with stroke
'\u219C': MO.WIDEREL, // leftwards wave arrow
'\u219D': MO.WIDEREL, // rightwards wave arrow
'\u219E': MO.WIDEREL, // leftwards two headed arrow
'\u219F': MO.WIDEREL, // upwards two headed arrow
'\u21A0': MO.WIDEREL, // rightwards two headed arrow
'\u21A1': MO.RELSTRETCH, // downwards two headed arrow
'\u21A2': MO.WIDEREL, // leftwards arrow with tail
'\u21A3': MO.WIDEREL, // rightwards arrow with tail
'\u21A4': MO.WIDEREL, // leftwards arrow from bar
'\u21A5': MO.RELSTRETCH, // upwards arrow from bar
'\u21A7': MO.RELSTRETCH, // downwards arrow from bar
'\u21A8': MO.RELSTRETCH, // up down arrow with base
'\u21AB': MO.WIDEREL, // leftwards arrow with loop
'\u21AC': MO.WIDEREL, // rightwards arrow with loop
'\u21AD': MO.WIDEREL, // left right wave arrow
'\u21AE': MO.RELACCENT, // left right arrow with stroke
'\u21AF': MO.RELSTRETCH, // downwards zigzag arrow
'\u21B0': MO.RELSTRETCH, // upwards arrow with tip leftwards
'\u21B1': MO.RELSTRETCH, // upwards arrow with tip rightwards
'\u21B2': MO.RELSTRETCH, // downwards arrow with tip leftwards
'\u21B3': MO.RELSTRETCH, // downwards arrow with tip rightwards
'\u21B4': MO.RELSTRETCH, // rightwards arrow with corner downwards
'\u21B5': MO.RELSTRETCH, // downwards arrow with corner leftwards
'\u21B6': MO.RELACCENT, // anticlockwise top semicircle arrow
'\u21B7': MO.RELACCENT, // clockwise top semicircle arrow
'\u21B8': MO.REL, // north west arrow to long bar
'\u21B9': MO.WIDEREL, // leftwards arrow to bar over rightwards arrow to bar
'\u21BA': MO.REL, // anticlockwise open circle arrow
'\u21BB': MO.REL, // clockwise open circle arrow
'\u21BE': MO.RELSTRETCH, // upwards harpoon with barb rightwards
'\u21BF': MO.RELSTRETCH, // upwards harpoon with barb leftwards
'\u21C2': MO.RELSTRETCH, // downwards harpoon with barb rightwards
'\u21C3': MO.RELSTRETCH, // downwards harpoon with barb leftwards
'\u21C4': MO.WIDEREL, // rightwards arrow over leftwards arrow
'\u21C5': MO.RELSTRETCH, // upwards arrow leftwards of downwards arrow
'\u21C6': MO.WIDEREL, // leftwards arrow over rightwards arrow
'\u21C7': MO.WIDEREL, // leftwards paired arrows
'\u21C8': MO.RELSTRETCH, // upwards paired arrows
'\u21C9': MO.WIDEREL, // rightwards paired arrows
'\u21CA': MO.RELSTRETCH, // downwards paired arrows
'\u21CB': MO.WIDEREL, // leftwards harpoon over rightwards harpoon
'\u21CD': MO.RELACCENT, // leftwards double arrow with stroke
'\u21CE': MO.RELACCENT, // left right double arrow with stroke
'\u21CF': MO.RELACCENT, // rightwards double arrow with stroke
'\u21D6': MO.RELSTRETCH, // north west double arrow
'\u21D7': MO.RELSTRETCH, // north east double arrow
'\u21D8': MO.RELSTRETCH, // south east double arrow
'\u21D9': MO.RELSTRETCH, // south west double arrow
'\u21DA': MO.WIDEREL, // leftwards triple arrow
'\u21DB': MO.WIDEREL, // rightwards triple arrow
'\u21DC': MO.WIDEREL, // leftwards squiggle arrow
'\u21DD': MO.WIDEREL, // rightwards squiggle arrow
'\u21DE': MO.REL, // upwards arrow with double stroke
'\u21DF': MO.REL, // downwards arrow with double stroke
'\u21E0': MO.WIDEREL, // leftwards dashed arrow
'\u21E1': MO.RELSTRETCH, // upwards dashed arrow
'\u21E2': MO.WIDEREL, // rightwards dashed arrow
'\u21E3': MO.RELSTRETCH, // downwards dashed arrow
'\u21E4': MO.WIDEREL, // leftwards arrow to bar
'\u21E5': MO.WIDEREL, // rightwards arrow to bar
'\u21E6': MO.WIDEREL, // leftwards white arrow
'\u21E7': MO.RELSTRETCH, // upwards white arrow
'\u21E8': MO.WIDEREL, // rightwards white arrow
'\u21E9': MO.RELSTRETCH, // downwards white arrow
'\u21EA': MO.RELSTRETCH, // upwards white arrow from bar
'\u21EB': MO.RELSTRETCH, // upwards white arrow on pedestal
'\u21EC': MO.RELSTRETCH, // upwards white arrow on pedestal with horizontal bar
'\u21ED': MO.RELSTRETCH, // upwards white arrow on pedestal with vertical bar
'\u21EE': MO.RELSTRETCH, // upwards white double arrow
'\u21EF': MO.RELSTRETCH, // upwards white double arrow on pedestal
'\u21F0': MO.WIDEREL, // rightwards white arrow from wall
'\u21F1': MO.REL, // north west arrow to corner
'\u21F2': MO.REL, // south east arrow to corner
'\u21F3': MO.RELSTRETCH, // up down white arrow
'\u21F4': MO.RELACCENT, // right arrow with small circle
'\u21F5': MO.RELSTRETCH, // downwards arrow leftwards of upwards arrow
'\u21F6': MO.WIDEREL, // three rightwards arrows
'\u21F7': MO.RELACCENT, // leftwards arrow with vertical stroke
'\u21F8': MO.RELACCENT, // rightwards arrow with vertical stroke
'\u21F9': MO.RELACCENT, // left right arrow with vertical stroke
'\u21FA': MO.RELACCENT, // leftwards arrow with double vertical stroke
'\u21FB': MO.RELACCENT, // rightwards arrow with double vertical stroke
'\u21FC': MO.RELACCENT, // left right arrow with double vertical stroke
'\u21FD': MO.WIDEREL, // leftwards open-headed arrow
'\u21FE': MO.WIDEREL, // rightwards open-headed arrow
'\u21FF': MO.WIDEREL // left right open-headed arrow
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/Arrows.js");
})(MathJax.ElementJax.mml);

65
web/assets/MathJax/unpacked/jax/element/mml/optable/BasicLatin.js vendored Normal file
View File

@@ -0,0 +1,65 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
'|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
},
postfix: {
'!!': [1,0,TEXCLASS.BIN], // multiple character operator: !!
'\'': MO.ACCENT, // apostrophe
'++': [0,0,TEXCLASS.BIN], // multiple character operator: ++
'--': [0,0,TEXCLASS.BIN], // multiple character operator: --
'..': [0,0,TEXCLASS.BIN], // multiple character operator: ..
'...': MO.ORD, // multiple character operator: ...
'||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
'|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
},
infix: {
'!=': MO.BIN4, // multiple character operator: !=
'&&': MO.BIN4, // multiple character operator: &&
'**': [1,1,TEXCLASS.BIN], // multiple character operator: **
'*=': MO.BIN4, // multiple character operator: *=
'+=': MO.BIN4, // multiple character operator: +=
'-=': MO.BIN4, // multiple character operator: -=
'->': MO.BIN5, // multiple character operator: ->
'//': [1,1,TEXCLASS.BIN], // multiple character operator: //
'/=': MO.BIN4, // multiple character operator: /=
':=': MO.BIN4, // multiple character operator: :=
'<=': MO.BIN5, // multiple character operator: <=
'<>': [1,1,TEXCLASS.BIN], // multiple character operator: <>
'==': MO.BIN4, // multiple character operator: ==
'>=': MO.BIN5, // multiple character operator: >=
'@': MO.ORD11, // commercial at
'||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
'|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js");
})(MathJax.ElementJax.mml);

35
web/assets/MathJax/unpacked/jax/element/mml/optable/CombDiacritMarks.js vendored Normal file
View File

@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u0311': MO.ACCENT // combining inverted breve
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiacritMarks.js");
})(MathJax.ElementJax.mml);

36
web/assets/MathJax/unpacked/jax/element/mml/optable/CombDiactForSymbols.js vendored Normal file
View File

@@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/CombDiactForSymbols.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u20DB': MO.ACCENT, // combining three dots above
'\u20DC': MO.ACCENT // combining four dots above
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiactForSymbols.js");
})(MathJax.ElementJax.mml);

38
web/assets/MathJax/unpacked/jax/element/mml/optable/Dingbats.js vendored Normal file
View File

@@ -0,0 +1,38 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Dingbats.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2772': MO.OPEN // light left tortoise shell bracket ornament
},
postfix: {
'\u2773': MO.CLOSE // light right tortoise shell bracket ornament
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/Dingbats.js");
})(MathJax.ElementJax.mml);

42
web/assets/MathJax/unpacked/jax/element/mml/optable/GeneralPunctuation.js vendored Normal file
View File

@@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
'\u2018': [0,0,TEXCLASS.OPEN,{fence: true}], // left single quotation mark
'\u201C': [0,0,TEXCLASS.OPEN,{fence: true}] // left double quotation mark
},
postfix: {
'\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
'\u2019': [0,0,TEXCLASS.CLOSE,{fence: true}], // right single quotation mark
'\u201D': [0,0,TEXCLASS.CLOSE,{fence: true}] // right double quotation mark
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/GeneralPunctuation.js");
})(MathJax.ElementJax.mml);

66
web/assets/MathJax/unpacked/jax/element/mml/optable/GeometricShapes.js vendored Normal file
View File

@@ -0,0 +1,66 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u25A0': MO.BIN3, // black square
'\u25A1': MO.BIN3, // white square
'\u25AA': MO.BIN3, // black small square
'\u25AB': MO.BIN3, // white small square
'\u25AD': MO.BIN3, // white rectangle
'\u25AE': MO.BIN3, // black vertical rectangle
'\u25AF': MO.BIN3, // white vertical rectangle
'\u25B0': MO.BIN3, // black parallelogram
'\u25B1': MO.BIN3, // white parallelogram
'\u25B2': MO.BIN4, // black up-pointing triangle
'\u25B4': MO.BIN4, // black up-pointing small triangle
'\u25B6': MO.BIN4, // black right-pointing triangle
'\u25B7': MO.BIN4, // white right-pointing triangle
'\u25B8': MO.BIN4, // black right-pointing small triangle
'\u25BC': MO.BIN4, // black down-pointing triangle
'\u25BE': MO.BIN4, // black down-pointing small triangle
'\u25C0': MO.BIN4, // black left-pointing triangle
'\u25C1': MO.BIN4, // white left-pointing triangle
'\u25C2': MO.BIN4, // black left-pointing small triangle
'\u25C4': MO.BIN4, // black left-pointing pointer
'\u25C5': MO.BIN4, // white left-pointing pointer
'\u25C6': MO.BIN4, // black diamond
'\u25C7': MO.BIN4, // white diamond
'\u25C8': MO.BIN4, // white diamond containing black small diamond
'\u25C9': MO.BIN4, // fisheye
'\u25CC': MO.BIN4, // dotted circle
'\u25CD': MO.BIN4, // circle with vertical fill
'\u25CE': MO.BIN4, // bullseye
'\u25CF': MO.BIN4, // black circle
'\u25D6': MO.BIN4, // left half black circle
'\u25D7': MO.BIN4, // right half black circle
'\u25E6': MO.BIN4 // white bullet
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/GeometricShapes.js");
})(MathJax.ElementJax.mml);

35
web/assets/MathJax/unpacked/jax/element/mml/optable/GreekAndCoptic.js vendored Normal file
View File

@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u03F6': MO.REL // greek reversed lunate epsilon symbol
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/GreekAndCoptic.js");
})(MathJax.ElementJax.mml);

37
web/assets/MathJax/unpacked/jax/element/mml/optable/Latin1Supplement.js vendored Normal file
View File

@@ -0,0 +1,37 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Latin1Supplement.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u00B0': MO.ORD, // degree sign
'\u00B4': MO.ACCENT, // acute accent
'\u00B8': MO.ACCENT // cedilla
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/Latin1Supplement.js");
})(MathJax.ElementJax.mml);

36
web/assets/MathJax/unpacked/jax/element/mml/optable/LetterlikeSymbols.js vendored Normal file
View File

@@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2145': MO.ORD21, // double-struck italic capital d
'\u2146': [2,0,TEXCLASS.ORD] // double-struck italic small d
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/LetterlikeSymbols.js");
})(MathJax.ElementJax.mml);

228
web/assets/MathJax/unpacked/jax/element/mml/optable/MathOperators.js vendored Normal file
View File

@@ -0,0 +1,228 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MathOperators.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2204': MO.ORD21, // there does not exist
'\u221B': MO.ORD11, // cube root
'\u221C': MO.ORD11, // fourth root
'\u2221': MO.ORD, // measured angle
'\u2222': MO.ORD, // spherical angle
'\u222C': MO.INTEGRAL, // double integral
'\u222D': MO.INTEGRAL, // triple integral
'\u222F': MO.INTEGRAL, // surface integral
'\u2230': MO.INTEGRAL, // volume integral
'\u2231': MO.INTEGRAL, // clockwise integral
'\u2232': MO.INTEGRAL, // clockwise contour integral
'\u2233': MO.INTEGRAL // anticlockwise contour integral
},
infix: {
'\u2201': [1,2,TEXCLASS.ORD], // complement
'\u2206': MO.BIN3, // increment
'\u220A': MO.REL, // small element of
'\u220C': MO.REL, // does not contain as member
'\u220D': MO.REL, // small contains as member
'\u220E': MO.BIN3, // end of proof
'\u2214': MO.BIN4, // dot plus
'\u221F': MO.REL, // right angle
'\u2224': MO.REL, // does not divide
'\u2226': MO.REL, // not parallel to
'\u2234': MO.REL, // therefore
'\u2235': MO.REL, // because
'\u2236': MO.REL, // ratio
'\u2237': MO.REL, // proportion
'\u2238': MO.BIN4, // dot minus
'\u2239': MO.REL, // excess
'\u223A': MO.BIN4, // geometric proportion
'\u223B': MO.REL, // homothetic
'\u223D': MO.REL, // reversed tilde
'\u223D\u0331': MO.BIN3, // reversed tilde with underline
'\u223E': MO.REL, // inverted lazy s
'\u223F': MO.BIN3, // sine wave
'\u2241': MO.REL, // not tilde
'\u2242': MO.REL, // minus tilde
'\u2242\u0338': MO.REL, // minus tilde with slash
'\u2244': MO.REL, // not asymptotically equal to
'\u2246': MO.REL, // approximately but not actually equal to
'\u2247': MO.REL, // neither approximately nor actually equal to
'\u2249': MO.REL, // not almost equal to
'\u224A': MO.REL, // almost equal or equal to
'\u224B': MO.REL, // triple tilde
'\u224C': MO.REL, // all equal to
'\u224E': MO.REL, // geometrically equivalent to
'\u224E\u0338': MO.REL, // geometrically equivalent to with slash
'\u224F': MO.REL, // difference between
'\u224F\u0338': MO.REL, // difference between with slash
'\u2251': MO.REL, // geometrically equal to
'\u2252': MO.REL, // approximately equal to or the image of
'\u2253': MO.REL, // image of or approximately equal to
'\u2254': MO.REL, // colon equals
'\u2255': MO.REL, // equals colon
'\u2256': MO.REL, // ring in equal to
'\u2257': MO.REL, // ring equal to
'\u2258': MO.REL, // corresponds to
'\u2259': MO.REL, // estimates
'\u225A': MO.REL, // equiangular to
'\u225C': MO.REL, // delta equal to
'\u225D': MO.REL, // equal to by definition
'\u225E': MO.REL, // measured by
'\u225F': MO.REL, // questioned equal to
'\u2262': MO.REL, // not identical to
'\u2263': MO.REL, // strictly equivalent to
'\u2266': MO.REL, // less-than over equal to
'\u2266\u0338': MO.REL, // less-than over equal to with slash
'\u2267': MO.REL, // greater-than over equal to
'\u2268': MO.REL, // less-than but not equal to
'\u2269': MO.REL, // greater-than but not equal to
'\u226A\u0338': MO.REL, // much less than with slash
'\u226B\u0338': MO.REL, // much greater than with slash
'\u226C': MO.REL, // between
'\u226D': MO.REL, // not equivalent to
'\u226E': MO.REL, // not less-than
'\u226F': MO.REL, // not greater-than
'\u2270': MO.REL, // neither less-than nor equal to
'\u2271': MO.REL, // neither greater-than nor equal to
'\u2272': MO.REL, // less-than or equivalent to
'\u2273': MO.REL, // greater-than or equivalent to
'\u2274': MO.REL, // neither less-than nor equivalent to
'\u2275': MO.REL, // neither greater-than nor equivalent to
'\u2276': MO.REL, // less-than or greater-than
'\u2277': MO.REL, // greater-than or less-than
'\u2278': MO.REL, // neither less-than nor greater-than
'\u2279': MO.REL, // neither greater-than nor less-than
'\u227C': MO.REL, // precedes or equal to
'\u227D': MO.REL, // succeeds or equal to
'\u227E': MO.REL, // precedes or equivalent to
'\u227F': MO.REL, // succeeds or equivalent to
'\u227F\u0338': MO.REL, // succeeds or equivalent to with slash
'\u2280': MO.REL, // does not precede
'\u2281': MO.REL, // does not succeed
'\u2282\u20D2': MO.REL, // subset of with vertical line
'\u2283\u20D2': MO.REL, // superset of with vertical line
'\u2284': MO.REL, // not a subset of
'\u2285': MO.REL, // not a superset of
'\u2288': MO.REL, // neither a subset of nor equal to
'\u2289': MO.REL, // neither a superset of nor equal to
'\u228A': MO.REL, // subset of with not equal to
'\u228B': MO.REL, // superset of with not equal to
'\u228C': MO.BIN4, // multiset
'\u228D': MO.BIN4, // multiset multiplication
'\u228F': MO.REL, // square image of
'\u228F\u0338': MO.REL, // square image of with slash
'\u2290': MO.REL, // square original of
'\u2290\u0338': MO.REL, // square original of with slash
'\u229A': MO.BIN4, // circled ring operator
'\u229B': MO.BIN4, // circled asterisk operator
'\u229C': MO.BIN4, // circled equals
'\u229D': MO.BIN4, // circled dash
'\u229E': MO.BIN4, // squared plus
'\u229F': MO.BIN4, // squared minus
'\u22A0': MO.BIN4, // squared times
'\u22A1': MO.BIN4, // squared dot operator
'\u22A6': MO.REL, // assertion
'\u22A7': MO.REL, // models
'\u22A9': MO.REL, // forces
'\u22AA': MO.REL, // triple vertical bar right turnstile
'\u22AB': MO.REL, // double vertical bar double right turnstile
'\u22AC': MO.REL, // does not prove
'\u22AD': MO.REL, // not true
'\u22AE': MO.REL, // does not force
'\u22AF': MO.REL, // negated double vertical bar double right turnstile
'\u22B0': MO.REL, // precedes under relation
'\u22B1': MO.REL, // succeeds under relation
'\u22B2': MO.REL, // normal subgroup of
'\u22B3': MO.REL, // contains as normal subgroup
'\u22B4': MO.REL, // normal subgroup of or equal to
'\u22B5': MO.REL, // contains as normal subgroup or equal to
'\u22B6': MO.REL, // original of
'\u22B7': MO.REL, // image of
'\u22B8': MO.REL, // multimap
'\u22B9': MO.REL, // hermitian conjugate matrix
'\u22BA': MO.BIN4, // intercalate
'\u22BB': MO.BIN4, // xor
'\u22BC': MO.BIN4, // nand
'\u22BD': MO.BIN4, // nor
'\u22BE': MO.BIN3, // right angle with arc
'\u22BF': MO.BIN3, // right triangle
'\u22C7': MO.BIN4, // division times
'\u22C9': MO.BIN4, // left normal factor semidirect product
'\u22CA': MO.BIN4, // right normal factor semidirect product
'\u22CB': MO.BIN4, // left semidirect product
'\u22CC': MO.BIN4, // right semidirect product
'\u22CD': MO.REL, // reversed tilde equals
'\u22CE': MO.BIN4, // curly logical or
'\u22CF': MO.BIN4, // curly logical and
'\u22D0': MO.REL, // double subset
'\u22D1': MO.REL, // double superset
'\u22D2': MO.BIN4, // double intersection
'\u22D3': MO.BIN4, // double union
'\u22D4': MO.REL, // pitchfork
'\u22D5': MO.REL, // equal and parallel to
'\u22D6': MO.REL, // less-than with dot
'\u22D7': MO.REL, // greater-than with dot
'\u22D8': MO.REL, // very much less-than
'\u22D9': MO.REL, // very much greater-than
'\u22DA': MO.REL, // less-than equal to or greater-than
'\u22DB': MO.REL, // greater-than equal to or less-than
'\u22DC': MO.REL, // equal to or less-than
'\u22DD': MO.REL, // equal to or greater-than
'\u22DE': MO.REL, // equal to or precedes
'\u22DF': MO.REL, // equal to or succeeds
'\u22E0': MO.REL, // does not precede or equal
'\u22E1': MO.REL, // does not succeed or equal
'\u22E2': MO.REL, // not square image of or equal to
'\u22E3': MO.REL, // not square original of or equal to
'\u22E4': MO.REL, // square image of or not equal to
'\u22E5': MO.REL, // square original of or not equal to
'\u22E6': MO.REL, // less-than but not equivalent to
'\u22E7': MO.REL, // greater-than but not equivalent to
'\u22E8': MO.REL, // precedes but not equivalent to
'\u22E9': MO.REL, // succeeds but not equivalent to
'\u22EA': MO.REL, // not normal subgroup of
'\u22EB': MO.REL, // does not contain as normal subgroup
'\u22EC': MO.REL, // not normal subgroup of or equal to
'\u22ED': MO.REL, // does not contain as normal subgroup or equal
'\u22F0': MO.REL, // up right diagonal ellipsis
'\u22F2': MO.REL, // element of with long horizontal stroke
'\u22F3': MO.REL, // element of with vertical bar at end of horizontal stroke
'\u22F4': MO.REL, // small element of with vertical bar at end of horizontal stroke
'\u22F5': MO.REL, // element of with dot above
'\u22F6': MO.REL, // element of with overbar
'\u22F7': MO.REL, // small element of with overbar
'\u22F8': MO.REL, // element of with underbar
'\u22F9': MO.REL, // element of with two horizontal strokes
'\u22FA': MO.REL, // contains with long horizontal stroke
'\u22FB': MO.REL, // contains with vertical bar at end of horizontal stroke
'\u22FC': MO.REL, // small contains with vertical bar at end of horizontal stroke
'\u22FD': MO.REL, // contains with overbar
'\u22FE': MO.REL, // small contains with overbar
'\u22FF': MO.REL // z notation bag membership
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MathOperators.js");
})(MathJax.ElementJax.mml);

42
web/assets/MathJax/unpacked/jax/element/mml/optable/MiscMathSymbolsA.js vendored Normal file
View File

@@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u27E6': MO.OPEN, // mathematical left white square bracket
'\u27EA': MO.OPEN, // mathematical left double angle bracket
'\u27EC': MO.OPEN // mathematical left white tortoise shell bracket
},
postfix: {
'\u27E7': MO.CLOSE, // mathematical right white square bracket
'\u27EB': MO.CLOSE, // mathematical right double angle bracket
'\u27ED': MO.CLOSE // mathematical right white tortoise shell bracket
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsA.js");
})(MathJax.ElementJax.mml);

168
web/assets/MathJax/unpacked/jax/element/mml/optable/MiscMathSymbolsB.js vendored Normal file
View File

@@ -0,0 +1,168 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsB.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2980': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // triple vertical bar delimiter
'\u2983': MO.OPEN, // left white curly bracket
'\u2985': MO.OPEN, // left white parenthesis
'\u2987': MO.OPEN, // z notation left image bracket
'\u2989': MO.OPEN, // z notation left binding bracket
'\u298B': MO.OPEN, // left square bracket with underbar
'\u298D': MO.OPEN, // left square bracket with tick in top corner
'\u298F': MO.OPEN, // left square bracket with tick in bottom corner
'\u2991': MO.OPEN, // left angle bracket with dot
'\u2993': MO.OPEN, // left arc less-than bracket
'\u2995': MO.OPEN, // double left arc greater-than bracket
'\u2997': MO.OPEN, // left black tortoise shell bracket
'\u29FC': MO.OPEN // left-pointing curved angle bracket
},
postfix: {
'\u2980': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // triple vertical bar delimiter
'\u2984': MO.CLOSE, // right white curly bracket
'\u2986': MO.CLOSE, // right white parenthesis
'\u2988': MO.CLOSE, // z notation right image bracket
'\u298A': MO.CLOSE, // z notation right binding bracket
'\u298C': MO.CLOSE, // right square bracket with underbar
'\u298E': MO.CLOSE, // right square bracket with tick in bottom corner
'\u2990': MO.CLOSE, // right square bracket with tick in top corner
'\u2992': MO.CLOSE, // right angle bracket with dot
'\u2994': MO.CLOSE, // right arc greater-than bracket
'\u2996': MO.CLOSE, // double right arc less-than bracket
'\u2998': MO.CLOSE, // right black tortoise shell bracket
'\u29FD': MO.CLOSE // right-pointing curved angle bracket
},
infix: {
'\u2981': MO.BIN3, // z notation spot
'\u2982': MO.BIN3, // z notation type colon
'\u2999': MO.BIN3, // dotted fence
'\u299A': MO.BIN3, // vertical zigzag line
'\u299B': MO.BIN3, // measured angle opening left
'\u299C': MO.BIN3, // right angle variant with square
'\u299D': MO.BIN3, // measured right angle with dot
'\u299E': MO.BIN3, // angle with s inside
'\u299F': MO.BIN3, // acute angle
'\u29A0': MO.BIN3, // spherical angle opening left
'\u29A1': MO.BIN3, // spherical angle opening up
'\u29A2': MO.BIN3, // turned angle
'\u29A3': MO.BIN3, // reversed angle
'\u29A4': MO.BIN3, // angle with underbar
'\u29A5': MO.BIN3, // reversed angle with underbar
'\u29A6': MO.BIN3, // oblique angle opening up
'\u29A7': MO.BIN3, // oblique angle opening down
'\u29A8': MO.BIN3, // measured angle with open arm ending in arrow pointing up and right
'\u29A9': MO.BIN3, // measured angle with open arm ending in arrow pointing up and left
'\u29AA': MO.BIN3, // measured angle with open arm ending in arrow pointing down and right
'\u29AB': MO.BIN3, // measured angle with open arm ending in arrow pointing down and left
'\u29AC': MO.BIN3, // measured angle with open arm ending in arrow pointing right and up
'\u29AD': MO.BIN3, // measured angle with open arm ending in arrow pointing left and up
'\u29AE': MO.BIN3, // measured angle with open arm ending in arrow pointing right and down
'\u29AF': MO.BIN3, // measured angle with open arm ending in arrow pointing left and down
'\u29B0': MO.BIN3, // reversed empty set
'\u29B1': MO.BIN3, // empty set with overbar
'\u29B2': MO.BIN3, // empty set with small circle above
'\u29B3': MO.BIN3, // empty set with right arrow above
'\u29B4': MO.BIN3, // empty set with left arrow above
'\u29B5': MO.BIN3, // circle with horizontal bar
'\u29B6': MO.BIN4, // circled vertical bar
'\u29B7': MO.BIN4, // circled parallel
'\u29B8': MO.BIN4, // circled reverse solidus
'\u29B9': MO.BIN4, // circled perpendicular
'\u29BA': MO.BIN4, // circle divided by horizontal bar and top half divided by vertical bar
'\u29BB': MO.BIN4, // circle with superimposed x
'\u29BC': MO.BIN4, // circled anticlockwise-rotated division sign
'\u29BD': MO.BIN4, // up arrow through circle
'\u29BE': MO.BIN4, // circled white bullet
'\u29BF': MO.BIN4, // circled bullet
'\u29C0': MO.REL, // circled less-than
'\u29C1': MO.REL, // circled greater-than
'\u29C2': MO.BIN3, // circle with small circle to the right
'\u29C3': MO.BIN3, // circle with two horizontal strokes to the right
'\u29C4': MO.BIN4, // squared rising diagonal slash
'\u29C5': MO.BIN4, // squared falling diagonal slash
'\u29C6': MO.BIN4, // squared asterisk
'\u29C7': MO.BIN4, // squared small circle
'\u29C8': MO.BIN4, // squared square
'\u29C9': MO.BIN3, // two joined squares
'\u29CA': MO.BIN3, // triangle with dot above
'\u29CB': MO.BIN3, // triangle with underbar
'\u29CC': MO.BIN3, // s in triangle
'\u29CD': MO.BIN3, // triangle with serifs at bottom
'\u29CE': MO.REL, // right triangle above left triangle
'\u29CF': MO.REL, // left triangle beside vertical bar
'\u29CF\u0338': MO.REL, // left triangle beside vertical bar with slash
'\u29D0': MO.REL, // vertical bar beside right triangle
'\u29D0\u0338': MO.REL, // vertical bar beside right triangle with slash
'\u29D1': MO.REL, // bowtie with left half black
'\u29D2': MO.REL, // bowtie with right half black
'\u29D3': MO.REL, // black bowtie
'\u29D4': MO.REL, // times with left half black
'\u29D5': MO.REL, // times with right half black
'\u29D6': MO.BIN4, // white hourglass
'\u29D7': MO.BIN4, // black hourglass
'\u29D8': MO.BIN3, // left wiggly fence
'\u29D9': MO.BIN3, // right wiggly fence
'\u29DB': MO.BIN3, // right double wiggly fence
'\u29DC': MO.BIN3, // incomplete infinity
'\u29DD': MO.BIN3, // tie over infinity
'\u29DE': MO.REL, // infinity negated with vertical bar
'\u29DF': MO.BIN3, // double-ended multimap
'\u29E0': MO.BIN3, // square with contoured outline
'\u29E1': MO.REL, // increases as
'\u29E2': MO.BIN4, // shuffle product
'\u29E3': MO.REL, // equals sign and slanted parallel
'\u29E4': MO.REL, // equals sign and slanted parallel with tilde above
'\u29E5': MO.REL, // identical to and slanted parallel
'\u29E6': MO.REL, // gleich stark
'\u29E7': MO.BIN3, // thermodynamic
'\u29E8': MO.BIN3, // down-pointing triangle with left half black
'\u29E9': MO.BIN3, // down-pointing triangle with right half black
'\u29EA': MO.BIN3, // black diamond with down arrow
'\u29EB': MO.BIN3, // black lozenge
'\u29EC': MO.BIN3, // white circle with down arrow
'\u29ED': MO.BIN3, // black circle with down arrow
'\u29EE': MO.BIN3, // error-barred white square
'\u29EF': MO.BIN3, // error-barred black square
'\u29F0': MO.BIN3, // error-barred white diamond
'\u29F1': MO.BIN3, // error-barred black diamond
'\u29F2': MO.BIN3, // error-barred white circle
'\u29F3': MO.BIN3, // error-barred black circle
'\u29F4': MO.REL, // rule-delayed
'\u29F5': MO.BIN4, // reverse solidus operator
'\u29F6': MO.BIN4, // solidus with overbar
'\u29F7': MO.BIN4, // reverse solidus with horizontal stroke
'\u29F8': MO.BIN3, // big solidus
'\u29F9': MO.BIN3, // big reverse solidus
'\u29FA': MO.BIN3, // double plus
'\u29FB': MO.BIN3, // triple plus
'\u29FE': MO.BIN4, // tiny
'\u29FF': MO.BIN4 // miny
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsB.js");
})(MathJax.ElementJax.mml);

36
web/assets/MathJax/unpacked/jax/element/mml/optable/MiscSymbolsAndArrows.js vendored Normal file
View File

@@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscSymbolsAndArrows.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u2B45': MO.RELSTRETCH, // leftwards quadruple arrow
'\u2B46': MO.RELSTRETCH // rightwards quadruple arrow
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscSymbolsAndArrows.js");
})(MathJax.ElementJax.mml);

40
web/assets/MathJax/unpacked/jax/element/mml/optable/MiscTechnical.js vendored Normal file
View File

@@ -0,0 +1,40 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u23B4': MO.WIDEACCENT, // top square bracket
'\u23B5': MO.WIDEACCENT, // bottom square bracket
'\u23DC': MO.WIDEACCENT, // top parenthesis
'\u23DD': MO.WIDEACCENT, // bottom parenthesis
'\u23E0': MO.WIDEACCENT, // top tortoise shell bracket
'\u23E1': MO.WIDEACCENT // bottom tortoise shell bracket
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscTechnical.js");
})(MathJax.ElementJax.mml);

38
web/assets/MathJax/unpacked/jax/element/mml/optable/SpacingModLetters.js vendored Normal file
View File

@@ -0,0 +1,38 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u02CD': MO.WIDEACCENT, // modifier letter low macron
'\u02DA': MO.ACCENT, // ring above
'\u02DD': MO.ACCENT, // double acute accent
'\u02F7': MO.WIDEACCENT // modifier letter low tilde
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SpacingModLetters.js");
})(MathJax.ElementJax.mml);

289
web/assets/MathJax/unpacked/jax/element/mml/optable/SuppMathOperators.js vendored Normal file
View File

@@ -0,0 +1,289 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SuppMathOperators.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2A03': MO.OP, // n-ary union operator with dot
'\u2A05': MO.OP, // n-ary square intersection operator
'\u2A07': MO.OP, // two logical and operator
'\u2A08': MO.OP, // two logical or operator
'\u2A09': MO.OP, // n-ary times operator
'\u2A0A': MO.OP, // modulo two sum
'\u2A0B': MO.INTEGRAL2, // summation with integral
'\u2A0C': MO.INTEGRAL, // quadruple integral operator
'\u2A0D': MO.INTEGRAL2, // finite part integral
'\u2A0E': MO.INTEGRAL2, // integral with double stroke
'\u2A0F': MO.INTEGRAL2, // integral average with slash
'\u2A10': MO.OP, // circulation function
'\u2A11': MO.OP, // anticlockwise integration
'\u2A12': MO.OP, // line integration with rectangular path around pole
'\u2A13': MO.OP, // line integration with semicircular path around pole
'\u2A14': MO.OP, // line integration not including the pole
'\u2A15': MO.INTEGRAL2, // integral around a point operator
'\u2A16': MO.INTEGRAL2, // quaternion integral operator
'\u2A17': MO.INTEGRAL2, // integral with leftwards arrow with hook
'\u2A18': MO.INTEGRAL2, // integral with times sign
'\u2A19': MO.INTEGRAL2, // integral with intersection
'\u2A1A': MO.INTEGRAL2, // integral with union
'\u2A1B': MO.INTEGRAL2, // integral with overbar
'\u2A1C': MO.INTEGRAL2, // integral with underbar
'\u2AFC': MO.OP, // large triple vertical bar operator
'\u2AFF': MO.OP // n-ary white vertical bar
},
infix: {
'\u2A1D': MO.BIN3, // join
'\u2A1E': MO.BIN3, // large left triangle operator
'\u2A1F': MO.BIN3, // z notation schema composition
'\u2A20': MO.BIN3, // z notation schema piping
'\u2A21': MO.BIN3, // z notation schema projection
'\u2A22': MO.BIN4, // plus sign with small circle above
'\u2A23': MO.BIN4, // plus sign with circumflex accent above
'\u2A24': MO.BIN4, // plus sign with tilde above
'\u2A25': MO.BIN4, // plus sign with dot below
'\u2A26': MO.BIN4, // plus sign with tilde below
'\u2A27': MO.BIN4, // plus sign with subscript two
'\u2A28': MO.BIN4, // plus sign with black triangle
'\u2A29': MO.BIN4, // minus sign with comma above
'\u2A2A': MO.BIN4, // minus sign with dot below
'\u2A2B': MO.BIN4, // minus sign with falling dots
'\u2A2C': MO.BIN4, // minus sign with rising dots
'\u2A2D': MO.BIN4, // plus sign in left half circle
'\u2A2E': MO.BIN4, // plus sign in right half circle
'\u2A30': MO.BIN4, // multiplication sign with dot above
'\u2A31': MO.BIN4, // multiplication sign with underbar
'\u2A32': MO.BIN4, // semidirect product with bottom closed
'\u2A33': MO.BIN4, // smash product
'\u2A34': MO.BIN4, // multiplication sign in left half circle
'\u2A35': MO.BIN4, // multiplication sign in right half circle
'\u2A36': MO.BIN4, // circled multiplication sign with circumflex accent
'\u2A37': MO.BIN4, // multiplication sign in double circle
'\u2A38': MO.BIN4, // circled division sign
'\u2A39': MO.BIN4, // plus sign in triangle
'\u2A3A': MO.BIN4, // minus sign in triangle
'\u2A3B': MO.BIN4, // multiplication sign in triangle
'\u2A3C': MO.BIN4, // interior product
'\u2A3D': MO.BIN4, // righthand interior product
'\u2A3E': MO.BIN4, // z notation relational composition
'\u2A40': MO.BIN4, // intersection with dot
'\u2A41': MO.BIN4, // union with minus sign
'\u2A42': MO.BIN4, // union with overbar
'\u2A43': MO.BIN4, // intersection with overbar
'\u2A44': MO.BIN4, // intersection with logical and
'\u2A45': MO.BIN4, // union with logical or
'\u2A46': MO.BIN4, // union above intersection
'\u2A47': MO.BIN4, // intersection above union
'\u2A48': MO.BIN4, // union above bar above intersection
'\u2A49': MO.BIN4, // intersection above bar above union
'\u2A4A': MO.BIN4, // union beside and joined with union
'\u2A4B': MO.BIN4, // intersection beside and joined with intersection
'\u2A4C': MO.BIN4, // closed union with serifs
'\u2A4D': MO.BIN4, // closed intersection with serifs
'\u2A4E': MO.BIN4, // double square intersection
'\u2A4F': MO.BIN4, // double square union
'\u2A50': MO.BIN4, // closed union with serifs and smash product
'\u2A51': MO.BIN4, // logical and with dot above
'\u2A52': MO.BIN4, // logical or with dot above
'\u2A53': MO.BIN4, // double logical and
'\u2A54': MO.BIN4, // double logical or
'\u2A55': MO.BIN4, // two intersecting logical and
'\u2A56': MO.BIN4, // two intersecting logical or
'\u2A57': MO.BIN4, // sloping large or
'\u2A58': MO.BIN4, // sloping large and
'\u2A59': MO.REL, // logical or overlapping logical and
'\u2A5A': MO.BIN4, // logical and with middle stem
'\u2A5B': MO.BIN4, // logical or with middle stem
'\u2A5C': MO.BIN4, // logical and with horizontal dash
'\u2A5D': MO.BIN4, // logical or with horizontal dash
'\u2A5E': MO.BIN4, // logical and with double overbar
'\u2A5F': MO.BIN4, // logical and with underbar
'\u2A60': MO.BIN4, // logical and with double underbar
'\u2A61': MO.BIN4, // small vee with underbar
'\u2A62': MO.BIN4, // logical or with double overbar
'\u2A63': MO.BIN4, // logical or with double underbar
'\u2A64': MO.BIN4, // z notation domain antirestriction
'\u2A65': MO.BIN4, // z notation range antirestriction
'\u2A66': MO.REL, // equals sign with dot below
'\u2A67': MO.REL, // identical with dot above
'\u2A68': MO.REL, // triple horizontal bar with double vertical stroke
'\u2A69': MO.REL, // triple horizontal bar with triple vertical stroke
'\u2A6A': MO.REL, // tilde operator with dot above
'\u2A6B': MO.REL, // tilde operator with rising dots
'\u2A6C': MO.REL, // similar minus similar
'\u2A6D': MO.REL, // congruent with dot above
'\u2A6E': MO.REL, // equals with asterisk
'\u2A6F': MO.REL, // almost equal to with circumflex accent
'\u2A70': MO.REL, // approximately equal or equal to
'\u2A71': MO.BIN4, // equals sign above plus sign
'\u2A72': MO.BIN4, // plus sign above equals sign
'\u2A73': MO.REL, // equals sign above tilde operator
'\u2A74': MO.REL, // double colon equal
'\u2A75': MO.REL, // two consecutive equals signs
'\u2A76': MO.REL, // three consecutive equals signs
'\u2A77': MO.REL, // equals sign with two dots above and two dots below
'\u2A78': MO.REL, // equivalent with four dots above
'\u2A79': MO.REL, // less-than with circle inside
'\u2A7A': MO.REL, // greater-than with circle inside
'\u2A7B': MO.REL, // less-than with question mark above
'\u2A7C': MO.REL, // greater-than with question mark above
'\u2A7D': MO.REL, // less-than or slanted equal to
'\u2A7D\u0338': MO.REL, // less-than or slanted equal to with slash
'\u2A7E': MO.REL, // greater-than or slanted equal to
'\u2A7E\u0338': MO.REL, // greater-than or slanted equal to with slash
'\u2A7F': MO.REL, // less-than or slanted equal to with dot inside
'\u2A80': MO.REL, // greater-than or slanted equal to with dot inside
'\u2A81': MO.REL, // less-than or slanted equal to with dot above
'\u2A82': MO.REL, // greater-than or slanted equal to with dot above
'\u2A83': MO.REL, // less-than or slanted equal to with dot above right
'\u2A84': MO.REL, // greater-than or slanted equal to with dot above left
'\u2A85': MO.REL, // less-than or approximate
'\u2A86': MO.REL, // greater-than or approximate
'\u2A87': MO.REL, // less-than and single-line not equal to
'\u2A88': MO.REL, // greater-than and single-line not equal to
'\u2A89': MO.REL, // less-than and not approximate
'\u2A8A': MO.REL, // greater-than and not approximate
'\u2A8B': MO.REL, // less-than above double-line equal above greater-than
'\u2A8C': MO.REL, // greater-than above double-line equal above less-than
'\u2A8D': MO.REL, // less-than above similar or equal
'\u2A8E': MO.REL, // greater-than above similar or equal
'\u2A8F': MO.REL, // less-than above similar above greater-than
'\u2A90': MO.REL, // greater-than above similar above less-than
'\u2A91': MO.REL, // less-than above greater-than above double-line equal
'\u2A92': MO.REL, // greater-than above less-than above double-line equal
'\u2A93': MO.REL, // less-than above slanted equal above greater-than above slanted equal
'\u2A94': MO.REL, // greater-than above slanted equal above less-than above slanted equal
'\u2A95': MO.REL, // slanted equal to or less-than
'\u2A96': MO.REL, // slanted equal to or greater-than
'\u2A97': MO.REL, // slanted equal to or less-than with dot inside
'\u2A98': MO.REL, // slanted equal to or greater-than with dot inside
'\u2A99': MO.REL, // double-line equal to or less-than
'\u2A9A': MO.REL, // double-line equal to or greater-than
'\u2A9B': MO.REL, // double-line slanted equal to or less-than
'\u2A9C': MO.REL, // double-line slanted equal to or greater-than
'\u2A9D': MO.REL, // similar or less-than
'\u2A9E': MO.REL, // similar or greater-than
'\u2A9F': MO.REL, // similar above less-than above equals sign
'\u2AA0': MO.REL, // similar above greater-than above equals sign
'\u2AA1': MO.REL, // double nested less-than
'\u2AA1\u0338': MO.REL, // double nested less-than with slash
'\u2AA2': MO.REL, // double nested greater-than
'\u2AA2\u0338': MO.REL, // double nested greater-than with slash
'\u2AA3': MO.REL, // double nested less-than with underbar
'\u2AA4': MO.REL, // greater-than overlapping less-than
'\u2AA5': MO.REL, // greater-than beside less-than
'\u2AA6': MO.REL, // less-than closed by curve
'\u2AA7': MO.REL, // greater-than closed by curve
'\u2AA8': MO.REL, // less-than closed by curve above slanted equal
'\u2AA9': MO.REL, // greater-than closed by curve above slanted equal
'\u2AAA': MO.REL, // smaller than
'\u2AAB': MO.REL, // larger than
'\u2AAC': MO.REL, // smaller than or equal to
'\u2AAD': MO.REL, // larger than or equal to
'\u2AAE': MO.REL, // equals sign with bumpy above
'\u2AAF\u0338': MO.REL, // precedes above single-line equals sign with slash
'\u2AB0\u0338': MO.REL, // succeeds above single-line equals sign with slash
'\u2AB1': MO.REL, // precedes above single-line not equal to
'\u2AB2': MO.REL, // succeeds above single-line not equal to
'\u2AB3': MO.REL, // precedes above equals sign
'\u2AB4': MO.REL, // succeeds above equals sign
'\u2AB5': MO.REL, // precedes above not equal to
'\u2AB6': MO.REL, // succeeds above not equal to
'\u2AB7': MO.REL, // precedes above almost equal to
'\u2AB8': MO.REL, // succeeds above almost equal to
'\u2AB9': MO.REL, // precedes above not almost equal to
'\u2ABA': MO.REL, // succeeds above not almost equal to
'\u2ABB': MO.REL, // double precedes
'\u2ABC': MO.REL, // double succeeds
'\u2ABD': MO.REL, // subset with dot
'\u2ABE': MO.REL, // superset with dot
'\u2ABF': MO.REL, // subset with plus sign below
'\u2AC0': MO.REL, // superset with plus sign below
'\u2AC1': MO.REL, // subset with multiplication sign below
'\u2AC2': MO.REL, // superset with multiplication sign below
'\u2AC3': MO.REL, // subset of or equal to with dot above
'\u2AC4': MO.REL, // superset of or equal to with dot above
'\u2AC5': MO.REL, // subset of above equals sign
'\u2AC6': MO.REL, // superset of above equals sign
'\u2AC7': MO.REL, // subset of above tilde operator
'\u2AC8': MO.REL, // superset of above tilde operator
'\u2AC9': MO.REL, // subset of above almost equal to
'\u2ACA': MO.REL, // superset of above almost equal to
'\u2ACB': MO.REL, // subset of above not equal to
'\u2ACC': MO.REL, // superset of above not equal to
'\u2ACD': MO.REL, // square left open box operator
'\u2ACE': MO.REL, // square right open box operator
'\u2ACF': MO.REL, // closed subset
'\u2AD0': MO.REL, // closed superset
'\u2AD1': MO.REL, // closed subset or equal to
'\u2AD2': MO.REL, // closed superset or equal to
'\u2AD3': MO.REL, // subset above superset
'\u2AD4': MO.REL, // superset above subset
'\u2AD5': MO.REL, // subset above subset
'\u2AD6': MO.REL, // superset above superset
'\u2AD7': MO.REL, // superset beside subset
'\u2AD8': MO.REL, // superset beside and joined by dash with subset
'\u2AD9': MO.REL, // element of opening downwards
'\u2ADA': MO.REL, // pitchfork with tee top
'\u2ADB': MO.REL, // transversal intersection
'\u2ADC': MO.REL, // forking
'\u2ADD': MO.REL, // nonforking
'\u2ADE': MO.REL, // short left tack
'\u2ADF': MO.REL, // short down tack
'\u2AE0': MO.REL, // short up tack
'\u2AE1': MO.REL, // perpendicular with s
'\u2AE2': MO.REL, // vertical bar triple right turnstile
'\u2AE3': MO.REL, // double vertical bar left turnstile
'\u2AE4': MO.REL, // vertical bar double left turnstile
'\u2AE5': MO.REL, // double vertical bar double left turnstile
'\u2AE6': MO.REL, // long dash from left member of double vertical
'\u2AE7': MO.REL, // short down tack with overbar
'\u2AE8': MO.REL, // short up tack with underbar
'\u2AE9': MO.REL, // short up tack above short down tack
'\u2AEA': MO.REL, // double down tack
'\u2AEB': MO.REL, // double up tack
'\u2AEC': MO.REL, // double stroke not sign
'\u2AED': MO.REL, // reversed double stroke not sign
'\u2AEE': MO.REL, // does not divide with reversed negation slash
'\u2AEF': MO.REL, // vertical line with circle above
'\u2AF0': MO.REL, // vertical line with circle below
'\u2AF1': MO.REL, // down tack with circle below
'\u2AF2': MO.REL, // parallel with horizontal stroke
'\u2AF3': MO.REL, // parallel with tilde operator
'\u2AF4': MO.BIN4, // triple vertical bar binary relation
'\u2AF5': MO.BIN4, // triple vertical bar with horizontal stroke
'\u2AF6': MO.BIN4, // triple colon operator
'\u2AF7': MO.REL, // triple nested less-than
'\u2AF8': MO.REL, // triple nested greater-than
'\u2AF9': MO.REL, // double-line slanted less-than or equal to
'\u2AFA': MO.REL, // double-line slanted greater-than or equal to
'\u2AFB': MO.BIN4, // triple solidus binary relation
'\u2AFD': MO.BIN4, // double solidus operator
'\u2AFE': MO.BIN3 // white vertical bar
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SuppMathOperators.js");
})(MathJax.ElementJax.mml);

40
web/assets/MathJax/unpacked/jax/element/mml/optable/SupplementalArrowsA.js vendored Normal file
View File

@@ -0,0 +1,40 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsA.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u27F0': MO.RELSTRETCH, // upwards quadruple arrow
'\u27F1': MO.RELSTRETCH, // downwards quadruple arrow
'\u27FB': MO.WIDEREL, // long leftwards arrow from bar
'\u27FD': MO.WIDEREL, // long leftwards double arrow from bar
'\u27FE': MO.WIDEREL, // long rightwards double arrow from bar
'\u27FF': MO.WIDEREL // long rightwards squiggle arrow
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsA.js");
})(MathJax.ElementJax.mml);

162
web/assets/MathJax/unpacked/jax/element/mml/optable/SupplementalArrowsB.js vendored Normal file
View File

@@ -0,0 +1,162 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u2900': MO.RELACCENT, // rightwards two-headed arrow with vertical stroke
'\u2901': MO.RELACCENT, // rightwards two-headed arrow with double vertical stroke
'\u2902': MO.RELACCENT, // leftwards double arrow with vertical stroke
'\u2903': MO.RELACCENT, // rightwards double arrow with vertical stroke
'\u2904': MO.RELACCENT, // left right double arrow with vertical stroke
'\u2905': MO.RELACCENT, // rightwards two-headed arrow from bar
'\u2906': MO.RELACCENT, // leftwards double arrow from bar
'\u2907': MO.RELACCENT, // rightwards double arrow from bar
'\u2908': MO.REL, // downwards arrow with horizontal stroke
'\u2909': MO.REL, // upwards arrow with horizontal stroke
'\u290A': MO.RELSTRETCH, // upwards triple arrow
'\u290B': MO.RELSTRETCH, // downwards triple arrow
'\u290C': MO.WIDEREL, // leftwards double dash arrow
'\u290D': MO.WIDEREL, // rightwards double dash arrow
'\u290E': MO.WIDEREL, // leftwards triple dash arrow
'\u290F': MO.WIDEREL, // rightwards triple dash arrow
'\u2910': MO.WIDEREL, // rightwards two-headed triple dash arrow
'\u2911': MO.RELACCENT, // rightwards arrow with dotted stem
'\u2912': MO.RELSTRETCH, // upwards arrow to bar
'\u2913': MO.RELSTRETCH, // downwards arrow to bar
'\u2914': MO.RELACCENT, // rightwards arrow with tail with vertical stroke
'\u2915': MO.RELACCENT, // rightwards arrow with tail with double vertical stroke
'\u2916': MO.RELACCENT, // rightwards two-headed arrow with tail
'\u2917': MO.RELACCENT, // rightwards two-headed arrow with tail with vertical stroke
'\u2918': MO.RELACCENT, // rightwards two-headed arrow with tail with double vertical stroke
'\u2919': MO.RELACCENT, // leftwards arrow-tail
'\u291A': MO.RELACCENT, // rightwards arrow-tail
'\u291B': MO.RELACCENT, // leftwards double arrow-tail
'\u291C': MO.RELACCENT, // rightwards double arrow-tail
'\u291D': MO.RELACCENT, // leftwards arrow to black diamond
'\u291E': MO.RELACCENT, // rightwards arrow to black diamond
'\u291F': MO.RELACCENT, // leftwards arrow from bar to black diamond
'\u2920': MO.RELACCENT, // rightwards arrow from bar to black diamond
'\u2921': MO.RELSTRETCH, // north west and south east arrow
'\u2922': MO.RELSTRETCH, // north east and south west arrow
'\u2923': MO.REL, // north west arrow with hook
'\u2924': MO.REL, // north east arrow with hook
'\u2925': MO.REL, // south east arrow with hook
'\u2926': MO.REL, // south west arrow with hook
'\u2927': MO.REL, // north west arrow and north east arrow
'\u2928': MO.REL, // north east arrow and south east arrow
'\u2929': MO.REL, // south east arrow and south west arrow
'\u292A': MO.REL, // south west arrow and north west arrow
'\u292B': MO.REL, // rising diagonal crossing falling diagonal
'\u292C': MO.REL, // falling diagonal crossing rising diagonal
'\u292D': MO.REL, // south east arrow crossing north east arrow
'\u292E': MO.REL, // north east arrow crossing south east arrow
'\u292F': MO.REL, // falling diagonal crossing north east arrow
'\u2930': MO.REL, // rising diagonal crossing south east arrow
'\u2931': MO.REL, // north east arrow crossing north west arrow
'\u2932': MO.REL, // north west arrow crossing north east arrow
'\u2933': MO.RELACCENT, // wave arrow pointing directly right
'\u2934': MO.REL, // arrow pointing rightwards then curving upwards
'\u2935': MO.REL, // arrow pointing rightwards then curving downwards
'\u2936': MO.REL, // arrow pointing downwards then curving leftwards
'\u2937': MO.REL, // arrow pointing downwards then curving rightwards
'\u2938': MO.REL, // right-side arc clockwise arrow
'\u2939': MO.REL, // left-side arc anticlockwise arrow
'\u293A': MO.RELACCENT, // top arc anticlockwise arrow
'\u293B': MO.RELACCENT, // bottom arc anticlockwise arrow
'\u293C': MO.RELACCENT, // top arc clockwise arrow with minus
'\u293D': MO.RELACCENT, // top arc anticlockwise arrow with plus
'\u293E': MO.REL, // lower right semicircular clockwise arrow
'\u293F': MO.REL, // lower left semicircular anticlockwise arrow
'\u2940': MO.REL, // anticlockwise closed circle arrow
'\u2941': MO.REL, // clockwise closed circle arrow
'\u2942': MO.RELACCENT, // rightwards arrow above short leftwards arrow
'\u2943': MO.RELACCENT, // leftwards arrow above short rightwards arrow
'\u2944': MO.RELACCENT, // short rightwards arrow above leftwards arrow
'\u2945': MO.RELACCENT, // rightwards arrow with plus below
'\u2946': MO.RELACCENT, // leftwards arrow with plus below
'\u2947': MO.RELACCENT, // rightwards arrow through x
'\u2948': MO.RELACCENT, // left right arrow through small circle
'\u2949': MO.REL, // upwards two-headed arrow from small circle
'\u294A': MO.RELACCENT, // left barb up right barb down harpoon
'\u294B': MO.RELACCENT, // left barb down right barb up harpoon
'\u294C': MO.REL, // up barb right down barb left harpoon
'\u294D': MO.REL, // up barb left down barb right harpoon
'\u294E': MO.WIDEREL, // left barb up right barb up harpoon
'\u294F': MO.RELSTRETCH, // up barb right down barb right harpoon
'\u2950': MO.WIDEREL, // left barb down right barb down harpoon
'\u2951': MO.RELSTRETCH, // up barb left down barb left harpoon
'\u2952': MO.WIDEREL, // leftwards harpoon with barb up to bar
'\u2953': MO.WIDEREL, // rightwards harpoon with barb up to bar
'\u2954': MO.RELSTRETCH, // upwards harpoon with barb right to bar
'\u2955': MO.RELSTRETCH, // downwards harpoon with barb right to bar
'\u2956': MO.RELSTRETCH, // leftwards harpoon with barb down to bar
'\u2957': MO.RELSTRETCH, // rightwards harpoon with barb down to bar
'\u2958': MO.RELSTRETCH, // upwards harpoon with barb left to bar
'\u2959': MO.RELSTRETCH, // downwards harpoon with barb left to bar
'\u295A': MO.WIDEREL, // leftwards harpoon with barb up from bar
'\u295B': MO.WIDEREL, // rightwards harpoon with barb up from bar
'\u295C': MO.RELSTRETCH, // upwards harpoon with barb right from bar
'\u295D': MO.RELSTRETCH, // downwards harpoon with barb right from bar
'\u295E': MO.WIDEREL, // leftwards harpoon with barb down from bar
'\u295F': MO.WIDEREL, // rightwards harpoon with barb down from bar
'\u2960': MO.RELSTRETCH, // upwards harpoon with barb left from bar
'\u2961': MO.RELSTRETCH, // downwards harpoon with barb left from bar
'\u2962': MO.RELACCENT, // leftwards harpoon with barb up above leftwards harpoon with barb down
'\u2963': MO.REL, // upwards harpoon with barb left beside upwards harpoon with barb right
'\u2964': MO.RELACCENT, // rightwards harpoon with barb up above rightwards harpoon with barb down
'\u2965': MO.REL, // downwards harpoon with barb left beside downwards harpoon with barb right
'\u2966': MO.RELACCENT, // leftwards harpoon with barb up above rightwards harpoon with barb up
'\u2967': MO.RELACCENT, // leftwards harpoon with barb down above rightwards harpoon with barb down
'\u2968': MO.RELACCENT, // rightwards harpoon with barb up above leftwards harpoon with barb up
'\u2969': MO.RELACCENT, // rightwards harpoon with barb down above leftwards harpoon with barb down
'\u296A': MO.RELACCENT, // leftwards harpoon with barb up above long dash
'\u296B': MO.RELACCENT, // leftwards harpoon with barb down below long dash
'\u296C': MO.RELACCENT, // rightwards harpoon with barb up above long dash
'\u296D': MO.RELACCENT, // rightwards harpoon with barb down below long dash
'\u296E': MO.RELSTRETCH, // upwards harpoon with barb left beside downwards harpoon with barb right
'\u296F': MO.RELSTRETCH, // downwards harpoon with barb left beside upwards harpoon with barb right
'\u2970': MO.RELACCENT, // right double arrow with rounded head
'\u2971': MO.RELACCENT, // equals sign above rightwards arrow
'\u2972': MO.RELACCENT, // tilde operator above rightwards arrow
'\u2973': MO.RELACCENT, // leftwards arrow above tilde operator
'\u2974': MO.RELACCENT, // rightwards arrow above tilde operator
'\u2975': MO.RELACCENT, // rightwards arrow above almost equal to
'\u2976': MO.RELACCENT, // less-than above leftwards arrow
'\u2977': MO.RELACCENT, // leftwards arrow through less-than
'\u2978': MO.RELACCENT, // greater-than above rightwards arrow
'\u2979': MO.RELACCENT, // subset above rightwards arrow
'\u297A': MO.RELACCENT, // leftwards arrow through subset
'\u297B': MO.RELACCENT, // superset above leftwards arrow
'\u297C': MO.RELACCENT, // left fish tail
'\u297D': MO.RELACCENT, // right fish tail
'\u297E': MO.REL, // up fish tail
'\u297F': MO.REL // down fish tail
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsB.js");
})(MathJax.ElementJax.mml);

46
web/assets/MathJax/unpacked/jax/input/AsciiMath/config.js vendored Normal file
View File

@@ -0,0 +1,46 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/input/AsciiMath/config.js
*
* Initializes the AsciiMath InputJax (the main definition is in
* MathJax/jax/input/AsciiMath/jax.js, which is loaded when needed).
*
* Originally adapted for MathJax by David Lippman.
* Additional work done by Davide P. Cervone.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2012-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.InputJax.AsciiMath = MathJax.InputJax({
id: "AsciiMath",
version: "2.7.8",
directory: MathJax.InputJax.directory + "/AsciiMath",
extensionDir: MathJax.InputJax.extensionDir + "/AsciiMath",
config: {
fixphi: true, // switch phi and varphi unicode values
useMathMLspacing: true, // use MathML spacing rather than TeX spacing?
displaystyle: true, // put limits above and below operators
decimalsign: "." // can change to "," but watch out for "(1,2)"
}
});
MathJax.InputJax.AsciiMath.Register("math/asciimath");
MathJax.InputJax.AsciiMath.loadComplete("config.js");

1541
web/assets/MathJax/unpacked/jax/input/AsciiMath/jax.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

41
web/assets/MathJax/unpacked/jax/input/MathML/config.js vendored Normal file
View File

@@ -0,0 +1,41 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/input/MathML/config.js
*
* Initializes the MathML InputJax (the main definition is in
* MathJax/jax/input/MathML/jax.js, which is loaded when needed).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.InputJax.MathML = MathJax.InputJax({
id: "MathML",
version: "2.7.8",
directory: MathJax.InputJax.directory + "/MathML",
extensionDir: MathJax.InputJax.extensionDir + "/MathML",
entityDir: MathJax.InputJax.directory + "/MathML/entities",
config: {
useMathMLspacing: false // false means use TeX spacing, true means MML spacing
}
});
MathJax.InputJax.MathML.Register("math/mml");
MathJax.InputJax.MathML.loadComplete("config.js");

90
web/assets/MathJax/unpacked/jax/input/MathML/entities/a.js vendored Normal file
View File

@@ -0,0 +1,90 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/a.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'AElig': '\u00C6',
'AMP': '\u0026',
'Aacute': '\u00C1',
'Abreve': '\u0102',
'Acirc': '\u00C2',
'Acy': '\u0410',
'Agrave': '\u00C0',
'Alpha': '\u0391',
'Amacr': '\u0100',
'And': '\u2A53',
'Aogon': '\u0104',
'Aring': '\u00C5',
'Assign': '\u2254',
'Atilde': '\u00C3',
'Auml': '\u00C4',
'aacute': '\u00E1',
'abreve': '\u0103',
'ac': '\u223E',
'acE': '\u223E\u0333',
'acd': '\u223F',
'acirc': '\u00E2',
'acy': '\u0430',
'aelig': '\u00E6',
'af': '\u2061',
'agrave': '\u00E0',
'alefsym': '\u2135',
'amacr': '\u0101',
'amp': '\u0026',
'andand': '\u2A55',
'andd': '\u2A5C',
'andslope': '\u2A58',
'andv': '\u2A5A',
'ange': '\u29A4',
'angle': '\u2220',
'angmsdaa': '\u29A8',
'angmsdab': '\u29A9',
'angmsdac': '\u29AA',
'angmsdad': '\u29AB',
'angmsdae': '\u29AC',
'angmsdaf': '\u29AD',
'angmsdag': '\u29AE',
'angmsdah': '\u29AF',
'angrt': '\u221F',
'angrtvb': '\u22BE',
'angrtvbd': '\u299D',
'angst': '\u00C5',
'angzarr': '\u237C',
'aogon': '\u0105',
'ap': '\u2248',
'apE': '\u2A70',
'apacir': '\u2A6F',
'apid': '\u224B',
'apos': '\u0027',
'approx': '\u2248',
'approxeq': '\u224A',
'aring': '\u00E5',
'ast': '\u002A',
'asymp': '\u2248',
'asympeq': '\u224D',
'atilde': '\u00E3',
'auml': '\u00E4',
'awconint': '\u2233',
'awint': '\u2A11'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/a.js");
})(MathJax.InputJax.MathML);

116
web/assets/MathJax/unpacked/jax/input/MathML/entities/b.js vendored Normal file
View File

@@ -0,0 +1,116 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/b.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Barv': '\u2AE7',
'Barwed': '\u2306',
'Bcy': '\u0411',
'Bernoullis': '\u212C',
'Beta': '\u0392',
'Bumpeq': '\u224E',
'bNot': '\u2AED',
'backcong': '\u224C',
'backepsilon': '\u03F6',
'barvee': '\u22BD',
'barwed': '\u2305',
'barwedge': '\u2305',
'bbrk': '\u23B5',
'bbrktbrk': '\u23B6',
'bcong': '\u224C',
'bcy': '\u0431',
'bdquo': '\u201E',
'becaus': '\u2235',
'because': '\u2235',
'bemptyv': '\u29B0',
'bepsi': '\u03F6',
'bernou': '\u212C',
'bigcap': '\u22C2',
'bigcup': '\u22C3',
'bigvee': '\u22C1',
'bigwedge': '\u22C0',
'bkarow': '\u290D',
'blacksquare': '\u25AA',
'blacktriangleright': '\u25B8',
'blank': '\u2423',
'blk12': '\u2592',
'blk14': '\u2591',
'blk34': '\u2593',
'block': '\u2588',
'bne': '\u003D\u20E5',
'bnequiv': '\u2261\u20E5',
'bnot': '\u2310',
'bot': '\u22A5',
'bottom': '\u22A5',
'boxDL': '\u2557',
'boxDR': '\u2554',
'boxDl': '\u2556',
'boxDr': '\u2553',
'boxH': '\u2550',
'boxHD': '\u2566',
'boxHU': '\u2569',
'boxHd': '\u2564',
'boxHu': '\u2567',
'boxUL': '\u255D',
'boxUR': '\u255A',
'boxUl': '\u255C',
'boxUr': '\u2559',
'boxV': '\u2551',
'boxVH': '\u256C',
'boxVL': '\u2563',
'boxVR': '\u2560',
'boxVh': '\u256B',
'boxVl': '\u2562',
'boxVr': '\u255F',
'boxbox': '\u29C9',
'boxdL': '\u2555',
'boxdR': '\u2552',
'boxh': '\u2500',
'boxhD': '\u2565',
'boxhU': '\u2568',
'boxhd': '\u252C',
'boxhu': '\u2534',
'boxuL': '\u255B',
'boxuR': '\u2558',
'boxv': '\u2502',
'boxvH': '\u256A',
'boxvL': '\u2561',
'boxvR': '\u255E',
'boxvh': '\u253C',
'boxvl': '\u2524',
'boxvr': '\u251C',
'bprime': '\u2035',
'breve': '\u02D8',
'brvbar': '\u00A6',
'bsemi': '\u204F',
'bsim': '\u223D',
'bsime': '\u22CD',
'bsolb': '\u29C5',
'bsolhsub': '\u27C8',
'bullet': '\u2022',
'bump': '\u224E',
'bumpE': '\u2AAE',
'bumpe': '\u224F',
'bumpeq': '\u224F'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/b.js");
})(MathJax.InputJax.MathML);

114
web/assets/MathJax/unpacked/jax/input/MathML/entities/c.js vendored Normal file
View File

@@ -0,0 +1,114 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/c.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'CHcy': '\u0427',
'COPY': '\u00A9',
'Cacute': '\u0106',
'CapitalDifferentialD': '\u2145',
'Cayleys': '\u212D',
'Ccaron': '\u010C',
'Ccedil': '\u00C7',
'Ccirc': '\u0108',
'Cconint': '\u2230',
'Cdot': '\u010A',
'Cedilla': '\u00B8',
'Chi': '\u03A7',
'ClockwiseContourIntegral': '\u2232',
'CloseCurlyDoubleQuote': '\u201D',
'CloseCurlyQuote': '\u2019',
'Colon': '\u2237',
'Colone': '\u2A74',
'Conint': '\u222F',
'CounterClockwiseContourIntegral': '\u2233',
'cacute': '\u0107',
'capand': '\u2A44',
'capbrcup': '\u2A49',
'capcap': '\u2A4B',
'capcup': '\u2A47',
'capdot': '\u2A40',
'caps': '\u2229\uFE00',
'caret': '\u2041',
'caron': '\u02C7',
'ccaps': '\u2A4D',
'ccaron': '\u010D',
'ccedil': '\u00E7',
'ccirc': '\u0109',
'ccups': '\u2A4C',
'ccupssm': '\u2A50',
'cdot': '\u010B',
'cedil': '\u00B8',
'cemptyv': '\u29B2',
'cent': '\u00A2',
'centerdot': '\u00B7',
'chcy': '\u0447',
'checkmark': '\u2713',
'cir': '\u25CB',
'cirE': '\u29C3',
'cire': '\u2257',
'cirfnint': '\u2A10',
'cirmid': '\u2AEF',
'cirscir': '\u29C2',
'clubsuit': '\u2663',
'colone': '\u2254',
'coloneq': '\u2254',
'comma': '\u002C',
'commat': '\u0040',
'compfn': '\u2218',
'complement': '\u2201',
'complexes': '\u2102',
'cong': '\u2245',
'congdot': '\u2A6D',
'conint': '\u222E',
'coprod': '\u2210',
'copy': '\u00A9',
'copysr': '\u2117',
'crarr': '\u21B5',
'cross': '\u2717',
'csub': '\u2ACF',
'csube': '\u2AD1',
'csup': '\u2AD0',
'csupe': '\u2AD2',
'cudarrl': '\u2938',
'cudarrr': '\u2935',
'cularrp': '\u293D',
'cupbrcap': '\u2A48',
'cupcap': '\u2A46',
'cupcup': '\u2A4A',
'cupdot': '\u228D',
'cupor': '\u2A45',
'cups': '\u222A\uFE00',
'curarrm': '\u293C',
'curlyeqprec': '\u22DE',
'curlyeqsucc': '\u22DF',
'curren': '\u00A4',
'curvearrowleft': '\u21B6',
'curvearrowright': '\u21B7',
'cuvee': '\u22CE',
'cuwed': '\u22CF',
'cwconint': '\u2232',
'cwint': '\u2231',
'cylcty': '\u232D'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/c.js");
})(MathJax.InputJax.MathML);

112
web/assets/MathJax/unpacked/jax/input/MathML/entities/d.js vendored Normal file
View File

@@ -0,0 +1,112 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/d.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'DD': '\u2145',
'DDotrahd': '\u2911',
'DJcy': '\u0402',
'DScy': '\u0405',
'DZcy': '\u040F',
'Darr': '\u21A1',
'Dashv': '\u2AE4',
'Dcaron': '\u010E',
'Dcy': '\u0414',
'DiacriticalAcute': '\u00B4',
'DiacriticalDot': '\u02D9',
'DiacriticalDoubleAcute': '\u02DD',
'DiacriticalGrave': '\u0060',
'DiacriticalTilde': '\u02DC',
'Dot': '\u00A8',
'DotDot': '\u20DC',
'DoubleContourIntegral': '\u222F',
'DoubleDownArrow': '\u21D3',
'DoubleLeftArrow': '\u21D0',
'DoubleLeftRightArrow': '\u21D4',
'DoubleLeftTee': '\u2AE4',
'DoubleLongLeftArrow': '\u27F8',
'DoubleLongLeftRightArrow': '\u27FA',
'DoubleLongRightArrow': '\u27F9',
'DoubleRightArrow': '\u21D2',
'DoubleUpArrow': '\u21D1',
'DoubleUpDownArrow': '\u21D5',
'DownArrowBar': '\u2913',
'DownArrowUpArrow': '\u21F5',
'DownBreve': '\u0311',
'DownLeftRightVector': '\u2950',
'DownLeftTeeVector': '\u295E',
'DownLeftVectorBar': '\u2956',
'DownRightTeeVector': '\u295F',
'DownRightVectorBar': '\u2957',
'DownTeeArrow': '\u21A7',
'Dstrok': '\u0110',
'dArr': '\u21D3',
'dHar': '\u2965',
'darr': '\u2193',
'dash': '\u2010',
'dashv': '\u22A3',
'dbkarow': '\u290F',
'dblac': '\u02DD',
'dcaron': '\u010F',
'dcy': '\u0434',
'dd': '\u2146',
'ddagger': '\u2021',
'ddotseq': '\u2A77',
'demptyv': '\u29B1',
'dfisht': '\u297F',
'dharl': '\u21C3',
'dharr': '\u21C2',
'diam': '\u22C4',
'diamond': '\u22C4',
'diamondsuit': '\u2666',
'diams': '\u2666',
'die': '\u00A8',
'disin': '\u22F2',
'divide': '\u00F7',
'divonx': '\u22C7',
'djcy': '\u0452',
'dlcorn': '\u231E',
'dlcrop': '\u230D',
'dollar': '\u0024',
'doteq': '\u2250',
'dotminus': '\u2238',
'doublebarwedge': '\u2306',
'downarrow': '\u2193',
'downdownarrows': '\u21CA',
'downharpoonleft': '\u21C3',
'downharpoonright': '\u21C2',
'drbkarow': '\u2910',
'drcorn': '\u231F',
'drcrop': '\u230C',
'dscy': '\u0455',
'dsol': '\u29F6',
'dstrok': '\u0111',
'dtri': '\u25BF',
'dtrif': '\u25BE',
'duarr': '\u21F5',
'duhar': '\u296F',
'dwangle': '\u29A6',
'dzcy': '\u045F',
'dzigrarr': '\u27FF'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/d.js");
})(MathJax.InputJax.MathML);

92
web/assets/MathJax/unpacked/jax/input/MathML/entities/e.js vendored Normal file
View File

@@ -0,0 +1,92 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/e.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'ENG': '\u014A',
'ETH': '\u00D0',
'Eacute': '\u00C9',
'Ecaron': '\u011A',
'Ecirc': '\u00CA',
'Ecy': '\u042D',
'Edot': '\u0116',
'Egrave': '\u00C8',
'Emacr': '\u0112',
'EmptySmallSquare': '\u25FB',
'EmptyVerySmallSquare': '\u25AB',
'Eogon': '\u0118',
'Epsilon': '\u0395',
'Equal': '\u2A75',
'Esim': '\u2A73',
'Eta': '\u0397',
'Euml': '\u00CB',
'eDDot': '\u2A77',
'eDot': '\u2251',
'eacute': '\u00E9',
'easter': '\u2A6E',
'ecaron': '\u011B',
'ecirc': '\u00EA',
'ecolon': '\u2255',
'ecy': '\u044D',
'edot': '\u0117',
'ee': '\u2147',
'eg': '\u2A9A',
'egrave': '\u00E8',
'egsdot': '\u2A98',
'el': '\u2A99',
'elinters': '\u23E7',
'elsdot': '\u2A97',
'emacr': '\u0113',
'emptyset': '\u2205',
'emptyv': '\u2205',
'emsp': '\u2003',
'emsp13': '\u2004',
'emsp14': '\u2005',
'eng': '\u014B',
'ensp': '\u2002',
'eogon': '\u0119',
'epar': '\u22D5',
'eparsl': '\u29E3',
'eplus': '\u2A71',
'epsilon': '\u03B5',
'eqcirc': '\u2256',
'eqcolon': '\u2255',
'eqsim': '\u2242',
'eqslantgtr': '\u2A96',
'eqslantless': '\u2A95',
'equals': '\u003D',
'equest': '\u225F',
'equiv': '\u2261',
'equivDD': '\u2A78',
'eqvparsl': '\u29E5',
'erarr': '\u2971',
'esdot': '\u2250',
'esim': '\u2242',
'euml': '\u00EB',
'euro': '\u20AC',
'excl': '\u0021',
'exist': '\u2203',
'expectation': '\u2130',
'exponentiale': '\u2147'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/e.js");
})(MathJax.InputJax.MathML);

60
web/assets/MathJax/unpacked/jax/input/MathML/entities/f.js vendored Normal file
View File

@@ -0,0 +1,60 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/f.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Fcy': '\u0424',
'FilledSmallSquare': '\u25FC',
'Fouriertrf': '\u2131',
'fallingdotseq': '\u2252',
'fcy': '\u0444',
'female': '\u2640',
'ffilig': '\uFB03',
'fflig': '\uFB00',
'ffllig': '\uFB04',
'filig': '\uFB01',
'fjlig': '\u0066\u006A',
'fllig': '\uFB02',
'fltns': '\u25B1',
'fnof': '\u0192',
'forall': '\u2200',
'forkv': '\u2AD9',
'fpartint': '\u2A0D',
'frac12': '\u00BD',
'frac13': '\u2153',
'frac14': '\u00BC',
'frac15': '\u2155',
'frac16': '\u2159',
'frac18': '\u215B',
'frac23': '\u2154',
'frac25': '\u2156',
'frac34': '\u00BE',
'frac35': '\u2157',
'frac38': '\u215C',
'frac45': '\u2158',
'frac56': '\u215A',
'frac58': '\u215D',
'frac78': '\u215E',
'frasl': '\u2044'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/f.js");
})(MathJax.InputJax.MathML);

79
web/assets/MathJax/unpacked/jax/input/MathML/entities/fr.js vendored Normal file
View File

@@ -0,0 +1,79 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/fr.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Afr': '\uD835\uDD04',
'Bfr': '\uD835\uDD05',
'Cfr': '\u212D',
'Dfr': '\uD835\uDD07',
'Efr': '\uD835\uDD08',
'Ffr': '\uD835\uDD09',
'Gfr': '\uD835\uDD0A',
'Hfr': '\u210C',
'Ifr': '\u2111',
'Jfr': '\uD835\uDD0D',
'Kfr': '\uD835\uDD0E',
'Lfr': '\uD835\uDD0F',
'Mfr': '\uD835\uDD10',
'Nfr': '\uD835\uDD11',
'Ofr': '\uD835\uDD12',
'Pfr': '\uD835\uDD13',
'Qfr': '\uD835\uDD14',
'Rfr': '\u211C',
'Sfr': '\uD835\uDD16',
'Tfr': '\uD835\uDD17',
'Ufr': '\uD835\uDD18',
'Vfr': '\uD835\uDD19',
'Wfr': '\uD835\uDD1A',
'Xfr': '\uD835\uDD1B',
'Yfr': '\uD835\uDD1C',
'Zfr': '\u2128',
'afr': '\uD835\uDD1E',
'bfr': '\uD835\uDD1F',
'cfr': '\uD835\uDD20',
'dfr': '\uD835\uDD21',
'efr': '\uD835\uDD22',
'ffr': '\uD835\uDD23',
'gfr': '\uD835\uDD24',
'hfr': '\uD835\uDD25',
'ifr': '\uD835\uDD26',
'jfr': '\uD835\uDD27',
'kfr': '\uD835\uDD28',
'lfr': '\uD835\uDD29',
'mfr': '\uD835\uDD2A',
'nfr': '\uD835\uDD2B',
'ofr': '\uD835\uDD2C',
'pfr': '\uD835\uDD2D',
'qfr': '\uD835\uDD2E',
'rfr': '\uD835\uDD2F',
'sfr': '\uD835\uDD30',
'tfr': '\uD835\uDD31',
'ufr': '\uD835\uDD32',
'vfr': '\uD835\uDD33',
'wfr': '\uD835\uDD34',
'xfr': '\uD835\uDD35',
'yfr': '\uD835\uDD36',
'zfr': '\uD835\uDD37'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/fr.js");
})(MathJax.InputJax.MathML);

83
web/assets/MathJax/unpacked/jax/input/MathML/entities/g.js vendored Normal file
View File

@@ -0,0 +1,83 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/g.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'GJcy': '\u0403',
'GT': '\u003E',
'Gammad': '\u03DC',
'Gbreve': '\u011E',
'Gcedil': '\u0122',
'Gcirc': '\u011C',
'Gcy': '\u0413',
'Gdot': '\u0120',
'GreaterGreater': '\u2AA2',
'Gt': '\u226B',
'gE': '\u2267',
'gacute': '\u01F5',
'gammad': '\u03DD',
'gbreve': '\u011F',
'gcirc': '\u011D',
'gcy': '\u0433',
'gdot': '\u0121',
'ge': '\u2265',
'gel': '\u22DB',
'geq': '\u2265',
'geqq': '\u2267',
'geqslant': '\u2A7E',
'ges': '\u2A7E',
'gescc': '\u2AA9',
'gesdot': '\u2A80',
'gesdoto': '\u2A82',
'gesdotol': '\u2A84',
'gesl': '\u22DB\uFE00',
'gesles': '\u2A94',
'gg': '\u226B',
'ggg': '\u22D9',
'gjcy': '\u0453',
'gl': '\u2277',
'glE': '\u2A92',
'gla': '\u2AA5',
'glj': '\u2AA4',
'gnapprox': '\u2A8A',
'gneq': '\u2A88',
'gneqq': '\u2269',
'grave': '\u0060',
'gsim': '\u2273',
'gsime': '\u2A8E',
'gsiml': '\u2A90',
'gtcc': '\u2AA7',
'gtcir': '\u2A7A',
'gtlPar': '\u2995',
'gtquest': '\u2A7C',
'gtrapprox': '\u2A86',
'gtrarr': '\u2978',
'gtrdot': '\u22D7',
'gtreqless': '\u22DB',
'gtreqqless': '\u2A8C',
'gtrless': '\u2277',
'gtrsim': '\u2273',
'gvertneqq': '\u2269\uFE00',
'gvnE': '\u2269\uFE00'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/g.js");
})(MathJax.InputJax.MathML);

52
web/assets/MathJax/unpacked/jax/input/MathML/entities/h.js vendored Normal file
View File

@@ -0,0 +1,52 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/h.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'HARDcy': '\u042A',
'Hcirc': '\u0124',
'HilbertSpace': '\u210B',
'HorizontalLine': '\u2500',
'Hstrok': '\u0126',
'hArr': '\u21D4',
'hairsp': '\u200A',
'half': '\u00BD',
'hamilt': '\u210B',
'hardcy': '\u044A',
'harr': '\u2194',
'harrcir': '\u2948',
'hcirc': '\u0125',
'hearts': '\u2665',
'heartsuit': '\u2665',
'hercon': '\u22B9',
'hksearow': '\u2925',
'hkswarow': '\u2926',
'hoarr': '\u21FF',
'homtht': '\u223B',
'horbar': '\u2015',
'hslash': '\u210F',
'hstrok': '\u0127',
'hybull': '\u2043',
'hyphen': '\u2010'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/h.js");
})(MathJax.InputJax.MathML);

86
web/assets/MathJax/unpacked/jax/input/MathML/entities/i.js vendored Normal file
View File

@@ -0,0 +1,86 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/i.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'IEcy': '\u0415',
'IJlig': '\u0132',
'IOcy': '\u0401',
'Iacute': '\u00CD',
'Icirc': '\u00CE',
'Icy': '\u0418',
'Idot': '\u0130',
'Igrave': '\u00CC',
'Imacr': '\u012A',
'Implies': '\u21D2',
'Int': '\u222C',
'Iogon': '\u012E',
'Iota': '\u0399',
'Itilde': '\u0128',
'Iukcy': '\u0406',
'Iuml': '\u00CF',
'iacute': '\u00ED',
'ic': '\u2063',
'icirc': '\u00EE',
'icy': '\u0438',
'iecy': '\u0435',
'iexcl': '\u00A1',
'iff': '\u21D4',
'igrave': '\u00EC',
'ii': '\u2148',
'iiiint': '\u2A0C',
'iiint': '\u222D',
'iinfin': '\u29DC',
'iiota': '\u2129',
'ijlig': '\u0133',
'imacr': '\u012B',
'image': '\u2111',
'imagline': '\u2110',
'imagpart': '\u2111',
'imof': '\u22B7',
'imped': '\u01B5',
'in': '\u2208',
'incare': '\u2105',
'infintie': '\u29DD',
'inodot': '\u0131',
'int': '\u222B',
'integers': '\u2124',
'intercal': '\u22BA',
'intlarhk': '\u2A17',
'intprod': '\u2A3C',
'iocy': '\u0451',
'iogon': '\u012F',
'iprod': '\u2A3C',
'iquest': '\u00BF',
'isin': '\u2208',
'isinE': '\u22F9',
'isindot': '\u22F5',
'isins': '\u22F4',
'isinsv': '\u22F3',
'isinv': '\u2208',
'it': '\u2062',
'itilde': '\u0129',
'iukcy': '\u0456',
'iuml': '\u00EF'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/i.js");
})(MathJax.InputJax.MathML);

35
web/assets/MathJax/unpacked/jax/input/MathML/entities/j.js vendored Normal file
View File

@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/j.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Jcirc': '\u0134',
'Jcy': '\u0419',
'Jsercy': '\u0408',
'Jukcy': '\u0404',
'jcirc': '\u0135',
'jcy': '\u0439',
'jsercy': '\u0458',
'jukcy': '\u0454'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/j.js");
})(MathJax.InputJax.MathML);

37
web/assets/MathJax/unpacked/jax/input/MathML/entities/k.js vendored Normal file
View File

@@ -0,0 +1,37 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/k.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'KHcy': '\u0425',
'KJcy': '\u040C',
'Kappa': '\u039A',
'Kcedil': '\u0136',
'Kcy': '\u041A',
'kcedil': '\u0137',
'kcy': '\u043A',
'kgreen': '\u0138',
'khcy': '\u0445',
'kjcy': '\u045C'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/k.js");
})(MathJax.InputJax.MathML);

179
web/assets/MathJax/unpacked/jax/input/MathML/entities/l.js vendored Normal file
View File

@@ -0,0 +1,179 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/l.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'LJcy': '\u0409',
'LT': '\u003C',
'Lacute': '\u0139',
'Lang': '\u27EA',
'Laplacetrf': '\u2112',
'Lcaron': '\u013D',
'Lcedil': '\u013B',
'Lcy': '\u041B',
'LeftArrowBar': '\u21E4',
'LeftDoubleBracket': '\u27E6',
'LeftDownTeeVector': '\u2961',
'LeftDownVectorBar': '\u2959',
'LeftRightVector': '\u294E',
'LeftTeeArrow': '\u21A4',
'LeftTeeVector': '\u295A',
'LeftTriangleBar': '\u29CF',
'LeftUpDownVector': '\u2951',
'LeftUpTeeVector': '\u2960',
'LeftUpVectorBar': '\u2958',
'LeftVectorBar': '\u2952',
'LessLess': '\u2AA1',
'Lmidot': '\u013F',
'LowerLeftArrow': '\u2199',
'LowerRightArrow': '\u2198',
'Lstrok': '\u0141',
'Lt': '\u226A',
'lAarr': '\u21DA',
'lArr': '\u21D0',
'lAtail': '\u291B',
'lBarr': '\u290E',
'lE': '\u2266',
'lHar': '\u2962',
'lacute': '\u013A',
'laemptyv': '\u29B4',
'lagran': '\u2112',
'lang': '\u27E8',
'langd': '\u2991',
'langle': '\u27E8',
'laquo': '\u00AB',
'larr': '\u2190',
'larrb': '\u21E4',
'larrbfs': '\u291F',
'larrfs': '\u291D',
'larrhk': '\u21A9',
'larrpl': '\u2939',
'larrsim': '\u2973',
'lat': '\u2AAB',
'latail': '\u2919',
'late': '\u2AAD',
'lates': '\u2AAD\uFE00',
'lbarr': '\u290C',
'lbbrk': '\u2772',
'lbrke': '\u298B',
'lbrksld': '\u298F',
'lbrkslu': '\u298D',
'lcaron': '\u013E',
'lcedil': '\u013C',
'lceil': '\u2308',
'lcub': '\u007B',
'lcy': '\u043B',
'ldca': '\u2936',
'ldquo': '\u201C',
'ldquor': '\u201E',
'ldrdhar': '\u2967',
'ldrushar': '\u294B',
'ldsh': '\u21B2',
'leftarrow': '\u2190',
'leftarrowtail': '\u21A2',
'leftharpoondown': '\u21BD',
'leftharpoonup': '\u21BC',
'leftrightarrow': '\u2194',
'leftrightarrows': '\u21C6',
'leftrightharpoons': '\u21CB',
'leftrightsquigarrow': '\u21AD',
'leg': '\u22DA',
'leq': '\u2264',
'leqq': '\u2266',
'leqslant': '\u2A7D',
'les': '\u2A7D',
'lescc': '\u2AA8',
'lesdot': '\u2A7F',
'lesdoto': '\u2A81',
'lesdotor': '\u2A83',
'lesg': '\u22DA\uFE00',
'lesges': '\u2A93',
'lessapprox': '\u2A85',
'lesseqgtr': '\u22DA',
'lesseqqgtr': '\u2A8B',
'lessgtr': '\u2276',
'lesssim': '\u2272',
'lfisht': '\u297C',
'lfloor': '\u230A',
'lg': '\u2276',
'lgE': '\u2A91',
'lhard': '\u21BD',
'lharu': '\u21BC',
'lharul': '\u296A',
'lhblk': '\u2584',
'ljcy': '\u0459',
'll': '\u226A',
'llarr': '\u21C7',
'llcorner': '\u231E',
'llhard': '\u296B',
'lltri': '\u25FA',
'lmidot': '\u0140',
'lmoustache': '\u23B0',
'lnapprox': '\u2A89',
'lneq': '\u2A87',
'lneqq': '\u2268',
'loang': '\u27EC',
'loarr': '\u21FD',
'lobrk': '\u27E6',
'longleftarrow': '\u27F5',
'longleftrightarrow': '\u27F7',
'longrightarrow': '\u27F6',
'looparrowleft': '\u21AB',
'lopar': '\u2985',
'loplus': '\u2A2D',
'lotimes': '\u2A34',
'lowbar': '\u005F',
'lozenge': '\u25CA',
'lozf': '\u29EB',
'lpar': '\u0028',
'lparlt': '\u2993',
'lrarr': '\u21C6',
'lrcorner': '\u231F',
'lrhar': '\u21CB',
'lrhard': '\u296D',
'lrm': '\u200E',
'lrtri': '\u22BF',
'lsaquo': '\u2039',
'lsh': '\u21B0',
'lsim': '\u2272',
'lsime': '\u2A8D',
'lsimg': '\u2A8F',
'lsqb': '\u005B',
'lsquo': '\u2018',
'lsquor': '\u201A',
'lstrok': '\u0142',
'ltcc': '\u2AA6',
'ltcir': '\u2A79',
'ltdot': '\u22D6',
'lthree': '\u22CB',
'ltlarr': '\u2976',
'ltquest': '\u2A7B',
'ltrPar': '\u2996',
'ltrie': '\u22B4',
'ltrif': '\u25C2',
'lurdshar': '\u294A',
'luruhar': '\u2966',
'lvertneqq': '\u2268\uFE00',
'lvnE': '\u2268\uFE00'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/l.js");
})(MathJax.InputJax.MathML);

61
web/assets/MathJax/unpacked/jax/input/MathML/entities/m.js vendored Normal file
View File

@@ -0,0 +1,61 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/m.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Map': '\u2905',
'Mcy': '\u041C',
'MediumSpace': '\u205F',
'Mellintrf': '\u2133',
'Mu': '\u039C',
'mDDot': '\u223A',
'male': '\u2642',
'maltese': '\u2720',
'map': '\u21A6',
'mapsto': '\u21A6',
'mapstodown': '\u21A7',
'mapstoleft': '\u21A4',
'mapstoup': '\u21A5',
'marker': '\u25AE',
'mcomma': '\u2A29',
'mcy': '\u043C',
'mdash': '\u2014',
'measuredangle': '\u2221',
'micro': '\u00B5',
'mid': '\u2223',
'midast': '\u002A',
'midcir': '\u2AF0',
'middot': '\u00B7',
'minus': '\u2212',
'minusb': '\u229F',
'minusd': '\u2238',
'minusdu': '\u2A2A',
'mlcp': '\u2ADB',
'mldr': '\u2026',
'mnplus': '\u2213',
'models': '\u22A7',
'mp': '\u2213',
'mstpos': '\u223E',
'mumap': '\u22B8'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/m.js");
})(MathJax.InputJax.MathML);

220
web/assets/MathJax/unpacked/jax/input/MathML/entities/n.js vendored Normal file
View File

@@ -0,0 +1,220 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/n.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'NJcy': '\u040A',
'Nacute': '\u0143',
'Ncaron': '\u0147',
'Ncedil': '\u0145',
'Ncy': '\u041D',
'NegativeMediumSpace': '\u200B',
'NegativeThickSpace': '\u200B',
'NegativeThinSpace': '\u200B',
'NegativeVeryThinSpace': '\u200B',
'NewLine': '\u000A',
'NoBreak': '\u2060',
'NonBreakingSpace': '\u00A0',
'Not': '\u2AEC',
'NotCongruent': '\u2262',
'NotCupCap': '\u226D',
'NotEqualTilde': '\u2242\u0338',
'NotGreaterFullEqual': '\u2267\u0338',
'NotGreaterGreater': '\u226B\u0338',
'NotGreaterLess': '\u2279',
'NotGreaterSlantEqual': '\u2A7E\u0338',
'NotGreaterTilde': '\u2275',
'NotHumpDownHump': '\u224E\u0338',
'NotHumpEqual': '\u224F\u0338',
'NotLeftTriangleBar': '\u29CF\u0338',
'NotLessGreater': '\u2278',
'NotLessLess': '\u226A\u0338',
'NotLessSlantEqual': '\u2A7D\u0338',
'NotLessTilde': '\u2274',
'NotNestedGreaterGreater': '\u2AA2\u0338',
'NotNestedLessLess': '\u2AA1\u0338',
'NotPrecedesEqual': '\u2AAF\u0338',
'NotReverseElement': '\u220C',
'NotRightTriangleBar': '\u29D0\u0338',
'NotSquareSubset': '\u228F\u0338',
'NotSquareSubsetEqual': '\u22E2',
'NotSquareSuperset': '\u2290\u0338',
'NotSquareSupersetEqual': '\u22E3',
'NotSubset': '\u2282\u20D2',
'NotSucceedsEqual': '\u2AB0\u0338',
'NotSucceedsTilde': '\u227F\u0338',
'NotSuperset': '\u2283\u20D2',
'NotTildeEqual': '\u2244',
'NotTildeFullEqual': '\u2247',
'NotTildeTilde': '\u2249',
'Ntilde': '\u00D1',
'Nu': '\u039D',
'nGg': '\u22D9\u0338',
'nGt': '\u226B\u20D2',
'nGtv': '\u226B\u0338',
'nLl': '\u22D8\u0338',
'nLt': '\u226A\u20D2',
'nLtv': '\u226A\u0338',
'nabla': '\u2207',
'nacute': '\u0144',
'nang': '\u2220\u20D2',
'nap': '\u2249',
'napE': '\u2A70\u0338',
'napid': '\u224B\u0338',
'napos': '\u0149',
'napprox': '\u2249',
'natural': '\u266E',
'naturals': '\u2115',
'nbsp': '\u00A0',
'nbump': '\u224E\u0338',
'nbumpe': '\u224F\u0338',
'ncap': '\u2A43',
'ncaron': '\u0148',
'ncedil': '\u0146',
'ncong': '\u2247',
'ncongdot': '\u2A6D\u0338',
'ncup': '\u2A42',
'ncy': '\u043D',
'ndash': '\u2013',
'ne': '\u2260',
'neArr': '\u21D7',
'nearhk': '\u2924',
'nearrow': '\u2197',
'nedot': '\u2250\u0338',
'nequiv': '\u2262',
'nesear': '\u2928',
'nesim': '\u2242\u0338',
'nexist': '\u2204',
'nexists': '\u2204',
'ngE': '\u2267\u0338',
'nge': '\u2271',
'ngeq': '\u2271',
'ngeqq': '\u2267\u0338',
'ngeqslant': '\u2A7E\u0338',
'nges': '\u2A7E\u0338',
'ngsim': '\u2275',
'ngt': '\u226F',
'ngtr': '\u226F',
'nhArr': '\u21CE',
'nhpar': '\u2AF2',
'ni': '\u220B',
'nis': '\u22FC',
'nisd': '\u22FA',
'niv': '\u220B',
'njcy': '\u045A',
'nlArr': '\u21CD',
'nlE': '\u2266\u0338',
'nldr': '\u2025',
'nle': '\u2270',
'nleftarrow': '\u219A',
'nleftrightarrow': '\u21AE',
'nleq': '\u2270',
'nleqq': '\u2266\u0338',
'nleqslant': '\u2A7D\u0338',
'nles': '\u2A7D\u0338',
'nless': '\u226E',
'nlsim': '\u2274',
'nlt': '\u226E',
'nltri': '\u22EA',
'nltrie': '\u22EC',
'nmid': '\u2224',
'notin': '\u2209',
'notinE': '\u22F9\u0338',
'notindot': '\u22F5\u0338',
'notinva': '\u2209',
'notinvb': '\u22F7',
'notinvc': '\u22F6',
'notni': '\u220C',
'notniva': '\u220C',
'notnivb': '\u22FE',
'notnivc': '\u22FD',
'npar': '\u2226',
'nparallel': '\u2226',
'nparsl': '\u2AFD\u20E5',
'npart': '\u2202\u0338',
'npolint': '\u2A14',
'npr': '\u2280',
'nprcue': '\u22E0',
'npre': '\u2AAF\u0338',
'nprec': '\u2280',
'npreceq': '\u2AAF\u0338',
'nrArr': '\u21CF',
'nrarrc': '\u2933\u0338',
'nrarrw': '\u219D\u0338',
'nrightarrow': '\u219B',
'nrtri': '\u22EB',
'nrtrie': '\u22ED',
'nsc': '\u2281',
'nsccue': '\u22E1',
'nsce': '\u2AB0\u0338',
'nshortmid': '\u2224',
'nshortparallel': '\u2226',
'nsim': '\u2241',
'nsime': '\u2244',
'nsimeq': '\u2244',
'nsmid': '\u2224',
'nspar': '\u2226',
'nsqsube': '\u22E2',
'nsqsupe': '\u22E3',
'nsub': '\u2284',
'nsubE': '\u2AC5\u0338',
'nsube': '\u2288',
'nsubset': '\u2282\u20D2',
'nsubseteq': '\u2288',
'nsubseteqq': '\u2AC5\u0338',
'nsucc': '\u2281',
'nsucceq': '\u2AB0\u0338',
'nsup': '\u2285',
'nsupE': '\u2AC6\u0338',
'nsupe': '\u2289',
'nsupset': '\u2283\u20D2',
'nsupseteq': '\u2289',
'nsupseteqq': '\u2AC6\u0338',
'ntgl': '\u2279',
'ntilde': '\u00F1',
'ntlg': '\u2278',
'ntriangleleft': '\u22EA',
'ntrianglelefteq': '\u22EC',
'ntriangleright': '\u22EB',
'ntrianglerighteq': '\u22ED',
'num': '\u0023',
'numero': '\u2116',
'numsp': '\u2007',
'nvHarr': '\u2904',
'nvap': '\u224D\u20D2',
'nvge': '\u2265\u20D2',
'nvgt': '\u003E\u20D2',
'nvinfin': '\u29DE',
'nvlArr': '\u2902',
'nvle': '\u2264\u20D2',
'nvlt': '\u003C\u20D2',
'nvltrie': '\u22B4\u20D2',
'nvrArr': '\u2903',
'nvrtrie': '\u22B5\u20D2',
'nvsim': '\u223C\u20D2',
'nwArr': '\u21D6',
'nwarhk': '\u2923',
'nwarrow': '\u2196',
'nwnear': '\u2927'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/n.js");
})(MathJax.InputJax.MathML);

90
web/assets/MathJax/unpacked/jax/input/MathML/entities/o.js vendored Normal file
View File

@@ -0,0 +1,90 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/o.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'OElig': '\u0152',
'Oacute': '\u00D3',
'Ocirc': '\u00D4',
'Ocy': '\u041E',
'Odblac': '\u0150',
'Ograve': '\u00D2',
'Omacr': '\u014C',
'Omicron': '\u039F',
'OpenCurlyDoubleQuote': '\u201C',
'OpenCurlyQuote': '\u2018',
'Or': '\u2A54',
'Oslash': '\u00D8',
'Otilde': '\u00D5',
'Otimes': '\u2A37',
'Ouml': '\u00D6',
'OverBracket': '\u23B4',
'OverParenthesis': '\u23DC',
'oS': '\u24C8',
'oacute': '\u00F3',
'oast': '\u229B',
'ocir': '\u229A',
'ocirc': '\u00F4',
'ocy': '\u043E',
'odash': '\u229D',
'odblac': '\u0151',
'odiv': '\u2A38',
'odot': '\u2299',
'odsold': '\u29BC',
'oelig': '\u0153',
'ofcir': '\u29BF',
'ogon': '\u02DB',
'ograve': '\u00F2',
'ogt': '\u29C1',
'ohbar': '\u29B5',
'ohm': '\u03A9',
'oint': '\u222E',
'olarr': '\u21BA',
'olcir': '\u29BE',
'olcross': '\u29BB',
'oline': '\u203E',
'olt': '\u29C0',
'omacr': '\u014D',
'omid': '\u29B6',
'ominus': '\u2296',
'opar': '\u29B7',
'operp': '\u29B9',
'oplus': '\u2295',
'orarr': '\u21BB',
'ord': '\u2A5D',
'order': '\u2134',
'orderof': '\u2134',
'ordf': '\u00AA',
'ordm': '\u00BA',
'origof': '\u22B6',
'oror': '\u2A56',
'orslope': '\u2A57',
'orv': '\u2A5B',
'oslash': '\u00F8',
'otilde': '\u00F5',
'otimes': '\u2297',
'otimesas': '\u2A36',
'ouml': '\u00F6',
'ovbar': '\u233D'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/o.js");
})(MathJax.InputJax.MathML);

79
web/assets/MathJax/unpacked/jax/input/MathML/entities/opf.js vendored Normal file
View File

@@ -0,0 +1,79 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/opf.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Aopf': '\uD835\uDD38',
'Bopf': '\uD835\uDD39',
'Copf': '\u2102',
'Dopf': '\uD835\uDD3B',
'Eopf': '\uD835\uDD3C',
'Fopf': '\uD835\uDD3D',
'Gopf': '\uD835\uDD3E',
'Hopf': '\u210D',
'Iopf': '\uD835\uDD40',
'Jopf': '\uD835\uDD41',
'Kopf': '\uD835\uDD42',
'Lopf': '\uD835\uDD43',
'Mopf': '\uD835\uDD44',
'Nopf': '\u2115',
'Oopf': '\uD835\uDD46',
'Popf': '\u2119',
'Qopf': '\u211A',
'Ropf': '\u211D',
'Sopf': '\uD835\uDD4A',
'Topf': '\uD835\uDD4B',
'Uopf': '\uD835\uDD4C',
'Vopf': '\uD835\uDD4D',
'Wopf': '\uD835\uDD4E',
'Xopf': '\uD835\uDD4F',
'Yopf': '\uD835\uDD50',
'Zopf': '\u2124',
'aopf': '\uD835\uDD52',
'bopf': '\uD835\uDD53',
'copf': '\uD835\uDD54',
'dopf': '\uD835\uDD55',
'eopf': '\uD835\uDD56',
'fopf': '\uD835\uDD57',
'gopf': '\uD835\uDD58',
'hopf': '\uD835\uDD59',
'iopf': '\uD835\uDD5A',
'jopf': '\uD835\uDD5B',
'kopf': '\uD835\uDD5C',
'lopf': '\uD835\uDD5D',
'mopf': '\uD835\uDD5E',
'nopf': '\uD835\uDD5F',
'oopf': '\uD835\uDD60',
'popf': '\uD835\uDD61',
'qopf': '\uD835\uDD62',
'ropf': '\uD835\uDD63',
'sopf': '\uD835\uDD64',
'topf': '\uD835\uDD65',
'uopf': '\uD835\uDD66',
'vopf': '\uD835\uDD67',
'wopf': '\uD835\uDD68',
'xopf': '\uD835\uDD69',
'yopf': '\uD835\uDD6A',
'zopf': '\uD835\uDD6B'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/opf.js");
})(MathJax.InputJax.MathML);

84
web/assets/MathJax/unpacked/jax/input/MathML/entities/p.js vendored Normal file
View File

@@ -0,0 +1,84 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/p.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Pcy': '\u041F',
'Poincareplane': '\u210C',
'Pr': '\u2ABB',
'Prime': '\u2033',
'Proportion': '\u2237',
'par': '\u2225',
'para': '\u00B6',
'parallel': '\u2225',
'parsim': '\u2AF3',
'parsl': '\u2AFD',
'part': '\u2202',
'pcy': '\u043F',
'percnt': '\u0025',
'permil': '\u2030',
'perp': '\u22A5',
'pertenk': '\u2031',
'phmmat': '\u2133',
'phone': '\u260E',
'pitchfork': '\u22D4',
'planck': '\u210F',
'planckh': '\u210E',
'plankv': '\u210F',
'plus': '\u002B',
'plusacir': '\u2A23',
'plusb': '\u229E',
'pluscir': '\u2A22',
'plusdo': '\u2214',
'plusdu': '\u2A25',
'pluse': '\u2A72',
'plusmn': '\u00B1',
'plussim': '\u2A26',
'plustwo': '\u2A27',
'pm': '\u00B1',
'pointint': '\u2A15',
'pound': '\u00A3',
'pr': '\u227A',
'prE': '\u2AB3',
'prcue': '\u227C',
'pre': '\u2AAF',
'prec': '\u227A',
'precapprox': '\u2AB7',
'preccurlyeq': '\u227C',
'preceq': '\u2AAF',
'precsim': '\u227E',
'primes': '\u2119',
'prnE': '\u2AB5',
'prnap': '\u2AB9',
'prnsim': '\u22E8',
'prod': '\u220F',
'profalar': '\u232E',
'profline': '\u2312',
'profsurf': '\u2313',
'prop': '\u221D',
'propto': '\u221D',
'prsim': '\u227E',
'prurel': '\u22B0',
'puncsp': '\u2008'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/p.js");
})(MathJax.InputJax.MathML);

35
web/assets/MathJax/unpacked/jax/input/MathML/entities/q.js vendored Normal file
View File

@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/q.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'QUOT': '\u0022',
'qint': '\u2A0C',
'qprime': '\u2057',
'quaternions': '\u210D',
'quatint': '\u2A16',
'quest': '\u003F',
'questeq': '\u225F',
'quot': '\u0022'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/q.js");
})(MathJax.InputJax.MathML);

138
web/assets/MathJax/unpacked/jax/input/MathML/entities/r.js vendored Normal file
View File

@@ -0,0 +1,138 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/r.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'RBarr': '\u2910',
'REG': '\u00AE',
'Racute': '\u0154',
'Rang': '\u27EB',
'Rarrtl': '\u2916',
'Rcaron': '\u0158',
'Rcedil': '\u0156',
'Rcy': '\u0420',
'ReverseElement': '\u220B',
'ReverseUpEquilibrium': '\u296F',
'Rho': '\u03A1',
'RightArrowBar': '\u21E5',
'RightDoubleBracket': '\u27E7',
'RightDownTeeVector': '\u295D',
'RightDownVectorBar': '\u2955',
'RightTeeVector': '\u295B',
'RightTriangleBar': '\u29D0',
'RightUpDownVector': '\u294F',
'RightUpTeeVector': '\u295C',
'RightUpVectorBar': '\u2954',
'RightVectorBar': '\u2953',
'RoundImplies': '\u2970',
'RuleDelayed': '\u29F4',
'rAarr': '\u21DB',
'rArr': '\u21D2',
'rAtail': '\u291C',
'rBarr': '\u290F',
'rHar': '\u2964',
'race': '\u223D\u0331',
'racute': '\u0155',
'radic': '\u221A',
'raemptyv': '\u29B3',
'rang': '\u27E9',
'rangd': '\u2992',
'range': '\u29A5',
'rangle': '\u27E9',
'raquo': '\u00BB',
'rarr': '\u2192',
'rarrap': '\u2975',
'rarrb': '\u21E5',
'rarrbfs': '\u2920',
'rarrc': '\u2933',
'rarrfs': '\u291E',
'rarrhk': '\u21AA',
'rarrlp': '\u21AC',
'rarrpl': '\u2945',
'rarrsim': '\u2974',
'rarrw': '\u219D',
'ratail': '\u291A',
'ratio': '\u2236',
'rationals': '\u211A',
'rbarr': '\u290D',
'rbbrk': '\u2773',
'rbrke': '\u298C',
'rbrksld': '\u298E',
'rbrkslu': '\u2990',
'rcaron': '\u0159',
'rcedil': '\u0157',
'rceil': '\u2309',
'rcub': '\u007D',
'rcy': '\u0440',
'rdca': '\u2937',
'rdldhar': '\u2969',
'rdquo': '\u201D',
'rdquor': '\u201D',
'rdsh': '\u21B3',
'real': '\u211C',
'realine': '\u211B',
'realpart': '\u211C',
'reals': '\u211D',
'rect': '\u25AD',
'reg': '\u00AE',
'rfisht': '\u297D',
'rfloor': '\u230B',
'rhard': '\u21C1',
'rharu': '\u21C0',
'rharul': '\u296C',
'rightarrow': '\u2192',
'rightarrowtail': '\u21A3',
'rightharpoondown': '\u21C1',
'rightharpoonup': '\u21C0',
'rightleftarrows': '\u21C4',
'rightleftharpoons': '\u21CC',
'rightsquigarrow': '\u219D',
'risingdotseq': '\u2253',
'rlarr': '\u21C4',
'rlhar': '\u21CC',
'rlm': '\u200F',
'rmoustache': '\u23B1',
'rnmid': '\u2AEE',
'roang': '\u27ED',
'roarr': '\u21FE',
'robrk': '\u27E7',
'ropar': '\u2986',
'roplus': '\u2A2E',
'rotimes': '\u2A35',
'rpar': '\u0029',
'rpargt': '\u2994',
'rppolint': '\u2A12',
'rrarr': '\u21C9',
'rsaquo': '\u203A',
'rsh': '\u21B1',
'rsqb': '\u005D',
'rsquo': '\u2019',
'rsquor': '\u2019',
'rthree': '\u22CC',
'rtrie': '\u22B5',
'rtrif': '\u25B8',
'rtriltri': '\u29CE',
'ruluhar': '\u2968',
'rx': '\u211E'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/r.js");
})(MathJax.InputJax.MathML);

170
web/assets/MathJax/unpacked/jax/input/MathML/entities/s.js vendored Normal file
View File

@@ -0,0 +1,170 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/s.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'SHCHcy': '\u0429',
'SHcy': '\u0428',
'SOFTcy': '\u042C',
'Sacute': '\u015A',
'Sc': '\u2ABC',
'Scaron': '\u0160',
'Scedil': '\u015E',
'Scirc': '\u015C',
'Scy': '\u0421',
'ShortDownArrow': '\u2193',
'ShortLeftArrow': '\u2190',
'ShortRightArrow': '\u2192',
'ShortUpArrow': '\u2191',
'Sub': '\u22D0',
'Sup': '\u22D1',
'sacute': '\u015B',
'sbquo': '\u201A',
'sc': '\u227B',
'scE': '\u2AB4',
'scaron': '\u0161',
'sccue': '\u227D',
'sce': '\u2AB0',
'scedil': '\u015F',
'scirc': '\u015D',
'scpolint': '\u2A13',
'scsim': '\u227F',
'scy': '\u0441',
'sdotb': '\u22A1',
'sdote': '\u2A66',
'seArr': '\u21D8',
'searhk': '\u2925',
'searrow': '\u2198',
'semi': '\u003B',
'seswar': '\u2929',
'setminus': '\u2216',
'setmn': '\u2216',
'sext': '\u2736',
'sfrown': '\u2322',
'shchcy': '\u0449',
'shcy': '\u0448',
'shortmid': '\u2223',
'shortparallel': '\u2225',
'shy': '\u00AD',
'sigmaf': '\u03C2',
'sim': '\u223C',
'simdot': '\u2A6A',
'sime': '\u2243',
'simeq': '\u2243',
'simg': '\u2A9E',
'simgE': '\u2AA0',
'siml': '\u2A9D',
'simlE': '\u2A9F',
'simplus': '\u2A24',
'simrarr': '\u2972',
'slarr': '\u2190',
'smallsetminus': '\u2216',
'smashp': '\u2A33',
'smeparsl': '\u29E4',
'smid': '\u2223',
'smt': '\u2AAA',
'smte': '\u2AAC',
'smtes': '\u2AAC\uFE00',
'softcy': '\u044C',
'sol': '\u002F',
'solb': '\u29C4',
'solbar': '\u233F',
'spadesuit': '\u2660',
'spar': '\u2225',
'sqcap': '\u2293',
'sqcaps': '\u2293\uFE00',
'sqcup': '\u2294',
'sqcups': '\u2294\uFE00',
'sqsub': '\u228F',
'sqsube': '\u2291',
'sqsubset': '\u228F',
'sqsubseteq': '\u2291',
'sqsup': '\u2290',
'sqsupe': '\u2292',
'sqsupset': '\u2290',
'sqsupseteq': '\u2292',
'squ': '\u25A1',
'square': '\u25A1',
'squarf': '\u25AA',
'squf': '\u25AA',
'srarr': '\u2192',
'ssetmn': '\u2216',
'ssmile': '\u2323',
'sstarf': '\u22C6',
'star': '\u2606',
'starf': '\u2605',
'straightepsilon': '\u03F5',
'straightphi': '\u03D5',
'strns': '\u00AF',
'subdot': '\u2ABD',
'sube': '\u2286',
'subedot': '\u2AC3',
'submult': '\u2AC1',
'subplus': '\u2ABF',
'subrarr': '\u2979',
'subset': '\u2282',
'subseteq': '\u2286',
'subseteqq': '\u2AC5',
'subsetneq': '\u228A',
'subsetneqq': '\u2ACB',
'subsim': '\u2AC7',
'subsub': '\u2AD5',
'subsup': '\u2AD3',
'succ': '\u227B',
'succapprox': '\u2AB8',
'succcurlyeq': '\u227D',
'succeq': '\u2AB0',
'succnapprox': '\u2ABA',
'succneqq': '\u2AB6',
'succnsim': '\u22E9',
'succsim': '\u227F',
'sum': '\u2211',
'sung': '\u266A',
'sup': '\u2283',
'sup1': '\u00B9',
'sup2': '\u00B2',
'sup3': '\u00B3',
'supdot': '\u2ABE',
'supdsub': '\u2AD8',
'supe': '\u2287',
'supedot': '\u2AC4',
'suphsol': '\u27C9',
'suphsub': '\u2AD7',
'suplarr': '\u297B',
'supmult': '\u2AC2',
'supplus': '\u2AC0',
'supset': '\u2283',
'supseteq': '\u2287',
'supseteqq': '\u2AC6',
'supsetneq': '\u228B',
'supsetneqq': '\u2ACC',
'supsim': '\u2AC8',
'supsub': '\u2AD4',
'supsup': '\u2AD6',
'swArr': '\u21D9',
'swarhk': '\u2926',
'swarrow': '\u2199',
'swnwar': '\u292A',
'szlig': '\u00DF'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/s.js");
})(MathJax.InputJax.MathML);

79
web/assets/MathJax/unpacked/jax/input/MathML/entities/scr.js vendored Normal file
View File

@@ -0,0 +1,79 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/scr.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Ascr': '\uD835\uDC9C',
'Bscr': '\u212C',
'Cscr': '\uD835\uDC9E',
'Dscr': '\uD835\uDC9F',
'Escr': '\u2130',
'Fscr': '\u2131',
'Gscr': '\uD835\uDCA2',
'Hscr': '\u210B',
'Iscr': '\u2110',
'Jscr': '\uD835\uDCA5',
'Kscr': '\uD835\uDCA6',
'Lscr': '\u2112',
'Mscr': '\u2133',
'Nscr': '\uD835\uDCA9',
'Oscr': '\uD835\uDCAA',
'Pscr': '\uD835\uDCAB',
'Qscr': '\uD835\uDCAC',
'Rscr': '\u211B',
'Sscr': '\uD835\uDCAE',
'Tscr': '\uD835\uDCAF',
'Uscr': '\uD835\uDCB0',
'Vscr': '\uD835\uDCB1',
'Wscr': '\uD835\uDCB2',
'Xscr': '\uD835\uDCB3',
'Yscr': '\uD835\uDCB4',
'Zscr': '\uD835\uDCB5',
'ascr': '\uD835\uDCB6',
'bscr': '\uD835\uDCB7',
'cscr': '\uD835\uDCB8',
'dscr': '\uD835\uDCB9',
'escr': '\u212F',
'fscr': '\uD835\uDCBB',
'gscr': '\u210A',
'hscr': '\uD835\uDCBD',
'iscr': '\uD835\uDCBE',
'jscr': '\uD835\uDCBF',
'kscr': '\uD835\uDCC0',
'lscr': '\uD835\uDCC1',
'mscr': '\uD835\uDCC2',
'nscr': '\uD835\uDCC3',
'oscr': '\u2134',
'pscr': '\uD835\uDCC5',
'qscr': '\uD835\uDCC6',
'rscr': '\uD835\uDCC7',
'sscr': '\uD835\uDCC8',
'tscr': '\uD835\uDCC9',
'uscr': '\uD835\uDCCA',
'vscr': '\uD835\uDCCB',
'wscr': '\uD835\uDCCC',
'xscr': '\uD835\uDCCD',
'yscr': '\uD835\uDCCE',
'zscr': '\uD835\uDCCF'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/scr.js");
})(MathJax.InputJax.MathML);

86
web/assets/MathJax/unpacked/jax/input/MathML/entities/t.js vendored Normal file
View File

@@ -0,0 +1,86 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/t.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'THORN': '\u00DE',
'TRADE': '\u2122',
'TSHcy': '\u040B',
'TScy': '\u0426',
'Tab': '\u0009',
'Tau': '\u03A4',
'Tcaron': '\u0164',
'Tcedil': '\u0162',
'Tcy': '\u0422',
'ThickSpace': '\u205F\u200A',
'ThinSpace': '\u2009',
'TripleDot': '\u20DB',
'Tstrok': '\u0166',
'target': '\u2316',
'tbrk': '\u23B4',
'tcaron': '\u0165',
'tcedil': '\u0163',
'tcy': '\u0442',
'tdot': '\u20DB',
'telrec': '\u2315',
'there4': '\u2234',
'therefore': '\u2234',
'thetasym': '\u03D1',
'thickapprox': '\u2248',
'thicksim': '\u223C',
'thinsp': '\u2009',
'thkap': '\u2248',
'thksim': '\u223C',
'thorn': '\u00FE',
'timesb': '\u22A0',
'timesbar': '\u2A31',
'timesd': '\u2A30',
'tint': '\u222D',
'toea': '\u2928',
'top': '\u22A4',
'topbot': '\u2336',
'topcir': '\u2AF1',
'topfork': '\u2ADA',
'tosa': '\u2929',
'tprime': '\u2034',
'trade': '\u2122',
'triangledown': '\u25BF',
'triangleleft': '\u25C3',
'trianglelefteq': '\u22B4',
'triangleright': '\u25B9',
'trianglerighteq': '\u22B5',
'tridot': '\u25EC',
'trie': '\u225C',
'triminus': '\u2A3A',
'triplus': '\u2A39',
'trisb': '\u29CD',
'tritime': '\u2A3B',
'trpezium': '\u23E2',
'tscy': '\u0446',
'tshcy': '\u045B',
'tstrok': '\u0167',
'twixt': '\u226C',
'twoheadleftarrow': '\u219E',
'twoheadrightarrow': '\u21A0'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/t.js");
})(MathJax.InputJax.MathML);

92
web/assets/MathJax/unpacked/jax/input/MathML/entities/u.js vendored Normal file
View File

@@ -0,0 +1,92 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/u.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Uacute': '\u00DA',
'Uarr': '\u219F',
'Uarrocir': '\u2949',
'Ubrcy': '\u040E',
'Ubreve': '\u016C',
'Ucirc': '\u00DB',
'Ucy': '\u0423',
'Udblac': '\u0170',
'Ugrave': '\u00D9',
'Umacr': '\u016A',
'UnderBracket': '\u23B5',
'UnderParenthesis': '\u23DD',
'Uogon': '\u0172',
'UpArrowBar': '\u2912',
'UpArrowDownArrow': '\u21C5',
'UpEquilibrium': '\u296E',
'UpTeeArrow': '\u21A5',
'UpperLeftArrow': '\u2196',
'UpperRightArrow': '\u2197',
'Upsi': '\u03D2',
'Uring': '\u016E',
'Utilde': '\u0168',
'Uuml': '\u00DC',
'uArr': '\u21D1',
'uHar': '\u2963',
'uacute': '\u00FA',
'uarr': '\u2191',
'ubrcy': '\u045E',
'ubreve': '\u016D',
'ucirc': '\u00FB',
'ucy': '\u0443',
'udarr': '\u21C5',
'udblac': '\u0171',
'udhar': '\u296E',
'ufisht': '\u297E',
'ugrave': '\u00F9',
'uharl': '\u21BF',
'uharr': '\u21BE',
'uhblk': '\u2580',
'ulcorn': '\u231C',
'ulcorner': '\u231C',
'ulcrop': '\u230F',
'ultri': '\u25F8',
'umacr': '\u016B',
'uml': '\u00A8',
'uogon': '\u0173',
'uparrow': '\u2191',
'updownarrow': '\u2195',
'upharpoonleft': '\u21BF',
'upharpoonright': '\u21BE',
'uplus': '\u228E',
'upsih': '\u03D2',
'upsilon': '\u03C5',
'urcorn': '\u231D',
'urcorner': '\u231D',
'urcrop': '\u230E',
'uring': '\u016F',
'urtri': '\u25F9',
'utdot': '\u22F0',
'utilde': '\u0169',
'utri': '\u25B5',
'utrif': '\u25B4',
'uuarr': '\u21C8',
'uuml': '\u00FC',
'uwangle': '\u29A7'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/u.js");
})(MathJax.InputJax.MathML);

73
web/assets/MathJax/unpacked/jax/input/MathML/entities/v.js vendored Normal file
View File

@@ -0,0 +1,73 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/v.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'VDash': '\u22AB',
'Vbar': '\u2AEB',
'Vcy': '\u0412',
'Vdashl': '\u2AE6',
'Verbar': '\u2016',
'Vert': '\u2016',
'VerticalLine': '\u007C',
'VerticalSeparator': '\u2758',
'VeryThinSpace': '\u200A',
'vArr': '\u21D5',
'vBar': '\u2AE8',
'vBarv': '\u2AE9',
'vDash': '\u22A8',
'vangrt': '\u299C',
'varepsilon': '\u03F5',
'varkappa': '\u03F0',
'varnothing': '\u2205',
'varphi': '\u03D5',
'varpi': '\u03D6',
'varpropto': '\u221D',
'varr': '\u2195',
'varrho': '\u03F1',
'varsigma': '\u03C2',
'varsubsetneq': '\u228A\uFE00',
'varsubsetneqq': '\u2ACB\uFE00',
'varsupsetneq': '\u228B\uFE00',
'varsupsetneqq': '\u2ACC\uFE00',
'vartheta': '\u03D1',
'vartriangleleft': '\u22B2',
'vartriangleright': '\u22B3',
'vcy': '\u0432',
'vdash': '\u22A2',
'vee': '\u2228',
'veeeq': '\u225A',
'verbar': '\u007C',
'vert': '\u007C',
'vltri': '\u22B2',
'vnsub': '\u2282\u20D2',
'vnsup': '\u2283\u20D2',
'vprop': '\u221D',
'vrtri': '\u22B3',
'vsubnE': '\u2ACB\uFE00',
'vsubne': '\u228A\uFE00',
'vsupnE': '\u2ACC\uFE00',
'vsupne': '\u228B\uFE00',
'vzigzag': '\u299A'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/v.js");
})(MathJax.InputJax.MathML);

35
web/assets/MathJax/unpacked/jax/input/MathML/entities/w.js vendored Normal file
View File

@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/w.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'Wcirc': '\u0174',
'wcirc': '\u0175',
'wedbar': '\u2A5F',
'wedge': '\u2227',
'wedgeq': '\u2259',
'wp': '\u2118',
'wr': '\u2240',
'wreath': '\u2240'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/w.js");
})(MathJax.InputJax.MathML);

47
web/assets/MathJax/unpacked/jax/input/MathML/entities/x.js vendored Normal file
View File

@@ -0,0 +1,47 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/x.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'xcap': '\u22C2',
'xcirc': '\u25EF',
'xcup': '\u22C3',
'xdtri': '\u25BD',
'xhArr': '\u27FA',
'xharr': '\u27F7',
'xlArr': '\u27F8',
'xlarr': '\u27F5',
'xmap': '\u27FC',
'xnis': '\u22FB',
'xodot': '\u2A00',
'xoplus': '\u2A01',
'xotime': '\u2A02',
'xrArr': '\u27F9',
'xrarr': '\u27F6',
'xsqcup': '\u2A06',
'xuplus': '\u2A04',
'xutri': '\u25B3',
'xvee': '\u22C1',
'xwedge': '\u22C0'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/x.js");
})(MathJax.InputJax.MathML);

41
web/assets/MathJax/unpacked/jax/input/MathML/entities/y.js vendored Normal file
View File

@@ -0,0 +1,41 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/y.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'YAcy': '\u042F',
'YIcy': '\u0407',
'YUcy': '\u042E',
'Yacute': '\u00DD',
'Ycirc': '\u0176',
'Ycy': '\u042B',
'Yuml': '\u0178',
'yacute': '\u00FD',
'yacy': '\u044F',
'ycirc': '\u0177',
'ycy': '\u044B',
'yicy': '\u0457',
'yucy': '\u044E',
'yuml': '\u00FF'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/y.js");
})(MathJax.InputJax.MathML);

42
web/assets/MathJax/unpacked/jax/input/MathML/entities/z.js vendored Normal file
View File

@@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/entities/z.js
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MATHML) {
MathJax.Hub.Insert(MATHML.Parse.Entity,{
'ZHcy': '\u0416',
'Zacute': '\u0179',
'Zcaron': '\u017D',
'Zcy': '\u0417',
'Zdot': '\u017B',
'ZeroWidthSpace': '\u200B',
'Zeta': '\u0396',
'zacute': '\u017A',
'zcaron': '\u017E',
'zcy': '\u0437',
'zdot': '\u017C',
'zeetrf': '\u2128',
'zhcy': '\u0436',
'zwj': '\u200D',
'zwnj': '\u200C'
});
MathJax.Ajax.loadComplete(MATHML.entityDir+"/z.js");
})(MathJax.InputJax.MathML);

781
web/assets/MathJax/unpacked/jax/input/MathML/jax.js vendored Normal file
View File

@@ -0,0 +1,781 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/input/MathML/jax.js
*
* Implements the MathML InputJax that reads mathematics in
* MathML format and converts it to the MML ElementJax
* internal format.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function (MATHML,BROWSER) {
var MML;
var _ = function (id) {
return MathJax.Localization._.apply(MathJax.Localization,
[["MathML",id]].concat([].slice.call(arguments,1)))
};
MATHML.Parse = MathJax.Object.Subclass({
Init: function (string,script) {this.Parse(string,script)},
//
// Parse the MathML and check for errors
//
Parse: function (math,script) {
var doc;
if (typeof math !== "string") {doc = math.parentNode} else {
doc = MATHML.ParseXML(this.preProcessMath.call(this,math));
if (doc == null) {MATHML.Error(["ErrorParsingMathML","Error parsing MathML"])}
}
var err = doc.getElementsByTagName("parsererror")[0];
if (err) MATHML.Error(["ParsingError","Error parsing MathML: %1",
err.textContent.replace(/This page.*?errors:|XML Parsing Error: |Below is a rendering of the page.*/g,"")]);
if (doc.childNodes.length !== 1)
{MATHML.Error(["MathMLSingleElement","MathML must be formed by a single element"])}
if (doc.firstChild.nodeName.toLowerCase() === "html") {
var h1 = doc.getElementsByTagName("h1")[0];
if (h1 && h1.textContent === "XML parsing error" && h1.nextSibling)
MATHML.Error(["ParsingError","Error parsing MathML: %1",
String(h1.nextSibling.nodeValue).replace(/fatal parsing error: /,"")]);
}
if (doc.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") !== "math") {
MATHML.Error(["MathMLRootElement",
"MathML must be formed by a <math> element, not %1",
"<"+doc.firstChild.nodeName+">"]);
}
var data = {math:doc.firstChild, script:script};
MATHML.DOMfilterHooks.Execute(data);
this.mml = this.MakeMML(data.math);
},
//
// Convert the MathML structure to the MathJax Element jax structure
//
MakeMML: function (node) {
var CLASS = String(node.getAttribute("class")||""); // make sure CLASS is a string
var mml, type = node.nodeName.toLowerCase().replace(/^[a-z]+:/,"");
var match = (CLASS.match(/(^| )MJX-TeXAtom-([^ ]*)/));
if (match) {
mml = this.TeXAtom(match[2],match[2] === "OP" && !CLASS.match(/MJX-fixedlimits/));
} else if (!(MML[type] && MML[type].isa && MML[type].isa(MML.mbase))) {
MathJax.Hub.signal.Post(["MathML Jax - unknown node type",type]);
return MML.Error(_("UnknownNodeType","Unknown node type: %1",type));
} else {
mml = MML[type]();
}
this.AddAttributes(mml,node); this.CheckClass(mml,mml["class"]);
this.AddChildren(mml,node);
if (MATHML.config.useMathMLspacing) {mml.useMMLspacing = 0x08}
return mml;
},
TeXAtom: function (mclass,movablelimits) {
var mml = MML.TeXAtom().With({texClass:MML.TEXCLASS[mclass]});
if (movablelimits) {mml.movesupsub = mml.movablelimits = true}
return mml;
},
CheckClass: function (mml,CLASS) {
CLASS = (CLASS||"").split(/ /); var NCLASS = [];
for (var i = 0, m = CLASS.length; i < m; i++) {
if (CLASS[i].substr(0,4) === "MJX-") {
if (CLASS[i] === "MJX-arrow") {
// This class was used in former versions of MathJax to attach an
// arrow to the updiagonalstrike notation. For backward
// compatibility, let's continue to accept this case. See issue 481.
if (!mml.notation.match("/"+MML.NOTATION.UPDIAGONALARROW+"/"))
mml.notation += " "+MML.NOTATION.UPDIAGONALARROW;
} else if (CLASS[i] === "MJX-variant") {
mml.variantForm = true;
//
// Variant forms come from AMSsymbols, and it sets up the
// character mappings, so load that if needed.
//
if (!MathJax.Extension["TeX/AMSsymbols"])
{MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/AMSsymbols.js"))}
} else if (CLASS[i].substr(0,11) !== "MJX-TeXAtom") {
mml.mathvariant = CLASS[i].substr(3);
//
// Caligraphic and oldstyle bold are set up in the boldsymbol
// extension, so load it if it isn't already loaded.
//
if (mml.mathvariant === "-tex-caligraphic-bold" ||
mml.mathvariant === "-tex-oldstyle-bold") {
if (!MathJax.Extension["TeX/boldsymbol"])
{MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/boldsymbol.js"))}
}
}
} else {NCLASS.push(CLASS[i])}
}
if (NCLASS.length) {mml["class"] = NCLASS.join(" ")} else {delete mml["class"]}
},
//
// Add the attributes to the mml node
//
AddAttributes: function (mml,node) {
mml.attr = {}; mml.attrNames = [];
for (var i = 0, m = node.attributes.length; i < m; i++) {
var name = node.attributes[i].name;
if (name == "xlink:href") {name = "href"}
if (name.match(/:/)) continue;
if (name.match(/^_moz-math-((column|row)(align|line)|font-style)$/)) continue;
var value = node.attributes[i].value;
value = this.filterAttribute(name,value);
var defaults = (mml.type === "mstyle" ? MML.math.prototype.defaults : mml.defaults);
if (value != null) {
var val = value.toLowerCase();
if (val === "true" || val === "false") {
if (typeof (defaults[name]) === "boolean" || defaults[name] === MML.INHERIT ||
mml.type === "math" || mml.type === "mstyle" ||
(defaults[name] === MML.AUTO &&
(mml.defaultDef == null || typeof(mml.defaultDef[name]) === "boolean"))) {
value = (val === "true");
}
}
if (defaults[name] != null || MML.copyAttributes[name])
{mml[name] = value} else {mml.attr[name] = value}
mml.attrNames.push(name);
}
}
},
filterAttribute: function (name,value) {return value}, // safe mode overrides this
//
// Create the children for the mml node
//
AddChildren: function (mml,node) {
for (var i = 0, m = node.childNodes.length; i < m; i++) {
var child = node.childNodes[i];
if (child.nodeName === "#comment") continue;
if (child.nodeName === "#text") {
if ((mml.isToken || mml.isChars) && !mml.mmlSelfClosing) {
var text = child.nodeValue;
if (mml.isToken) {
text = text.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity);
text = this.trimSpace(text);
}
mml.Append(MML.chars(text));
} else if (child.nodeValue.match(/\S/)) {
MATHML.Error(["UnexpectedTextNode",
"Unexpected text node: %1","'"+child.nodeValue+"'"]);
}
} else if (mml.type === "annotation-xml") {
mml.Append(MML.xml(child));
} else {
var cmml = this.MakeMML(child); mml.Append(cmml);
if (cmml.mmlSelfClosing && cmml.data.length)
{mml.Append.apply(mml,cmml.data); cmml.data = []}
}
}
if (mml.type === "mrow" && mml.data.length >= 2) {
var first = mml.data[0], last = mml.data[mml.data.length-1];
if (first.type === "mo" && first.Get("fence") &&
last.type === "mo" && last.Get("fence")) {
if (first.data[0]) {mml.open = first.data.join("")}
if (last.data[0]) {mml.close = last.data.join("")}
}
}
},
//
// Clean Up the <math> source to prepare for XML parsing
//
preProcessMath: function (math) {
if (math.match(/^<[a-z]+:/i) && !math.match(/^<[^<>]* xmlns:/)) {
math = math.replace(/^<([a-z]+)(:math)/i,'<$1$2 xmlns:$1="http://www.w3.org/1998/Math/MathML"')
}
// HTML5 removes xmlns: namespaces, so put them back for XML
var match = math.match(/^(<math( ('.*?'|".*?"|[^>])+)>)/i);
if (match && match[2].match(/ (?!xmlns=)[a-z]+=\"http:/i)) {
math = match[1].replace(/ (?!xmlns=)([a-z]+=(['"])http:.*?\2)/ig," xmlns:$1 $1") +
math.substr(match[0].length);
}
if (math.match(/^<math[ >]/i) && !math.match(/^<[^<>]* xmlns=/)) {
// append the MathML namespace
math = math.replace(/^<(math)/i,'<math xmlns="http://www.w3.org/1998/Math/MathML"')
}
math = math.replace(/^\s*(?:\/\/)?<!(--)?\[CDATA\[((.|\n)*)(\/\/)?\]\]\1>\s*$/,"$2");
return math.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity);
},
//
// Remove attribute whitespace
//
trimSpace: function (string) {
return string.replace(/[\t\n\r]/g," ") // whitespace to spaces
.replace(/^ +/,"") // initial whitespace
.replace(/ +$/,"") // trailing whitespace
.replace(/ +/g," "); // internal multiple whitespace
},
//
// Replace a named entity by its value
// (look up from external files if necessary)
//
replaceEntity: function (match,entity) {
if (entity.match(/^(lt|amp|quot)$/)) {return match} // these mess up attribute parsing
if (MATHML.Parse.Entity[entity]) {return MATHML.Parse.Entity[entity]}
var file = entity.charAt(0).toLowerCase();
var font = entity.match(/^[a-zA-Z](fr|scr|opf)$/);
if (font) {file = font[1]}
if (!MATHML.Parse.loaded[file]) {
MATHML.Parse.loaded[file] = true;
MathJax.Hub.RestartAfter(MathJax.Ajax.Require(MATHML.entityDir+"/"+file+".js"));
}
return match;
}
}, {
loaded: [] // the entity files that are loaded
});
/************************************************************************/
MATHML.Augment({
sourceMenuTitle: /*_(MathMenu)*/ ["OriginalMathML","Original MathML"],
prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML string before processing MathML
DOMfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML DOM before processing
postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on internal jax format after processing MathML
Translate: function (script) {
if (!this.ParseXML) {this.ParseXML = this.createParser()}
var mml, math, data = {script:script};
if (script.firstChild &&
script.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") === "math") {
data.math = script.firstChild;
} else {
math = MathJax.HTML.getScript(script);
if (BROWSER.isMSIE) {math = math.replace(/(&nbsp;)+$/,"")}
data.math = math;
}
var callback = this.prefilterHooks.Execute(data); if (callback) return callback;
math = data.math;
try {
mml = MATHML.Parse(math,script).mml;
} catch(err) {
if (!err.mathmlError) {throw err}
mml = this.formatError(err,math,script);
}
data.math = MML(mml);
return this.postfilterHooks.Execute(data) || data.math;
},
prefilterMath: function (math,script) {return math},
prefilterMathML: function (math,script) {return math},
formatError: function (err,math,script) {
var message = err.message.replace(/\n.*/,"");
MathJax.Hub.signal.Post(["MathML Jax - parse error",message,math,script]);
return MML.Error(message);
},
Error: function (message) {
//
// Translate message if it is ["id","message",args]
//
if (MathJax.Object.isArray(message)) {message = _.apply(_,message)}
throw MathJax.Hub.Insert(Error(message),{mathmlError: true});
},
//
// Parsers for various forms (DOMParser, Windows ActiveX object, other)
//
parseDOM: function (string) {return this.parser.parseFromString(string,"text/xml")},
parseMS: function (string) {return (this.parser.loadXML(string) ? this.parser : null)},
parseDIV: function (string) {
this.div.innerHTML =
"<div>"+string.replace(/<([a-z]+)([^>]*)\/>/g,"<$1$2></$1>")+"</div>";
var doc = this.div.firstChild;
this.div.innerHTML = "";
return doc;
},
parseError: function (string) {return null},
createMSParser: function() {
var parser = null;
var xml = ["MSXML2.DOMDocument.6.0","MSXML2.DOMDocument.5.0",
"MSXML2.DOMDocument.4.0","MSXML2.DOMDocument.3.0",
"MSXML2.DOMDocument.2.0","Microsoft.XMLDOM"];
for (var i = 0, m = xml.length; i < m && !parser; i++) {
try {
parser = new ActiveXObject(xml[i])
} catch (err) {}
}
return parser;
},
//
// Create the parser using a DOMParser, or other fallback method
//
createParser: function () {
if (window.DOMParser) {
this.parser = new DOMParser();
return(this.parseDOM);
} else if (window.ActiveXObject) {
this.parser = this.createMSParser();
if (!this.parser) {
MathJax.Localization.Try(this.parserCreationError);
return(this.parseError);
}
this.parser.async = false;
return(this.parseMS);
}
this.div = MathJax.Hub.Insert(document.createElement("div"),{
style:{visibility:"hidden", overflow:"hidden", height:"1px",
position:"absolute", top:0}
});
if (!document.body.firstChild) {document.body.appendChild(this.div)}
else {document.body.insertBefore(this.div,document.body.firstChild)}
return(this.parseDIV);
},
parserCreationError: function () {
alert(_("CantCreateXMLParser",
"MathJax can't create an XML parser for MathML. Check that\n"+
"the 'Script ActiveX controls marked safe for scripting' security\n"+
"setting is enabled (use the Internet Options item in the Tools\n"+
"menu, and select the Security panel, then press the Custom Level\n"+
"button to check this).\n\n"+
"MathML equations will not be able to be processed by MathJax."));
},
//
// Initialize the parser object (whichever type is used)
//
Startup: function () {
MML = MathJax.ElementJax.mml;
MML.mspace.Augment({mmlSelfClosing: true});
MML.none.Augment({mmlSelfClosing: true});
MML.mprescripts.Augment({mmlSelfClosing:true});
MML.maligngroup.Augment({mmlSelfClosing:true});
MML.malignmark.Augment({mmlSelfClosing:true});
}
});
//
// Add the default pre-filter (for backward compatibility)
//
MATHML.prefilterHooks.Add(function (data) {
data.math = (typeof(data.math) === "string" ?
MATHML.prefilterMath(data.math,data.script) :
MATHML.prefilterMathML(data.math,data.script));
});
MATHML.Parse.Entity = {
ApplyFunction: '\u2061',
Backslash: '\u2216',
Because: '\u2235',
Breve: '\u02D8',
Cap: '\u22D2',
CenterDot: '\u00B7',
CircleDot: '\u2299',
CircleMinus: '\u2296',
CirclePlus: '\u2295',
CircleTimes: '\u2297',
Congruent: '\u2261',
ContourIntegral: '\u222E',
Coproduct: '\u2210',
Cross: '\u2A2F',
Cup: '\u22D3',
CupCap: '\u224D',
Dagger: '\u2021',
Del: '\u2207',
Delta: '\u0394',
Diamond: '\u22C4',
DifferentialD: '\u2146',
DotEqual: '\u2250',
DoubleDot: '\u00A8',
DoubleRightTee: '\u22A8',
DoubleVerticalBar: '\u2225',
DownArrow: '\u2193',
DownLeftVector: '\u21BD',
DownRightVector: '\u21C1',
DownTee: '\u22A4',
Downarrow: '\u21D3',
Element: '\u2208',
EqualTilde: '\u2242',
Equilibrium: '\u21CC',
Exists: '\u2203',
ExponentialE: '\u2147',
FilledVerySmallSquare: '\u25AA',
ForAll: '\u2200',
Gamma: '\u0393',
Gg: '\u22D9',
GreaterEqual: '\u2265',
GreaterEqualLess: '\u22DB',
GreaterFullEqual: '\u2267',
GreaterLess: '\u2277',
GreaterSlantEqual: '\u2A7E',
GreaterTilde: '\u2273',
Hacek: '\u02C7',
Hat: '\u005E',
HumpDownHump: '\u224E',
HumpEqual: '\u224F',
Im: '\u2111',
ImaginaryI: '\u2148',
Integral: '\u222B',
Intersection: '\u22C2',
InvisibleComma: '\u2063',
InvisibleTimes: '\u2062',
Lambda: '\u039B',
Larr: '\u219E',
LeftAngleBracket: '\u27E8',
LeftArrow: '\u2190',
LeftArrowRightArrow: '\u21C6',
LeftCeiling: '\u2308',
LeftDownVector: '\u21C3',
LeftFloor: '\u230A',
LeftRightArrow: '\u2194',
LeftTee: '\u22A3',
LeftTriangle: '\u22B2',
LeftTriangleEqual: '\u22B4',
LeftUpVector: '\u21BF',
LeftVector: '\u21BC',
Leftarrow: '\u21D0',
Leftrightarrow: '\u21D4',
LessEqualGreater: '\u22DA',
LessFullEqual: '\u2266',
LessGreater: '\u2276',
LessSlantEqual: '\u2A7D',
LessTilde: '\u2272',
Ll: '\u22D8',
Lleftarrow: '\u21DA',
LongLeftArrow: '\u27F5',
LongLeftRightArrow: '\u27F7',
LongRightArrow: '\u27F6',
Longleftarrow: '\u27F8',
Longleftrightarrow: '\u27FA',
Longrightarrow: '\u27F9',
Lsh: '\u21B0',
MinusPlus: '\u2213',
NestedGreaterGreater: '\u226B',
NestedLessLess: '\u226A',
NotDoubleVerticalBar: '\u2226',
NotElement: '\u2209',
NotEqual: '\u2260',
NotExists: '\u2204',
NotGreater: '\u226F',
NotGreaterEqual: '\u2271',
NotLeftTriangle: '\u22EA',
NotLeftTriangleEqual: '\u22EC',
NotLess: '\u226E',
NotLessEqual: '\u2270',
NotPrecedes: '\u2280',
NotPrecedesSlantEqual: '\u22E0',
NotRightTriangle: '\u22EB',
NotRightTriangleEqual: '\u22ED',
NotSubsetEqual: '\u2288',
NotSucceeds: '\u2281',
NotSucceedsSlantEqual: '\u22E1',
NotSupersetEqual: '\u2289',
NotTilde: '\u2241',
NotVerticalBar: '\u2224',
Omega: '\u03A9',
OverBar: '\u203E',
OverBrace: '\u23DE',
PartialD: '\u2202',
Phi: '\u03A6',
Pi: '\u03A0',
PlusMinus: '\u00B1',
Precedes: '\u227A',
PrecedesEqual: '\u2AAF',
PrecedesSlantEqual: '\u227C',
PrecedesTilde: '\u227E',
Product: '\u220F',
Proportional: '\u221D',
Psi: '\u03A8',
Rarr: '\u21A0',
Re: '\u211C',
ReverseEquilibrium: '\u21CB',
RightAngleBracket: '\u27E9',
RightArrow: '\u2192',
RightArrowLeftArrow: '\u21C4',
RightCeiling: '\u2309',
RightDownVector: '\u21C2',
RightFloor: '\u230B',
RightTee: '\u22A2',
RightTeeArrow: '\u21A6',
RightTriangle: '\u22B3',
RightTriangleEqual: '\u22B5',
RightUpVector: '\u21BE',
RightVector: '\u21C0',
Rightarrow: '\u21D2',
Rrightarrow: '\u21DB',
Rsh: '\u21B1',
Sigma: '\u03A3',
SmallCircle: '\u2218',
Sqrt: '\u221A',
Square: '\u25A1',
SquareIntersection: '\u2293',
SquareSubset: '\u228F',
SquareSubsetEqual: '\u2291',
SquareSuperset: '\u2290',
SquareSupersetEqual: '\u2292',
SquareUnion: '\u2294',
Star: '\u22C6',
Subset: '\u22D0',
SubsetEqual: '\u2286',
Succeeds: '\u227B',
SucceedsEqual: '\u2AB0',
SucceedsSlantEqual: '\u227D',
SucceedsTilde: '\u227F',
SuchThat: '\u220B',
Sum: '\u2211',
Superset: '\u2283',
SupersetEqual: '\u2287',
Supset: '\u22D1',
Therefore: '\u2234',
Theta: '\u0398',
Tilde: '\u223C',
TildeEqual: '\u2243',
TildeFullEqual: '\u2245',
TildeTilde: '\u2248',
UnderBar: '\u005F',
UnderBrace: '\u23DF',
Union: '\u22C3',
UnionPlus: '\u228E',
UpArrow: '\u2191',
UpDownArrow: '\u2195',
UpTee: '\u22A5',
Uparrow: '\u21D1',
Updownarrow: '\u21D5',
Upsilon: '\u03A5',
Vdash: '\u22A9',
Vee: '\u22C1',
VerticalBar: '\u2223',
VerticalTilde: '\u2240',
Vvdash: '\u22AA',
Wedge: '\u22C0',
Xi: '\u039E',
acute: '\u00B4',
aleph: '\u2135',
alpha: '\u03B1',
amalg: '\u2A3F',
and: '\u2227',
ang: '\u2220',
angmsd: '\u2221',
angsph: '\u2222',
ape: '\u224A',
backprime: '\u2035',
backsim: '\u223D',
backsimeq: '\u22CD',
beta: '\u03B2',
beth: '\u2136',
between: '\u226C',
bigcirc: '\u25EF',
bigodot: '\u2A00',
bigoplus: '\u2A01',
bigotimes: '\u2A02',
bigsqcup: '\u2A06',
bigstar: '\u2605',
bigtriangledown: '\u25BD',
bigtriangleup: '\u25B3',
biguplus: '\u2A04',
blacklozenge: '\u29EB',
blacktriangle: '\u25B4',
blacktriangledown: '\u25BE',
blacktriangleleft: '\u25C2',
bowtie: '\u22C8',
boxdl: '\u2510',
boxdr: '\u250C',
boxminus: '\u229F',
boxplus: '\u229E',
boxtimes: '\u22A0',
boxul: '\u2518',
boxur: '\u2514',
bsol: '\u005C',
bull: '\u2022',
cap: '\u2229',
check: '\u2713',
chi: '\u03C7',
circ: '\u02C6',
circeq: '\u2257',
circlearrowleft: '\u21BA',
circlearrowright: '\u21BB',
circledR: '\u00AE',
circledS: '\u24C8',
circledast: '\u229B',
circledcirc: '\u229A',
circleddash: '\u229D',
clubs: '\u2663',
colon: '\u003A',
comp: '\u2201',
ctdot: '\u22EF',
cuepr: '\u22DE',
cuesc: '\u22DF',
cularr: '\u21B6',
cup: '\u222A',
curarr: '\u21B7',
curlyvee: '\u22CE',
curlywedge: '\u22CF',
dagger: '\u2020',
daleth: '\u2138',
ddarr: '\u21CA',
deg: '\u00B0',
delta: '\u03B4',
digamma: '\u03DD',
div: '\u00F7',
divideontimes: '\u22C7',
dot: '\u02D9',
doteqdot: '\u2251',
dotplus: '\u2214',
dotsquare: '\u22A1',
dtdot: '\u22F1',
ecir: '\u2256',
efDot: '\u2252',
egs: '\u2A96',
ell: '\u2113',
els: '\u2A95',
empty: '\u2205',
epsi: '\u03B5',
epsiv: '\u03F5',
erDot: '\u2253',
eta: '\u03B7',
eth: '\u00F0',
flat: '\u266D',
fork: '\u22D4',
frown: '\u2322',
gEl: '\u2A8C',
gamma: '\u03B3',
gap: '\u2A86',
gimel: '\u2137',
gnE: '\u2269',
gnap: '\u2A8A',
gne: '\u2A88',
gnsim: '\u22E7',
gt: '\u003E',
gtdot: '\u22D7',
harrw: '\u21AD',
hbar: '\u210F',
hellip: '\u2026',
hookleftarrow: '\u21A9',
hookrightarrow: '\u21AA',
imath: '\u0131',
infin: '\u221E',
intcal: '\u22BA',
iota: '\u03B9',
jmath: '\u0237',
kappa: '\u03BA',
kappav: '\u03F0',
lEg: '\u2A8B',
lambda: '\u03BB',
lap: '\u2A85',
larrlp: '\u21AB',
larrtl: '\u21A2',
lbrace: '\u007B',
lbrack: '\u005B',
le: '\u2264',
leftleftarrows: '\u21C7',
leftthreetimes: '\u22CB',
lessdot: '\u22D6',
lmoust: '\u23B0',
lnE: '\u2268',
lnap: '\u2A89',
lne: '\u2A87',
lnsim: '\u22E6',
longmapsto: '\u27FC',
looparrowright: '\u21AC',
lowast: '\u2217',
loz: '\u25CA',
lt: '\u003C',
ltimes: '\u22C9',
ltri: '\u25C3',
macr: '\u00AF',
malt: '\u2720',
mho: '\u2127',
mu: '\u03BC',
multimap: '\u22B8',
nLeftarrow: '\u21CD',
nLeftrightarrow: '\u21CE',
nRightarrow: '\u21CF',
nVDash: '\u22AF',
nVdash: '\u22AE',
natur: '\u266E',
nearr: '\u2197',
nharr: '\u21AE',
nlarr: '\u219A',
not: '\u00AC',
nrarr: '\u219B',
nu: '\u03BD',
nvDash: '\u22AD',
nvdash: '\u22AC',
nwarr: '\u2196',
omega: '\u03C9',
omicron: '\u03BF',
or: '\u2228',
osol: '\u2298',
period: '\u002E',
phi: '\u03C6',
phiv: '\u03D5',
pi: '\u03C0',
piv: '\u03D6',
prap: '\u2AB7',
precnapprox: '\u2AB9',
precneqq: '\u2AB5',
precnsim: '\u22E8',
prime: '\u2032',
psi: '\u03C8',
rarrtl: '\u21A3',
rbrace: '\u007D',
rbrack: '\u005D',
rho: '\u03C1',
rhov: '\u03F1',
rightrightarrows: '\u21C9',
rightthreetimes: '\u22CC',
ring: '\u02DA',
rmoust: '\u23B1',
rtimes: '\u22CA',
rtri: '\u25B9',
scap: '\u2AB8',
scnE: '\u2AB6',
scnap: '\u2ABA',
scnsim: '\u22E9',
sdot: '\u22C5',
searr: '\u2198',
sect: '\u00A7',
sharp: '\u266F',
sigma: '\u03C3',
sigmav: '\u03C2',
simne: '\u2246',
smile: '\u2323',
spades: '\u2660',
sub: '\u2282',
subE: '\u2AC5',
subnE: '\u2ACB',
subne: '\u228A',
supE: '\u2AC6',
supnE: '\u2ACC',
supne: '\u228B',
swarr: '\u2199',
tau: '\u03C4',
theta: '\u03B8',
thetav: '\u03D1',
tilde: '\u02DC',
times: '\u00D7',
triangle: '\u25B5',
triangleq: '\u225C',
upsi: '\u03C5',
upuparrows: '\u21C8',
veebar: '\u22BB',
vellip: '\u22EE',
weierp: '\u2118',
xi: '\u03BE',
yen: '\u00A5',
zeta: '\u03B6',
zigrarr: '\u21DD'
};
MATHML.loadComplete("jax.js");
})(MathJax.InputJax.MathML,MathJax.Hub.Browser);

54
web/assets/MathJax/unpacked/jax/input/TeX/config.js vendored Normal file
View File

@@ -0,0 +1,54 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/input/TeX/config.js
*
* Initializes the TeX InputJax (the main definition is in
* MathJax/jax/input/TeX/jax.js, which is loaded when needed).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.InputJax.TeX = MathJax.InputJax({
id: "TeX",
version: "2.7.8",
directory: MathJax.InputJax.directory + "/TeX",
extensionDir: MathJax.InputJax.extensionDir + "/TeX",
config: {
TagSide: "right",
TagIndent: "0.8em",
MultLineWidth: "85%",
equationNumbers: {
autoNumber: "none", // "AMS" for standard AMS numbering,
// or "all" for all displayed equations
formatNumber: function (n) {return n},
formatTag: function (n) {return '('+n+')'},
formatID: function (n) {return 'mjx-eqn-'+String(n).replace(/\s/g,"_")},
formatURL: function (id,base) {return base+'#'+encodeURIComponent(id)},
useLabelIds: true
}
},
resetEquationNumbers: function () {} // filled in by AMSmath extension
});
MathJax.InputJax.TeX.Register("math/tex");
MathJax.InputJax.TeX.loadComplete("config.js");

2371
web/assets/MathJax/unpacked/jax/input/TeX/jax.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

60
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/annotation-xml.js vendored Normal file
View File

@@ -0,0 +1,60 @@
/* -*- 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.8";
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");
});

178
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/maction.js vendored Normal file
View File

@@ -0,0 +1,178 @@
/* -*- 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.8";
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");
});

330
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/menclose.js vendored Normal file
View File

@@ -0,0 +1,330 @@
/* -*- 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.8";
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");
});

94
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/mglyph.js vendored Normal file
View File

@@ -0,0 +1,94 @@
/* -*- 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.8";
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");
});

296
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/mmultiscripts.js vendored Normal file
View File

@@ -0,0 +1,296 @@
/* -*- 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.8";
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");
});

73
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/ms.js vendored Normal file
View File

@@ -0,0 +1,73 @@
/* -*- 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.8";
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");
});

602
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/mtable.js vendored Normal file
View File

@@ -0,0 +1,602 @@
/* -*- 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.8";
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");
});

797
web/assets/MathJax/unpacked/jax/output/CommonHTML/autoload/multiline.js vendored Normal file
View File

@@ -0,0 +1,797 @@
/* -*- 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.8";
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");
});

64
web/assets/MathJax/unpacked/jax/output/CommonHTML/config.js vendored Normal file
View File

@@ -0,0 +1,64 @@
/* -*- 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.8",
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");

289
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/AMS-Regular.js vendored Normal file
View File

@@ -0,0 +1,289 @@
/*************************************************************
*
* 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);

99
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Caligraphic-Bold.js vendored Normal file
View File

@@ -0,0 +1,99 @@
/*************************************************************
*
* 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);

125
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Fraktur-Bold.js vendored Normal file
View File

@@ -0,0 +1,125 @@
/*************************************************************
*
* 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);

125
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Fraktur-Regular.js vendored Normal file
View File

@@ -0,0 +1,125 @@
/*************************************************************
*
* 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);

208
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Main-Bold.js vendored Normal file
View File

@@ -0,0 +1,208 @@
/*************************************************************
*
* 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);

208
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Math-BoldItalic.js vendored Normal file
View File

@@ -0,0 +1,208 @@
/*************************************************************
*
* 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);

152
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/SansSerif-Bold.js vendored Normal file
View File

@@ -0,0 +1,152 @@
/*************************************************************
*
* 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);

152
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/SansSerif-Italic.js vendored Normal file
View File

@@ -0,0 +1,152 @@
/*************************************************************
*
* 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);

152
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/SansSerif-Regular.js vendored Normal file
View File

@@ -0,0 +1,152 @@
/*************************************************************
*
* 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);

88
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Script-Regular.js vendored Normal file
View File

@@ -0,0 +1,88 @@
/*************************************************************
*
* 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);

155
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/Typewriter-Regular.js vendored Normal file
View File

@@ -0,0 +1,155 @@
/*************************************************************
*
* 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);

240
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/fontdata-extra.js vendored Normal file
View File

@@ -0,0 +1,240 @@
/* -*- 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.8";
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);

1784
web/assets/MathJax/unpacked/jax/output/CommonHTML/fonts/TeX/fontdata.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2843
web/assets/MathJax/unpacked/jax/output/CommonHTML/jax.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

63
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/annotation-xml.js vendored Normal file
View File

@@ -0,0 +1,63 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/annotation-xm;l.js
*
* Implements the HTML-CSS output for <annotation-xml> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-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("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
MML["annotation-xml"].Augment({
toHTML: function (span) {
span = this.HTMLhandleSize(this.HTMLcreateSpan(span));
var encoding = this.Get("encoding");
for (var i = 0, m = this.data.length; i < m; i++)
{this.data[i].toHTML(span,encoding)}
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
return span;
},
HTMLgetScale: function () {
return this.SUPER(arguments).HTMLgetScale.call(this) / HTMLCSS.scale;
}
});
MML.xml.Augment({
toHTML: function (span,encoding) {
for (var i = 0, m = this.data.length; i < m; i++)
{span.appendChild(this.data[i].cloneNode(true))}
var bbox = span.bbox; span.bbox = null;
bbox.rw = bbox.w = HTMLCSS.getW(span);
var HD = HTMLCSS.getHD(span);
bbox.h = HD.h; bbox.d = HD.d;
span.bbox = bbox;
}
});
MathJax.Hub.Startup.signal.Post("HTML-CSS annotation-xml Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/annotation-xml.js");
});

229
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/maction.js vendored Normal file
View File

@@ -0,0 +1,229 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/maction.js
*
* Implements the HTML-CSS output for <maction> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
var currentTip, hover, clear;
//
// Add configuration for tooltips
//
var CONFIG = HTMLCSS.config.tooltip = MathJax.Hub.Insert({
delayPost: 600, delayClear: 600,
offsetX: 10, offsetY: 5
},HTMLCSS.config.tooltip||{});
MML.maction.Augment({
HTMLtooltip: HTMLCSS.addElement(document.body,"div",{id:"MathJax_Tooltip"}),
toHTML: function (span,HW,D) {
var selected = this.selected();
if (selected.type == "null") {
span = this.HTMLcreateSpan(span);
span.bbox = this.HTMLzeroBBox();
return span;
}
span = this.HTMLcreateSpan(span); span.bbox = null;
span.scale = this.HTMLgetScale();
var box = selected.toHTML(span);
if (D != null) {HTMLCSS.Remeasured(selected.HTMLstretchV(span,HW,D),span)}
else if (HW != null) {
HTMLCSS.Remeasured(selected.HTMLstretchH(span,HW),span)
} else {HTMLCSS.Measured(box,span)}
this.HTMLhandleHitBox(span);
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
return span;
},
HTMLhandleHitBox: function (span,postfix) {
var frame;
if (HTMLCSS.msieHitBoxBug) {
// margin-left doesn't work on inline-block elements in IE, so put it in a SPAN
var box = HTMLCSS.addElement(span,"span",{isMathJax:true});
frame = HTMLCSS.createFrame(box,span.bbox.h,span.bbox.d,span.bbox.w,0,"none");
span.insertBefore(box,span.firstChild); // move below the content
box.style.marginRight = HTMLCSS.Em(-span.bbox.w);
if (HTMLCSS.msieInlineBlockAlignBug)
{frame.style.verticalAlign = HTMLCSS.Em(HTMLCSS.getHD(span).d-span.bbox.d)}
} else {
frame = HTMLCSS.createFrame(span,span.bbox.h,span.bbox.d,span.bbox.w,0,"none");
span.insertBefore(frame,span.firstChild); // move below the content
frame.style.marginRight = HTMLCSS.Em(-span.bbox.w);
}
frame.className = "MathJax_HitBox";
frame.id = "MathJax-HitBox-" + this.spanID + (postfix||"") + HTMLCSS.idPostfix;
var type = this.Get("actiontype");
if (this.HTMLaction[type]) {this.HTMLaction[type].call(this,span,frame,this.Get("selection"))}
},
HTMLstretchH: MML.mbase.HTMLstretchH,
HTMLstretchV: MML.mbase.HTMLstretchV,
//
// Implementations for the various actions
//
HTMLaction: {
toggle: function (span,frame,selection) {
this.selection = selection;
span.onclick = MathJax.Callback(["HTMLclick",this]);
frame.style.cursor = span.childNodes[1].style.cursor = "pointer";
},
statusline: function (span,frame,selection) {
span.onmouseover = MathJax.Callback(["HTMLsetStatus",this]);
span.onmouseout = MathJax.Callback(["HTMLclearStatus",this]);
span.onmouseover.autoReset = span.onmouseout.autoReset = true;
frame.style.cursor = span.childNodes[1].style.cursor = "default";
},
tooltip: function(span,frame,selection) {
if (this.data[1] && this.data[1].isToken) {
span.title = span.alt = this.data[1].data.join("");
} else {
span.onmouseover = MathJax.Callback(["HTMLtooltipOver",this]);
span.onmouseout = MathJax.Callback(["HTMLtooltipOut",this]);
span.onmouseover.autoReset = span.onmouseout.autoReset = true;
}
frame.style.cursor = span.childNodes[1].style.cursor = "default";
}
},
//
// Handle a click on the maction element
// (remove the original rendering and rerender)
//
HTMLclick: function (event) {
this.selection++;
if (this.selection > this.data.length) {this.selection = 1}
var math = this; while (math.type !== "math") {math = math.inherit}
var jax = MathJax.Hub.getJaxFor(math.inputID), 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
//
HTMLsetStatus: 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());
},
HTMLclearStatus: function (event) {
if (this.messageID) {MathJax.Message.Clear(this.messageID,0)}
delete this.messageID;
},
//
// Handle tooltips
//
HTMLtooltipOver: function (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(["HTMLtooltipPost",this,x+CONFIG.offsetX,y+CONFIG.offsetY])
hover = setTimeout(callback,CONFIG.delayPost);
},
HTMLtooltipOut: function (event) {
if (hover) {clearTimeout(hover); hover = null}
if (clear) {clearTimeout(clear)}
var callback = MathJax.Callback(["HTMLtooltipClear",this,80]);
clear = setTimeout(callback,CONFIG.delayClear);
},
HTMLtooltipPost: function (x,y) {
hover = null; if (clear) {clearTimeout(clear); clear = null}
var tip = this.HTMLtooltip;
tip.style.display = "block"; tip.style.opacity = "";
tip.style.filter = HTMLCSS.config.styles["#MathJax_Tooltip"].filter;
if (this === currentTip) return;
tip.style.left = x+"px"; tip.style.top = y+"px";
tip.innerHTML = '<span class="MathJax"><nobr></nobr></span>';
//
// get em sizes (taken from HTMLCSS.preTranslate)
//
var emex = tip.insertBefore(HTMLCSS.TestSpan.cloneNode(true),tip.firstChild);
var ex = emex.childNodes[1].offsetHeight/60,
em = emex.childNodes[2].offsetHeight/60;
emex.parentNode.removeChild(emex);
HTMLCSS.em = HTMLCSS.outerEm = MML.mbase.prototype.em = em;
var scale = Math.floor(Math.max(HTMLCSS.config.minScaleAdjust/100,(ex/HTMLCSS.TeX.x_height)/em) * HTMLCSS.config.scale);
tip.firstChild.style.fontSize = scale+"%";
var stack = HTMLCSS.createStack(tip.firstChild.firstChild);
var box = HTMLCSS.createBox(stack);
try {HTMLCSS.Measured(this.data[1].toHTML(box),box)} catch(err) {
if (!err.restart) {throw err}
tip.style.display = "none";
MathJax.Callback.After(["HTMLtooltipPost",this,x,y],err.restart);
return;
}
HTMLCSS.placeBox(box,0,0);
HTMLCSS.createRule(tip.firstChild.firstChild,box.bbox.h,box.bbox.d,0);
currentTip = this;
},
HTMLtooltipClear: function (n) {
var tip = this.HTMLtooltip;
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(["HTMLtooltipClear",this,n-20]),50);
}
}
});
//
// Do browser-specific setup
//
MathJax.Hub.Browser.Select({
MSIE: function (browser) {
HTMLCSS.msieHitBoxBug = true;
}
});
MathJax.Hub.Startup.signal.Post("HTML-CSS maction Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/maction.js");
});

339
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/menclose.js vendored Normal file
View File

@@ -0,0 +1,339 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/menclose.js
*
* Implements the HTML-CSS output for <menclose> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
var SVGNS = "http://www.w3.org/2000/svg";
var VMLNS = "urn:schemas-microsoft-com:vml";
var vmlns = "mjxvml";
MML.menclose.Augment({
toHTML: function (span) {
var values = this.getValues("notation","thickness","padding","mathcolor","color");
if (values.color && !this.mathcolor) {values.mathcolor = values.color}
if (values.thickness == null) {values.thickness = ".075em"}
if (values.padding == null) {values.padding = ".2em"}
span = this.HTMLcreateSpan(span);
var mu = this.HTMLgetMu(span), scale = this.HTMLgetScale();
var p = HTMLCSS.length2em(values.padding,mu,1/HTMLCSS.em) * scale; // padding for enclosure
var t = HTMLCSS.length2em(values.thickness,mu,1/HTMLCSS.em) * scale; // thickness of lines
t = Math.max(1/HTMLCSS.em,t); // see issue #414
var SOLID = HTMLCSS.Em(t)+" solid";
var stack = HTMLCSS.createStack(span);
var base = HTMLCSS.createBox(stack);
this.HTMLmeasureChild(0,base);
var H = base.bbox.h+p+t, D = base.bbox.d+p+t, W = base.bbox.w+2*(p+t);
var frame = HTMLCSS.createFrame(stack,H+D,0,W,t,"none");
frame.id = "MathJax-frame-"+this.spanID;
HTMLCSS.addBox(stack,frame); stack.insertBefore(frame,base); // move base to above background
var T = 0, B = 0, R = 0, L = 0, dx = 0, dy = 0; var svg, vml;
var w, h, r;
if (!values.mathcolor) {values.mathcolor = "currentColor"} else {span.style.color = values.mathcolor}
// perform some reduction e.g. eliminate duplicate notations.
var nl = MathJax.Hub.SplitList(values.notation), notation = {};
for (var i = 0, m = nl.length; i < m; i++) notation[nl[i]] = true;
if (notation[MML.NOTATION.UPDIAGONALARROW]) notation[MML.NOTATION.UPDIAGONALSTRIKE] = false;
var line;
for (var n in notation) {
if (!notation.hasOwnProperty(n) || !notation[n]) continue;
switch (n) {
case MML.NOTATION.BOX:
frame.style.border = SOLID; if (!HTMLCSS.msieBorderWidthBug) {T = B = L = R = t}
break;
case MML.NOTATION.ROUNDEDBOX:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
// roundrect.arcsize can't be set in IE8 standards mode, so use a path
r = Math.floor(1000*Math.min(W,H+D)-2*t);
w = Math.floor(4000*(W-2*t)), h = Math.floor(4000*(H+D-2*t));
this.HTMLvmlElement(vml,"shape",{
style: {width:this.HTMLpx(W-2*t),height:this.HTMLpx(H+D-2*t),
left:this.HTMLpx(t,.5),top:this.HTMLpx(t,.5)},
path: "m "+r+",0 qx 0,"+r+" l 0,"+(h-r)+" qy "+r+","+h+" "+
"l "+(w-r)+","+h+" qx "+w+","+(h-r)+" l "+w+","+r+" qy "+(w-r)+",0 x e",
coordsize: w+","+h
});
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"rect",{
x:1, y:1, width:this.HTMLpx(W-t)-1,
height:this.HTMLpx(H+D-t)-1, rx:this.HTMLpx(Math.min(H+D,W)/4)
});
}
break;
case MML.NOTATION.CIRCLE:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
this.HTMLvmlElement(vml,"oval",{
style: {width:this.HTMLpx(W-2*t),height:this.HTMLpx(H+D-2*t),
left:this.HTMLpx(t,.5),top:this.HTMLpx(t,.5)}
});
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"ellipse",{
rx:this.HTMLpx(W/2-t), ry:this.HTMLpx((H+D)/2-t),
cx:this.HTMLpx(W/2), cy:this.HTMLpx((H+D)/2)
});
}
break;
case MML.NOTATION.LEFT:
frame.style.borderLeft = SOLID; if (!HTMLCSS.msieBorderWidthBug) {L = t}
break;
case MML.NOTATION.ACTUARIAL:
frame.style.borderTop = SOLID; if (!HTMLCSS.msieBorderWidthBug) {T = t; frame.bbox.w += p-t}
case MML.NOTATION.RIGHT:
frame.style.borderRight = SOLID; if (!HTMLCSS.msieBorderWidthBug) {R = t}
break;
case MML.NOTATION.VERTICALSTRIKE:
line = HTMLCSS.createRule(stack,H+D-t/2,0,t);
HTMLCSS.addBox(stack,line); HTMLCSS.placeBox(line,p+t+base.bbox.w/2,-D,true);
break;
case MML.NOTATION.TOP:
frame.style.borderTop = SOLID; if (!HTMLCSS.msieBorderWidthBug) {T = t}
break;
case MML.NOTATION.BOTTOM:
frame.style.borderBottom = SOLID; if (!HTMLCSS.msieBorderWidthBug) {B = t}
break;
case MML.NOTATION.HORIZONTALSTRIKE:
line = HTMLCSS.createRule(stack,t,0,W-t/2);
HTMLCSS.addBox(stack,line); HTMLCSS.placeBox(line,0,(H+D)/2-D,true);
break;
case MML.NOTATION.UPDIAGONALSTRIKE:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
line = this.HTMLvmlElement(vml,"line",{from: "0,"+this.HTMLpx(H+D-t), to: this.HTMLpx(W)+",0"});
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"line",{
x1:1, y1:this.HTMLpx(H+D-t), x2:this.HTMLpx(W-t), y2:this.HTMLpx(t)
});
}
break;
case MML.NOTATION.UPDIAGONALARROW:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
line = this.HTMLvmlElement(vml,"line",{from: "0,"+this.HTMLpx(H+D-t), to: this.HTMLpx(W)+","+this.HTMLpx(t)});
this.HTMLvmlElement(line,"stroke",{endarrow:"classic"});
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
var l = Math.sqrt(W*W + (H+D)*(H+D)), f = 1/l * 10*this.scale/HTMLCSS.em * t/.075;
w = W * f; h = (H+D) * f; var x = W - t/2, y = t/2;
if (y+h-.4*w < 0) {y = .4*w-h}
this.HTMLsvgElement(svg.firstChild,"line",{
x1:1, y1:this.HTMLpx(H+D-t), x2:this.HTMLpx(x-.7*w), y2:this.HTMLpx(y+.7*h)
});
this.HTMLsvgElement(svg.firstChild,"polygon",{
points: this.HTMLpx(x)+","+this.HTMLpx(y)+" "
+this.HTMLpx(x-w-.4*h)+","+this.HTMLpx(y+h-.4*w)+" "
+this.HTMLpx(x-.7*w)+","+this.HTMLpx(y+.7*h)+" "
+this.HTMLpx(x-w+.4*h)+","+this.HTMLpx(y+h+.4*w)+" "
+this.HTMLpx(x)+","+this.HTMLpx(y),
fill:values.mathcolor, stroke:"none"
});
}
break;
case MML.NOTATION.DOWNDIAGONALSTRIKE:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
this.HTMLvmlElement(vml,"line",{from: "0,0", to: this.HTMLpx(W)+","+this.HTMLpx(H+D-t)});
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"line",{
x1:1, y1:this.HTMLpx(t), x2:this.HTMLpx(W-t), y2:this.HTMLpx(H+D-t)
});
}
break;
case MML.NOTATION.PHASORANGLE:
W -= 2*p; p = (H+D)/2; W += p;
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
this.HTMLvmlElement(vml,"shape",{
style: {width:this.HTMLpx(W), height:this.HTMLpx(H+D)},
path: "m "+this.HTMLpt(p+t/2,t/2)+
" l "+this.HTMLpt(t/2,H+D-t)+" "+this.HTMLpt(W-t/2,H+D-t)+" e",
coordsize: this.HTMLpt(W,H+D)
});
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"path",{
d: "M "+this.HTMLpx(p)+",1" +
"L 1,"+this.HTMLpx(H+D-t)+" L "+this.HTMLpx(W)+","+this.HTMLpx(H+D-t)
});
HTMLCSS.placeBox(svg.parentNode,0,-D,true);
}
break;
case MML.NOTATION.MADRUWB:
frame.style.borderBottom = SOLID;
frame.style.borderRight = SOLID; if (!HTMLCSS.msieBorderWidthBug) {B = R = t}
break;
case MML.NOTATION.RADICAL:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
this.HTMLvmlElement(vml,"shape",{
style: {width:this.HTMLpx(W), height:this.HTMLpx(H+D)},
path: "m "+this.HTMLpt(t/2,.6*(H+D))+" l "+this.HTMLpt(p,H+D-t)+" "+
this.HTMLpt(2*p,t/2)+" "+this.HTMLpt(W,t/2)+" e",
coordsize: this.HTMLpt(W,H+D)
});
dx = p;
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"path",{
d: "M 1,"+this.HTMLpx(.6*(H+D)) +
" L "+this.HTMLpx(p)+","+this.HTMLpx(H+D) +
" L "+this.HTMLpx(2*p)+",1 L "+this.HTMLpx(W)+",1"
});
HTMLCSS.placeBox(svg.parentNode,0,p/2-D,true);
dx = p; dy = t;
}
break;
case MML.NOTATION.LONGDIV:
if (HTMLCSS.useVML) {
if (!vml) {vml = this.HTMLvml(stack,H,D,W,t,values.mathcolor)}
this.HTMLvmlElement(vml,"line",{from: "0,"+this.HTMLpx(t/2), to: this.HTMLpx(W-t)+","+this.HTMLpx(t/2)});
this.HTMLvmlElement(vml,"arc",{
style: {width:this.HTMLpx(2*p),height:this.HTMLpx(H+D-2*t),
left:this.HTMLpx(-p),top:this.HTMLpx(t)},
startangle:"10", endangle:"170"
});
dx = p;
} else {
if (!svg) {svg = this.HTMLsvg(stack,H,D,W,t,values.mathcolor)}
this.HTMLsvgElement(svg.firstChild,"path",{
d: "M "+this.HTMLpx(W)+",1 L 1,1 "+
"a"+this.HTMLpx(p)+","+this.HTMLpx((H+D)/2-t)+" 0 0,1 1,"+this.HTMLpx(H+D-2*t)
});
HTMLCSS.placeBox(svg.parentNode,0,t-D,true);
dx = p; dy = t;
}
break;
}
}
frame.style.width = HTMLCSS.Em(W-L-R); frame.style.height = HTMLCSS.Em(H+D-T-B);
HTMLCSS.placeBox(frame,0,dy-D,true);
HTMLCSS.placeBox(base,dx+p+t,0);
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
return span;
},
HTMLpx: function (n) {return (n*HTMLCSS.em)},
HTMLpt: function (x,y) {return Math.floor(1000*x)+','+Math.floor(1000*y)},
HTMLhandleColor: function (span) {
var frame = document.getElementById("MathJax-frame-"+this.spanID);
if (frame) {
// mathcolor is handled in toHTML above
var values = this.getValues("mathbackground","background");
if (this.style && span.style.backgroundColor) {
values.mathbackground = span.style.backgroundColor;
span.style.backgroundColor = "";
}
if (values.background && !this.mathbackground) {values.mathbackground = values.background}
if (values.mathbackground && values.mathbackground !== MML.COLOR.TRANSPARENT)
{frame.style.backgroundColor = values.mathbackground}
} else {this.SUPER(arguments).HTMLhandleColor.call(this,span)}
},
HTMLsvg: function (stack,H,D,W,t,color) {
var svg = document.createElementNS(SVGNS,"svg");
if (svg.style) {svg.style.width = HTMLCSS.Em(W); svg.style.height = HTMLCSS.Em(H+D)}
var scale = HTMLCSS.createBox(stack); scale.appendChild(svg);
HTMLCSS.placeBox(scale,0,-D,true);
this.HTMLsvgElement(svg,"g",{fill:"none", stroke:color, "stroke-width":t*HTMLCSS.em});
return svg;
},
HTMLsvgElement: 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;
},
HTMLvml: function (stack,H,D,W,t,color) {
var vml = HTMLCSS.createFrame(stack,H+D,0,W,0,"none");
HTMLCSS.addBox(stack,vml); HTMLCSS.placeBox(vml,0,-D,true);
this.constructor.VMLcolor = color; this.constructor.VMLthickness = this.HTMLpx(t);
return vml;
},
HTMLvmlElement: function (vml,type,def) {
var obj = HTMLCSS.addElement(vml,vmlns+":"+type,{isMathJax:true});
obj.style.position = "absolute"; obj.style.left = obj.style.top = 0;
MathJax.Hub.Insert(obj,def); // IE8 needs to do this after obj is added to the page
if (!def.fillcolor) {obj.fillcolor = "none"}
if (!def.strokecolor) {obj.strokecolor = this.constructor.VMLcolor}
if (!def.strokeweight) {obj.strokeweight =this.constructor.VMLthickness}
return obj;
}
});
MathJax.Hub.Browser.Select({
MSIE: function (browser) {
//
// IE8 and below doesn't have SVG, so use VML
//
if ((document.documentMode||0) < 9) {
MML.menclose.Augment({HTMLpx: function (n,d) {return (n*HTMLCSS.em+(d||0))+"px"}});
HTMLCSS.useVML = true;
if (!document.namespaces[vmlns]) {
if (document.documentMode && document.documentMode === 8) {
document.namespaces.add(vmlns,VMLNS,"#default#VML");
} else {
document.namespaces.add(vmlns,VMLNS);
document.createStyleSheet().addRule(vmlns+"\\: *","{behavior: url(#default#VML)}");
}
}
}
}
});
MathJax.Hub.Startup.signal.Post("HTML-CSS menclose Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/menclose.js");
});

115
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/mglyph.js vendored Normal file
View File

@@ -0,0 +1,115 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/mglyph.js
*
* Implements the HTML-CSS output for <mglyph> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"],
LOCALE = MathJax.Localization;
MML.mglyph.Augment({
toHTML: function (span,variant) {
var SPAN = span, values = this.getValues("src","width","height","valign","alt"), err;
span = this.HTMLcreateSpan(span);
if (values.src === "") {
var index = this.Get("index");
if (index) {
variant = this.HTMLgetVariant(); var font = variant.defaultFont;
if (font) {
font.noStyleChar = true; font.testString = String.fromCharCode(index) + 'ABCabc';
if (HTMLCSS.Font.testFont(font)) {
this.HTMLhandleVariant(span,variant,String.fromCharCode(index));
} else {
if (values.alt === "")
{values.alt = LOCALE._(["MathML","BadMglyphFont"],"Bad font: %1",font.family)}
err = MML.Error(values.alt,{mathsize:"75%"});
this.Append(err); err.toHTML(span); this.data.pop();
span.bbox = err.HTMLspanElement().bbox;
}
}
}
} else {
if (!this.img) {this.img = MML.mglyph.GLYPH[values.src]}
if (!this.img) {
this.img = MML.mglyph.GLYPH[values.src] = {img: new Image(), status: "pending"};
var img = this.img.img;
img.onload = MathJax.Callback(["HTMLimgLoaded",this]);
img.onerror = MathJax.Callback(["HTMLimgError",this]);
img.src = values.src;
MathJax.Hub.RestartAfter(img.onload);
}
if (this.img.status !== "OK") {
err = MML.Error(
LOCALE._(["MathML","BadMglyph"],"Bad mglyph: %1",values.src),
{mathsize:"75%"});
this.Append(err); err.toHTML(span); this.data.pop();
span.bbox = err.HTMLspanElement().bbox;
} else {
var mu = this.HTMLgetMu(span);
var scale = this.HTMLgetScale();
img = HTMLCSS.addElement(span,"img",{isMathJax:true, src:values.src, alt:values.alt, title:values.alt});
if (values.width) {
img.style.width = HTMLCSS.Em(HTMLCSS.length2em(values.width,mu,this.img.img.width/HTMLCSS.em) * scale);
}
if (values.height) {
img.style.height = HTMLCSS.Em(HTMLCSS.length2em(values.height,mu,this.img.img.height/HTMLCSS.em) * scale);
}
span.bbox.w = span.bbox.rw = img.offsetWidth/HTMLCSS.em;
span.bbox.h = img.offsetHeight/HTMLCSS.em;
if (values.valign) {
span.bbox.d = -HTMLCSS.length2em(values.valign,mu,this.img.img.height/HTMLCSS.em) * scale;
img.style.verticalAlign = HTMLCSS.Em(-span.bbox.d);
span.bbox.h -= span.bbox.d;
}
}
}
if (!SPAN.bbox) {
SPAN.bbox = {w: span.bbox.w, h: span.bbox.h, d: span.bbox.d,
rw: span.bbox.rw, lw: span.bbox.lw};
} else if (span.bbox) {
SPAN.bbox.w += span.bbox.w;
if (SPAN.bbox.w > SPAN.bbox.rw) {SPAN.bbox.rw = SPAN.bbox.w}
if (span.bbox.h > SPAN.bbox.h) {SPAN.bbox.h = span.bbox.h}
if (span.bbox.d > SPAN.bbox.d) {SPAN.bbox.d = span.bbox.d}
}
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
return span;
},
HTMLimgLoaded: function (event,status) {
if (typeof(event) === "string") {status = event}
this.img.status = (status || "OK")
},
HTMLimgError: function () {this.img.img.onload("error")}
},{
GLYPH: {} // global list of all loaded glyphs
});
MathJax.Hub.Startup.signal.Post("HTML-CSS mglyph Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/mglyph.js");
});

200
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/mmultiscripts.js vendored Normal file
View File

@@ -0,0 +1,200 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/mmultiscripts.js
*
* Implements the HTML-CSS output for <mmultiscripts> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
MML.mmultiscripts.Augment({
toHTML: function (span,HW,D) {
span = this.HTMLcreateSpan(span); var scale = this.HTMLgetScale();
var stack = HTMLCSS.createStack(span), values;
var base = HTMLCSS.createBox(stack);
if (this.data[this.base]) {
var child = this.data[this.base].toHTML(base);
if (D != null) {this.data[this.base].HTMLstretchV(base,HW,D)}
else if (HW != null) {this.data[this.base].HTMLstretchH(base,HW)}
HTMLCSS.Measured(child,base);
} else {base.bbox = this.HTMLzeroBBox()}
var x_height = HTMLCSS.TeX.x_height * scale,
s = HTMLCSS.TeX.scriptspace * scale * .75; // FIXME: .75 can be removed when IC is right?
var BOX = this.HTMLgetScripts(stack,s);
var sub = BOX[0], sup = BOX[1], presub = BOX[2], presup = BOX[3];
//
// <mmultiscripts> children other than the base can be <none/>,
// <mprescripts/>, <mrow></mrow> etc so try to get HTMLgetScale from the
// first element with a spanID. See issue 362.
//
var sscale = scale;
for (var i = 1; i < this.data.length; i++) {
if (this.data[i] && this.data[i].spanID) {
sscale = this.data[i].HTMLgetScale();
break;
}
}
var q = HTMLCSS.TeX.sup_drop * sscale, r = HTMLCSS.TeX.sub_drop * sscale;
var u = base.bbox.h - q, v = base.bbox.d + r, delta = 0, p;
if (base.bbox.ic) {delta = base.bbox.ic}
if (this.data[this.base] &&
(this.data[this.base].type === "mi" || this.data[this.base].type === "mo")) {
if (HTMLCSS.isChar(this.data[this.base].data.join("")) && base.bbox.scale === 1 &&
!this.data[this.base].Get("largeop")) {u = v = 0}
}
var min = this.getValues("subscriptshift","superscriptshift"), mu = this.HTMLgetMu(span);
min.subscriptshift = (min.subscriptshift === "" ? 0 : HTMLCSS.length2em(min.subscriptshift,mu));
min.superscriptshift = (min.superscriptshift === "" ? 0 : HTMLCSS.length2em(min.superscriptshift,mu));
var dx = 0;
if (presub) {dx = presub.bbox.w+delta} else if (presup) {dx = presup.bbox.w-delta}
if (dx < 0) {dx = 0};
HTMLCSS.placeBox(base,dx,0);
if (!sup && !presup) {
v = Math.max(v,HTMLCSS.TeX.sub1*scale,min.subscriptshift);
if (sub) {v = Math.max(v,sub.bbox.h-(4/5)*x_height)}
if (presub) {v = Math.max(v,presub.bbox.h-(4/5)*x_height)}
if (sub) {HTMLCSS.placeBox(sub,dx+base.bbox.w+s-delta,-v)}
if (presub) {HTMLCSS.placeBox(presub,0,-v)}
} else {
if (!sub && !presub) {
values = this.getValues("displaystyle","texprimestyle");
p = HTMLCSS.TeX[(values.displaystyle ? "sup1" : (values.texprimestyle ? "sup3" : "sup2"))];
u = Math.max(u,p*scale,min.superscriptshift);
if (sup) {u = Math.max(u,sup.bbox.d+(1/4)*x_height)}
if (presup) {u = Math.max(u,presup.bbox.d+(1/4)*x_height)}
if (sup) {HTMLCSS.placeBox(sup,dx+base.bbox.w+s,u)}
if (presup) {HTMLCSS.placeBox(presup,0,u)}
} else {
v = Math.max(v,HTMLCSS.TeX.sub2*scale);
var t = HTMLCSS.TeX.rule_thickness * scale;
var h = (sub||presub).bbox.h, d = (sup||presup).bbox.d;
if (presub) {h = Math.max(h,presub.bbox.h)}
if (presup) {d = Math.max(d,presup.bbox.d)}
if ((u - d) - (h - v) < 3*t) {
v = 3*t - u + d + h; q = (4/5)*x_height - (u - d);
if (q > 0) {u += q; v -= q}
}
u = Math.max(u,min.superscriptshift); v = Math.max(v,min.subscriptshift);
if (sup) {HTMLCSS.placeBox(sup,dx+base.bbox.w+s,u)}
if (presup) {HTMLCSS.placeBox(presup,dx+delta-presup.bbox.w,u)}
if (sub) {HTMLCSS.placeBox(sub,dx+base.bbox.w+s-delta,-v)}
if (presub) {HTMLCSS.placeBox(presub,dx-presub.bbox.w,-v)}
}
}
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
var bbox = span.bbox;
bbox.dx = dx; bbox.s = s; bbox.u = u; bbox.v = v; bbox.delta = delta;
bbox.px = dx+base.bbox.w;
return span;
},
HTMLgetScripts: function (stack,s) {
var sup, sub, BOX = [];
var i = 1, m = this.data.length, W = 0;
for (var k = 0; k < 4; k += 2) {
while (i < m && (this.data[i]||{}).type !== "mprescripts") {
var box = [null,null,null,null];
for (var j = k; j < k+2; j++) {
if (this.data[i] && this.data[i].type !== "none" && this.data[i].type !== "mprescripts") {
if (!BOX[j]) {
BOX[j] = HTMLCSS.createBox(stack); BOX[j].bbox = this.HTMLemptyBBox({});
if (W) {HTMLCSS.createBlank(BOX[j],W); BOX[j].bbox.w = BOX[j].bbox.rw = W}
}
box[j] = this.data[i].toHTML(BOX[j]);
} else {
box[j] = MathJax.HTML.Element("span",{bbox:this.HTMLemptyBBox({})});
}
if ((this.data[i]||{}).type !== "mprescripts") i++;
}
var isPre = (k === 2);
sub = BOX[k]; sup = BOX[k+1];
if (sub && sup) {
var w = box[k+1].bbox.w - box[k].bbox.w;
if (w > 0) {
if (isPre) {
this.HTMLmoveColor(box[k],w,1);
BOX[k].w += w;
} else {
HTMLCSS.createBlank(sub,w);
}
} else if (w < 0) {
if (isPre) {
this.HTMLmoveColor(box[k+1],-w,-1);
BOX[k+1].w += -w;
} else {
HTMLCSS.createBlank(sup,-w);
}
}
this.HTMLcombineBBoxes(box[k],sub.bbox);
this.HTMLcombineBBoxes(box[k+1],sup.bbox);
if (w > 0) {
sub.bbox.w = sup.bbox.w;
sub.bbox.rw = Math.max(sub.bbox.w,sub.bbox.rw);
} else if (w < 0) {
sup.bbox.w = sub.bbox.w;
sup.bbox.rw = Math.max(sup.bbox.w,sup.bbox.rw);
}
} else {
if (sub) this.HTMLcombineBBoxes(box[k],sub.bbox);
if (sup) this.HTMLcombineBBoxes(box[k+1],sup.bbox);
}
if (sub) {W = sub.bbox.w} else if (sup) {W = sup.bbox.w}
}
i++; W = 0;
}
for (j = 0; j < 4; j++) {
if (BOX[j]) {
BOX[j].bbox.w += s;
BOX[j].bbox.rw = Math.max(BOX[j].bbox.w,BOX[j].bbox.rw);
BOX[j].bbox.name = (["sub","sup","presub","presup"])[j];
this.HTMLcleanBBox(BOX[j].bbox);
}
}
return BOX;
},
HTMLmoveColor: function (box,w,sign) {
var W = w/(box.scale||1);
box.style.paddingLeft = HTMLCSS.Em(W);
var color = box.previousSibling;
if (color && (color.id||"").match(/^MathJax-Color-/)) {
color.style.marginLeft = HTMLCSS.Em(W+parseFloat(color.style.marginLeft));
color.style.marginRight = HTMLCSS.Em(sign*(W-parseFloat(color.style.marginRight)));
}
},
HTMLstretchH: MML.mbase.HTMLstretchH,
HTMLstretchV: MML.mbase.HTMLstretchV
});
MathJax.Hub.Startup.signal.Post("HTML-CSS mmultiscripts Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/mmultiscripts.js");
});

53
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/ms.js vendored Normal file
View File

@@ -0,0 +1,53 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/ms.js
*
* Implements the HTML-CSS output for <ms> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
MML.ms.Augment({
toHTML: function (span) {
span = this.HTMLhandleSize(this.HTMLcreateSpan(span));
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 = '"';
var text = values.lquote+this.data.join("")+values.rquote; // FIXME: handle mglyph?
this.HTMLhandleVariant(span,this.HTMLgetVariant(),text);
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
this.HTMLhandleDir(span);
return span;
}
});
MathJax.Hub.Startup.signal.Post("HTML-CSS ms Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/ms.js");
});

505
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/mtable.js vendored Normal file
View File

@@ -0,0 +1,505 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/mtable.js
*
* Implements the HTML-CSS output for <mtable> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
MML.mtable.Augment({
toHTML: function (span) {
span = this.HTMLcreateSpan(span);
if (this.data.length === 0) {return span}
var values = this.getValues("columnalign","rowalign","columnspacing","rowspacing",
"columnwidth","equalcolumns","equalrows",
"columnlines","rowlines","frame","framespacing",
"align","useHeight","width","side","minlabelspacing");
var hasRelativeWidth = values.width.match(/%$/);
var stack = HTMLCSS.createStack(span);
var scale = this.HTMLgetScale(), mu = this.HTMLgetMu(span), LABEL = -1;
var H = [], D = [], W = [], A = [], C = [], i, j, J = -1,
m, M, s, row, cell, mo, entries = [], HD;
var LH = HTMLCSS.FONTDATA.lineH * scale * values.useHeight,
LD = HTMLCSS.FONTDATA.lineD * scale * values.useHeight;
//
// Create cells and measure columns and rows
//
for (i = 0, m = this.data.length; i < m; i++) {
row = this.data[i]; s = (row.type === "mlabeledtr" ? LABEL : 0);
A[i] = []; H[i] = LH; D[i] = LD;
for (j = s, M = row.data.length + s; j < M; j++) {
if (W[j] == null) {
if (j > J) {J = j}
C[j] = HTMLCSS.createStack(HTMLCSS.createBox(stack));
W[j] = -HTMLCSS.BIGDIMEN;
}
A[i][j] = HTMLCSS.createBox(C[j]);
entries.push(row.data[j-s].toHTML(A[i][j]));
}
}
HTMLCSS.MeasureSpans(entries);
for (i = 0, m = this.data.length; i < m; i++) {
row = this.data[i]; s = (row.type === "mlabeledtr" ? LABEL : 0);
for (j = s, M = row.data.length + s; j < M; j++) {
cell = row.data[j-s];
if (cell.isMultiline) {A[i][j].style.width = "100%"}
if (cell.isEmbellished()) {
mo = cell.CoreMO();
var min = mo.Get("minsize",true);
if (min) {
var bbox = mo.HTMLspanElement().bbox;
if (mo.HTMLcanStretch("Vertical")) {
HD = bbox.h + bbox.d;
if (HD) {
min = HTMLCSS.length2em(min,mu,HD);
if (min*bbox.h/HD > H[i]) {H[i] = min*bbox.h/HD}
if (min*bbox.d/HD > D[i]) {D[i] = min*bbox.d/HD}
}
} else if (mo.HTMLcanStretch("Horizontal")) {
min = HTMLCSS.length2em(min,mu,bbox.w);
if (min > W[j]) {W[j] = min}
}
}
}
if (A[i][j].bbox.h > H[i]) {H[i] = A[i][j].bbox.h}
if (A[i][j].bbox.d > D[i]) {D[i] = A[i][j].bbox.d}
if (A[i][j].bbox.w > W[j]) {W[j] = A[i][j].bbox.w}
}
}
//
// Determine spacing and alignment
//
var SPLIT = MathJax.Hub.SplitList;
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 = [];
for (i = 0, m = CSPACE.length; i < m; i++) {CSPACE[i] = HTMLCSS.length2em(CSPACE[i],mu)}
for (i = 0, m = RSPACE.length; i < m; i++) {RSPACE[i] = HTMLCSS.length2em(RSPACE[i],mu)}
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 < A.length) {RSPACE.push(RSPACE[RSPACE.length-1])}
while (RALIGN.length <= A.length) {RALIGN.push(RALIGN[RALIGN.length-1])}
while (RLINES.length < A.length) {RLINES.push(RLINES[RLINES.length-1])}
if (C[LABEL]) {
CALIGN[LABEL] = (values.side.substr(0,1) === "l" ? "left" : "right");
CSPACE[LABEL] = -W[LABEL];
}
//
// Override row data
//
for (i = 0, m = A.length; i < m; i++) {
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 equal heights
//
if (values.equalrows) {
// FIXME: should really be based on row align (below is for baseline)
var Hm = Math.max.apply(Math,H), Dm = Math.max.apply(Math,D);
for (i = 0, m = A.length; i < m; i++)
{s = ((Hm + Dm) - (H[i] + D[i])) / 2; H[i] += s; D[i] += s}
}
// FIXME: do background colors for entire cell (include half the intercolumn space?)
//
// Determine array total height
//
HD = H[0] + D[A.length-1];
for (i = 0, m = A.length-1; i < m; i++) {HD += Math.max(0,D[i]+H[i+1]+RSPACE[i])}
//
// Determine frame and line sizes
//
var fx = 0, fy = 0, fW, fH = HD;
if (values.frame !== "none" ||
(values.columnlines+values.rowlines).match(/solid|dashed/)) {
var frameSpacing = SPLIT(values.framespacing);
if (frameSpacing.length != 2) {
// invalid attribute value: use the default.
frameSpacing = SPLIT(this.defaults.framespacing);
}
fx = HTMLCSS.length2em(frameSpacing[0],mu);
fy = HTMLCSS.length2em(frameSpacing[1],mu);
fH = HD + 2*fy; // fW waits until stack.bbox.w is determined
}
//
// Compute alignment
//
var Y, fY, n = "";
if (typeof(values.align) !== "string") {values.align = String(values.align)}
if (values.align.match(/(top|bottom|center|baseline|axis)( +(-?\d+))?/))
{n = RegExp.$3||""; values.align = RegExp.$1} else {values.align = this.defaults.align}
if (n !== "") {
//
// Find the height of the given row
//
n = parseInt(n);
if (n < 0) {n = A.length + 1 + n}
if (n < 1) {n = 1} else if (n > A.length) {n = A.length}
Y = 0; fY = -(HD + fy) + H[0];
for (i = 0, m = n-1; i < m; i++) {
// FIXME: Should handle values.align for final row
var dY = Math.max(0,D[i]+H[i+1]+RSPACE[i]);
Y += dY; fY += dY;
}
} else {
Y = ({
top: -(H[0] + fy),
bottom: HD + fy - H[0],
center: HD/2 - H[0],
baseline: HD/2 - H[0],
axis: HD/2 + HTMLCSS.TeX.axis_height*scale - H[0]
})[values.align];
fY = ({
top: -(HD + 2*fy),
bottom: 0,
center: -(HD/2 + fy),
baseline: -(HD/2 + fy),
axis: HTMLCSS.TeX.axis_height*scale - HD/2 - fy
})[values.align];
}
var WW, WP = 0, Wt = 0, Wp = 0, p = 0, f = 0, P = [], F = [], Wf = 1;
//
if (values.equalcolumns && values.width !== "auto") {
//
// Handle equalcolumns for percent-width and fixed-width tables
//
if (hasRelativeWidth) {
// Set widths to percentages
WW = (100/(J+1)).toFixed(2).replace(/\.?0+$/,"")+"%";
for (i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {CWIDTH[i] = WW}
// Get total column spacing
WW = 0; WP = 1; f = J+1;
for (i = 0, m = Math.min(J+1,CSPACE.length); i < m; i++) {WW += CSPACE[i]}
} else {
// Get total width minus column spacing
WW = HTMLCSS.length2em(values.width,mu);
for (i = 0, m = Math.min(J,CSPACE.length); i < m; i++) {WW -= CSPACE[i]}
// Determine individual column widths
WW /= J;
for (i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {W[i] = WW}
}
} else {
//
// Get column widths for fit and percentage columns
//
// Calculate the natural widths and percentage widths,
// while keeping track of the fit and percentage columns
for(i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {
if (CWIDTH[i] === "auto") {Wt += W[i]}
else if (CWIDTH[i] === "fit") {F[f] = i; f++; Wt += W[i]}
else if (CWIDTH[i].match(/%$/))
{P[p] = i; p++; Wp += W[i]; WP += HTMLCSS.length2em(CWIDTH[i],mu,1)}
else {W[i] = HTMLCSS.length2em(CWIDTH[i],mu); Wt += W[i]}
}
if (hasRelativeWidth) {
// Get separation width and check percentages
WW = 0; for (i = 0, m = Math.min(J,CSPACE.length); i < m; i++) {WW += CSPACE[i]}
if (WP > .98) {Wf = .98/WP; WP = .98}
} else {
// Get the full width (excluding inter-column spacing)
if (values.width === "auto") {
if (WP > .98) {Wf = Wp/(Wt+Wp); WW = Wt + Wp} else {WW = Wt / (1-WP)}
} else {
WW = HTMLCSS.length2em(values.width,mu);
for (i = 0, m = Math.min(J,CSPACE.length); i < m; i++) {WW -= CSPACE[i]}
}
// Determine the relative column widths
for (i = 0, m = P.length; i < m; i++) {
W[P[i]] = HTMLCSS.length2em(CWIDTH[P[i]],mu,WW*Wf); Wt += W[P[i]];
}
// Stretch fit columns, if any, otherwise stretch (or shrink) everything
if (Math.abs(WW - Wt) > .01) {
if (f && WW > Wt) {
WW = (WW - Wt) / f; for (i = 0, m = F.length; i < m; i++) {W[F[i]] += WW}
} else {WW = WW/Wt; for (j = 0; j <= J; j++) {W[j] *= WW}}
}
//
// Handle equal columns
//
if (values.equalcolumns) {
var Wm = Math.max.apply(Math,W);
for (j = 0; j <= J; j++) {W[j] = Wm}
}
}
}
//
// Lay out array columns
//
var y = Y, dy, line, align; s = (C[LABEL] ? LABEL : 0);
for (j = s; j <= J; j++) {
for (i = 0, m = A.length; i < m; i++) {
if (A[i][j]) {
s = (this.data[i].type === "mlabeledtr" ? LABEL : 0);
cell = this.data[i].data[j-s];
if (cell.HTMLcanStretch("Horizontal")) {
A[i][j].bbox = cell.HTMLstretchH(C[j],W[j]).bbox;
} else if (cell.HTMLcanStretch("Vertical")) {
mo = cell.CoreMO();
var symmetric = mo.symmetric; mo.symmetric = false;
A[i][j].bbox = cell.HTMLstretchV(C[j],H[i],D[i]).bbox; A[i][j].HH = null;
if (A[i][j].bbox.h > H[i]) {A[i][j].bbox.H = A[i][j].bbox.h; A[i][j].bbox.h = H[i]}
if (A[i][j].bbox.d > D[i]) {A[i][j].bbox.D = A[i][j].bbox.d; A[i][j].bbox.d = D[i]}
mo.symmetric = symmetric;
}
align = cell.rowalign||this.data[i].rowalign||RALIGN[i];
dy = ({top: H[i] - A[i][j].bbox.h,
bottom: A[i][j].bbox.d - D[i],
center: ((H[i]-D[i]) - (A[i][j].bbox.h-A[i][j].bbox.d))/2,
baseline: 0, axis: 0})[align] || 0; // FIXME: handle axis better?
align = (cell.columnalign||RCALIGN[i][j]||CALIGN[j]);
HTMLCSS.alignBox(A[i][j],align,y+dy);
}
if (i < A.length-1) {y -= Math.max(0,D[i]+H[i+1]+RSPACE[i])}
}
y = Y;
}
//
// Set column widths and placement
//
if (hasRelativeWidth) {
//
// Remove column spacing to get width available for columns
//
var box = HTMLCSS.createBox(stack); box.style.left = box.style.top = 0;
box.style.right = HTMLCSS.Em(WW+2*fx); box.style.display = "inline-block";
box.style.height = "0px";
if (HTMLCSS.msieRelativeWidthBug) {
box = HTMLCSS.createBox(box); box.style.position = "relative";
box.style.height = "1em"; box.style.width = "100%"; box.bbox = stack.bbox;
}
//
// wp = remaining width (%) divided by the number of columns it is split over
// wm = remaining width (fixed) divided by the number of columns it is split over
//
var xp = 0, xf = fx, wp, wm;
if (f) {wp = 100*(1-WP)/f, wm = Wt/f} else {wp = 100*(1-WP)/(J+1); wm = Wt/(J+1)}
for (j = 0; j <= J; j++) {
HTMLCSS.placeBox(C[j].parentNode,0,0); // sets the bbox
//
// Convert original column to the innermost span in the mobile column
//
C[j].style.position = "relative";
C[j].style.left = HTMLCSS.Em(xf);
C[j].style.width = "100%";
C[j].parentNode.parentNode.removeChild(C[j].parentNode);
var Cj = HTMLCSS.createBox(box); HTMLCSS.addBox(Cj,C[j]); C[j] = Cj;
var CjStyle = Cj.style; CjStyle.display = "inline-block"; CjStyle.left = xp + "%";
//
// Set width/position based on the type of column
//
if (CWIDTH[j].match(/%$/)) {
var pp = parseFloat(CWIDTH[j]) * Wf;
if (f === 0) {
CjStyle.width = (wp + pp) + "%"; xp += wp + pp;
Cj = HTMLCSS.createBox(Cj); HTMLCSS.addBox(Cj,C[j].firstChild);
Cj.style.left = 0; Cj.style.right = HTMLCSS.Em(wm); xf -= wm;
} else {
CjStyle.width = pp + "%"; xp += pp;
}
} else if (CWIDTH[j] === "fit" || f === 0) {
CjStyle.width = wp + "%";
Cj = HTMLCSS.createBox(Cj); HTMLCSS.addBox(Cj,C[j].firstChild);
Cj.style.left = 0; Cj.style.right = HTMLCSS.Em(wm-W[j]);
xf += W[j] - wm; xp += wp;
} else {
CjStyle.width = HTMLCSS.Em(W[j]); xf += W[j];
}
if (HTMLCSS.msieRelativeWidthBug) {
HTMLCSS.addText(Cj.firstChild,HTMLCSS.NBSP); // gets correct baseline
Cj.firstChild.style.position = "relative";
}
xf += CSPACE[j];
//
// Add column lines
//
if (CLINES[j] !== "none" && j < J && j !== LABEL) {
line = HTMLCSS.createBox(box); line.style.left = xp+"%";
line = HTMLCSS.createRule(line,fH,0,1.25/HTMLCSS.em); line.style.position = "absolute";
line.bbox = {h:fH, d:0, w:0, rw:1.25/HTMLCSS.em, lw:0};
line.parentNode.bbox = stack.bbox; // make sure stack size is updated
HTMLCSS.placeBox(line,xf-CSPACE[j]/2,fY,true); line.style.borderStyle = CLINES[j];
}
}
} else {
//
// Set the column box widths and place them
//
var x = fx;
for (j = 0; j <= J; j++) {
if (!C[j].bbox.width) {HTMLCSS.setStackWidth(C[j],W[j])}
if (CWIDTH[j] !== "auto" && CWIDTH[j] !== "fit")
{C[j].bbox.width = W[j]; C[j].bbox.isFixed = true}
HTMLCSS.placeBox(C[j].parentNode,x,0); x += W[j] + CSPACE[j];
//
// Add column lines
//
if (CLINES[j] !== "none" && j < J && j !== LABEL) {
line = HTMLCSS.createRule(stack,fH,0,1.25/HTMLCSS.em); HTMLCSS.addBox(stack,line);
line.bbox = {h:fH, d:0, w:0, rw:1.25/HTMLCSS.em, lw:0};
HTMLCSS.placeBox(line,x-CSPACE[j]/2,fY,true); line.style.borderStyle = CLINES[j];
}
}
}
stack.bbox.d = -fY; stack.bbox.h = fH+fY;
HTMLCSS.setStackWidth(stack,stack.bbox.w + fx);
//
// Add frame
//
fW = stack.bbox.w; var frame;
if (values.frame !== "none") {
frame = HTMLCSS.createFrame(stack,fH,0,fW,1.25/HTMLCSS.em,values.frame);
HTMLCSS.addBox(stack,frame); HTMLCSS.placeBox(frame,0,fY,true);
if (hasRelativeWidth) {frame.style.width = "100%"}
}
//
// Add row lines
//
y = Y;
for (i = 0, m = A.length-1; i < m; i++) {
dy = Math.max(0,D[i]+H[i+1]+RSPACE[i]);
if (RLINES[i] !== MML.LINES.NONE && RLINES[i] !== "") {
line = HTMLCSS.createRule(stack,1.25/HTMLCSS.em,0,fW); HTMLCSS.addBox(stack,line);
line.bbox = {h:1.25/HTMLCSS.em, d:0, w:fW, rw:fW, lw:0};
HTMLCSS.placeBox(line,0,y - D[i] - (dy-D[i]-H[i+1])/2,true);
if (RLINES[i] === MML.LINES.DASHED) line.style.borderTopStyle = "dashed";
if (hasRelativeWidth) line.style.width = "100%"
}
y -= dy;
}
//
// Set relative width
//
if (hasRelativeWidth) {span.bbox.width = values.width; stack.style.width = "100%"}
//
// Place the labels, if any
//
if (C[LABEL]) {
var mw = stack.bbox.w;
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 = this.displayAlign}
if (indent.indentshiftfirst !== MML.INDENTSHIFT.INDENTSHIFT) {indent.indentshift = indent.indentshiftfirst}
if (indent.indentshift === "auto") {indent.indentshift = "0"}
var shift = HTMLCSS.length2em(indent.indentshift,mu,HTMLCSS.cwidth);
var labelspace = HTMLCSS.length2em(values.minlabelspacing,mu,HTMLCSS.cwidth);
var labelW = labelspace + C[LABEL].bbox.w, labelshift = 0, tw = mw;
var dIndent = HTMLCSS.length2em(this.displayIndent,mu,HTMLCSS.cwidth);
s = (CALIGN[LABEL] === MML.INDENTALIGN.RIGHT ? -1 : 1);
if (indent.indentalign === MML.INDENTALIGN.CENTER) {
tw += 2 * (labelW - s*(shift + dIndent));
shift += dIndent;
} else if (CALIGN[LABEL] === indent.indentalign) {
if (dIndent < 0) {labelshift = s*dIndent; dIndent = 0}
shift += s*dIndent; if (labelW > s*shift) shift = s*labelW; shift += labelshift;
tw += s*shift;
} else {
tw += labelW - s*shift + dIndent;
shift -= s*dIndent;
}
var eqn = HTMLCSS.createStack(span,false,"100%");
HTMLCSS.addBox(eqn,stack); HTMLCSS.alignBox(stack,indent.indentalign,0,shift);
C[LABEL].parentNode.parentNode.removeChild(C[LABEL].parentNode);
HTMLCSS.addBox(eqn,C[LABEL]); HTMLCSS.alignBox(C[LABEL],CALIGN[LABEL],0);
if (HTMLCSS.msieRelativeWidthBug) {stack.style.top = C[LABEL].style.top = ""}
if (hasRelativeWidth) {stack.style.width = values.width; span.bbox.width = "100%"}
C[LABEL].style[s === 1 ? "marginLeft" : "marginRight"] = HTMLCSS.Em(s*labelshift);
span.bbox.tw = tw;
span.style.minWidth = span.bbox.minWidth = HTMLCSS.Em(tw);
eqn.style.minWidth = eqn.bbox.minWidth = HTMLCSS.Em(tw/scale);
}
//
// Finish the table
//
if (!hasRelativeWidth) {this.HTMLhandleSpace(span)}
var color = this.HTMLhandleColor(span);
//
// Handle relative-sized background color
//
if (color && hasRelativeWidth) {
if (!frame) {
frame = HTMLCSS.createFrame(stack,fH,0,fW,0,"none");
HTMLCSS.addBox(stack,frame); HTMLCSS.placeBox(frame,0,fY,true);
frame.style.width = "100%";
}
frame.style.backgroundColor = color.style.backgroundColor;
frame.parentNode.insertBefore(frame,frame.parentNode.firstChild);
color.parentNode.removeChild(color);
}
return span;
},
HTMLhandleSpace: function (span) {
span.bbox.keepPadding = true; span.bbox.exact = true;
if (!this.hasFrame && span.bbox.width == null) {
span.firstChild.style.marginLeft = span.firstChild.style.marginRight = HTMLCSS.Em(1/6);
span.bbox.w += 1/3; span.bbox.rw += 1/3; span.bbox.lw += 1/6;
}
this.SUPER(arguments).HTMLhandleSpace.call(this,span);
}
});
MML.mtd.Augment({
toHTML: function (span,HW,D) {
span = this.HTMLcreateSpan(span);
if (this.data[0]) {
var box = this.data[0].toHTML(span);
if (D != null) {box = this.data[0].HTMLstretchV(span,HW,D)}
else if (HW != null) {box = this.data[0].HTMLstretchH(span,HW)}
span.bbox = box.bbox;
}
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
return span;
},
HTMLstretchH: MML.mbase.HTMLstretchH,
HTMLstretchV: MML.mbase.HTMLstretchV
});
MathJax.Hub.Startup.signal.Post("HTML-CSS mtable Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/mtable.js");
});

829
web/assets/MathJax/unpacked/jax/output/HTML-CSS/autoload/multiline.js vendored Normal file
View File

@@ -0,0 +1,829 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/autoload/multiline.js
*
* Implements the HTML-CSS output for <mrow>'s that contain line breaks.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml,
HTMLCSS = MathJax.OutputJax["HTML-CSS"];
//
// Fake node used for testing end-of-line potential breakpoint
//
var MO = MML.mo().With({HTMLspanElement: function () {return {bbox: {w:0}, style: {}}}});
//
// 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({
HTMLlinebreakPenalty: PENALTY,
/****************************************************************/
//
// Handle breaking an mrow into separate lines
//
HTMLmultiline: function (span) {
//
// Find the parent element and mark it as multiline
//
var parent = this;
while (parent.inferred || (parent.parent && parent.parent.type === "mrow" &&
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 = HTMLCSS.length2em(VALUES.lineleading,1,0.5);
//
// Remove old color and break the span at its best line breaks
//
this.HTMLremoveColor(span);
var stack = HTMLCSS.createStack(span);
this.HTMLgetScale();
var state = {
n: 0, Y: 0,
scale: this.scale || 1,
isTop: isTop,
values: {},
VALUES: VALUES
},
align = this.HTMLgetAlign(state,{}),
shift = this.HTMLgetShift(state,{},align),
start = [],
end = {
index:[], penalty:PENALTY.nobreak,
w:0, W:shift, shift:shift, scanW:shift,
nest: 0
},
broken = false;
while (this.HTMLbetterBreak(end,state,true) &&
(end.scanW >= HTMLCSS.linebreakWidth || end.penalty === PENALTY.newline)) {
this.HTMLaddLine(stack,start,end.index,state,end.values,broken);
start = end.index.slice(0); broken = true;
align = this.HTMLgetAlign(state,end.values);
shift = this.HTMLgetShift(state,end.values,align);
if (align === MML.INDENTALIGN.CENTER) {shift = 0}
end.W = end.shift = end.scanW = shift; end.penalty = PENALTY.nobreak;
}
state.isLast = true;
this.HTMLaddLine(stack,start,[],state,ENDVALUES,broken);
//
// Make top-level spans 100% wide.
// Finish up the space and add the color again
//
if (parent.type === "math") {stack.style.width = span.bbox.width = "100%"}
this.HTMLhandleSpace(span);
this.HTMLhandleColor(span);
span.bbox.isMultiline = true;
return span;
},
/****************************************************************/
//
// Locate the next linebreak that is better than the current one
//
HTMLbetterBreak: function (info,state,toplevel) {
if (this.isToken) {return false} // FIXME: handle breaking of token elements
if (this.isEmbellished()) {
info.embellished = this;
return this.CoreMO().HTMLbetterBreak(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*HTMLCSS.linebreakWidth || info.w === 0)) {
if (this.data[i]) {
if (this.data[i].HTMLbetterBreak(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.HTMLaddWidth(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.HTMLbetterBreak(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;
},
HTMLaddWidth: function (i,info,scanW) {
if (this.data[i]) {
var span = this.data[i].HTMLspanElement();
scanW += span.bbox.w;
if (span.style.paddingLeft) {scanW += HTMLCSS.unEm(span.style.paddingLeft)}
if (span.style.paddingRight) {scanW += HTMLCSS.unEm(span.style.paddingRight)}
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
//
HTMLaddLine: 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
//
line = HTMLCSS.createBox(stack);
line.bbox = this.HTMLemptyBBox({});
state.first = broken; state.last = true;
this.HTMLmoveLine(start,end,line,state,values);
this.HTMLcleanBBox(line.bbox);
//
// Get the alignment and shift values
//
var align = this.HTMLgetAlign(state,values),
shift = this.HTMLgetShift(state,values,align);
//
// Set the Y offset based on previous depth, leading, and current height
//
if (state.n > 0) {
var LHD = HTMLCSS.FONTDATA.baselineskip * state.scale;
var leading = (state.values.lineleading == null ? state.VALUES : state.values).lineleading * state.scale;
state.Y -= Math.max(LHD,state.d + line.bbox.h + leading);
}
//
// Place the new line
//
HTMLCSS.alignBox(line,align,state.Y,shift);
//
// Save the values needed for the future
//
state.d = line.bbox.d; state.values = values; state.n++;
},
/****************************************************************/
//
// Get alignment and shift values from the given data
//
HTMLgetAlign: 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 ? this.displayAlign : MML.INDENTALIGN.LEFT)}
return align;
},
HTMLgetShift: function (state,values,align) {
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 = HTMLCSS.length2em(shift,1,HTMLCSS.cwidth);
if (state.isTop && this.displayIndent !== "0") {
var indent = HTMLCSS.length2em(this.displayIndent,1,HTMLCSS.cwidth);
shift += (align === MML.INDENTALIGN.RIGHT ? -indent : indent);
}
return shift;
},
/****************************************************************/
//
// Move the selected elements into the new line's span,
// moving whole items when possible, and parts of ones
// that are split by a line break.
//
HTMLmoveLine: function (start,end,span,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].HTMLmoveSlice(start.slice(1),end.slice(1),span,state,values,"paddingLeft");
} 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].HTMLmoveSpan(span,state,values)}
else {this.data[i].HTMLmoveSlice(start.slice(1),[],span,state,values,"paddingLeft")}
}
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].HTMLmoveSpan(span,state,values)}
else {this.data[i].HTMLmoveSlice([],end.slice(1),span,state,values,"paddingRight")}
}
}
},
/****************************************************************/
//
// Split an element and copy the selected items into the new part
//
HTMLmoveSlice: function (start,end,span,state,values,padding) {
//
// Get rid of color, if any (added back in later)
// Create a new span for the slice of the element
// Move the selected portion into the slice
// If it is the last slice
// Remove the original (now empty) span
// Rename the Continue-0 span with the original name (for HTMLspanElement)
// Add back the color
//
this.HTMLremoveColor();
var slice = this.HTMLcreateSliceSpan(span);
this.HTMLmoveLine(start,end,slice,state,values);
slice.style[padding] = "";
this.HTMLcombineBBoxes(slice,span.bbox);
this.HTMLcleanBBox(slice.bbox);
if (end.length === 0) {
span = this.HTMLspanElement();
var SPAN = span;
if (this.href) span = span.parentNode;
span.parentNode.removeChild(span);
span.nextMathJaxSpan.id = SPAN.id; var n = 0;
while ((SPAN = SPAN.nextMathJaxSpan)) {
if (SPAN.nodeName.toLowerCase() === "a") SPAN = SPAN.firstChild;
var color = this.HTMLhandleColor(SPAN);
if (color) {color.id += "-MathJax-Continue-"+n; n++}
}
}
return slice;
},
/****************************************************************/
//
// Create a new span for an element that is split in two
// Clone the original and update its ID.
// Link the old span to the new one so we can find it later
//
HTMLcreateSliceSpan: function (span) {
var SPAN = this.HTMLspanElement(), n = 0;
if (this.href) SPAN = SPAN.parentNode;
var LAST = SPAN; while (LAST.nextMathJaxSpan) {LAST = LAST.nextMathJaxSpan; n++}
var SLICE = SPAN.cloneNode(false); LAST.nextMathJaxSpan = SLICE; SLICE.nextMathJaxSpan = null;
SLICE.id += "-MathJax-Continue-"+n;
SLICE.bbox = this.HTMLemptyBBox({});
return span.appendChild(SLICE);
},
/****************************************************************/
//
// Move an element from its original span to its new location in
// a split element or the new line's span
//
HTMLmoveSpan: 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 color and span
//
var color = document.getElementById("MathJax-Color-"+this.spanID+HTMLCSS.idPostfix);
if (color) {line.appendChild(color)}
var span = this.HTMLspanElement();
if (this.href) span = span.parentNode;
line.appendChild(span);
//
// If it is last, remove right padding
// If it is first, remove left padding and recolor
//
if (state.last) {span.style.paddingRight = ""}
if (state.first || state.nextIsFirst) {
span.style.paddingLeft = "";
if (color) {this.HTMLremoveColor(span); this.HTMLhandleColor(span)}
}
if (state.first && span.bbox.w === 0) {state.nextIsFirst = true}
else {delete state.nextIsFirst}
//
// Update bounding box
//
this.HTMLcombineBBoxes(this,line.bbox);
}
}
});
/**************************************************************************/
MML.mfenced.Augment({
HTMLbetterBreak: 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*HTMLCSS.linebreakWidth || info.w === 0)) {
var k = this.dataI[i];
if (this.data[k]) {
if (this.data[k].HTMLbetterBreak(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.HTMLaddWidth(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;
},
HTMLmoveLine: function (start,end,span,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]].HTMLmoveSlice(start.slice(1),end.slice(1),span,state,values,"paddingLeft");
} 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].HTMLmoveSpan(span,state,values)}
else {this.data[k].HTMLmoveSlice(start.slice(1),[],span,state,values,"paddingLeft")}
}
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].HTMLmoveSpan(span,state,values)}
else {this.data[k].HTMLmoveSlice([],end.slice(1),span,state,values,"paddingRight")}
}
}
}
});
/**************************************************************************/
MML.msubsup.Augment({
HTMLbetterBreak: 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.HTMLbaseW = this.data[this.base].HTMLspanElement().bbox.w;
this.HTMLdw = this.HTMLspanElement().bbox.w - this.HTMLbaseW;
}
//
// Check if the base can be broken
//
if (this.data[this.base].HTMLbetterBreak(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.HTMLaddWidth(this.base,info,scanW)}
info.scanW += this.HTMLdw; info.W = info.scanW;
info.index = []; if (better) {info.W = W; info.w = w; info.index = index}
return better;
},
HTMLmoveLine: function (start,end,span,state,values) {
//
// Move the proper part of the base
//
if (this.data[this.base]) {
if (start.length > 1) {
this.data[this.base].HTMLmoveSlice(start.slice(1),end.slice(1),span,state,values,"paddingLeft");
} else {
if (end.length <= 1) {this.data[this.base].HTMLmoveSpan(span,state,values)}
else {this.data[this.base].HTMLmoveSlice([],end.slice(1),span,state,values,"paddingRight")}
}
}
//
// If this is the end, check for super and subscripts, and move those
// by moving the stack that contains them, and shifting by the amount of the
// base that has been removed. Remove the empty base box from the stack.
//
if (end.length === 0) {
var s = this.data[this.sup] || this.data[this.sub];
if (s && this.HTMLnotEmpty(s)) {
var box = s.HTMLspanElement().parentNode;
if (s.href) box = box.parentNode;
var stack = box.parentNode;
if (this.data[this.base]) {
var ic = this.data[this.base].HTMLspanElement().bbox.ic;
if (ic) stack.style.marginLeft = HTMLCSS.Em(-ic);
stack.removeChild(stack.firstChild);
}
for (box = stack.firstChild; box; box = box.nextSibling)
{box.style.left = HTMLCSS.Em(HTMLCSS.unEm(box.style.left)-this.HTMLbaseW)}
stack.bbox.w -= this.HTMLbaseW; stack.style.width = HTMLCSS.Em(stack.bbox.w);
this.HTMLcombineBBoxes(stack,span.bbox);
span.appendChild(stack);
}
}
}
});
/**************************************************************************/
MML.mmultiscripts.Augment({
HTMLbetterBreak: 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.HTMLspanElement().bbox,
base = this.data[this.base].HTMLspanElement().bbox;
var dw = bbox.w - base.w;
//
// Add in the prescripts
//
info.scanW += bbox.dx; scanW = info.scanW;
//
// Check if the base can be broken
//
if (this.data[this.base].HTMLbetterBreak(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.HTMLaddWidth(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;
},
HTMLmoveLine: function (start,end,span,state,values) {
var SPAN = this.HTMLspanElement(), data = SPAN.bbox,
stack = SPAN.firstChild, BOX = {};
if (HTMLCSS.msiePaddingWidthBug) {stack = stack.nextSibling}
var box = stack.firstChild;
//
// Get the boxes for the scripts (if any)
//
while (box) {
if (box.bbox && box.bbox.name) {BOX[box.bbox.name] = box}
box = box.nextSibling;
}
//
// If this is the start, move the prescripts, if any.
//
if (start.length < 1) {
if (BOX.presub || BOX.presup) {
var STACK = HTMLCSS.createStack(span);
if (BOX.presup) {
HTMLCSS.addBox(STACK,BOX.presup);
HTMLCSS.placeBox(BOX.presup,data.dx-BOX.presup.bbox.w,data.u);
}
if (BOX.presub) {
HTMLCSS.addBox(STACK,BOX.presub);
HTMLCSS.placeBox(BOX.presub,data.dx+data.delta-BOX.presub.bbox.w,-data.v);
}
this.HTMLcombineBBoxes(STACK,span.bbox);
span.appendChild(STACK);
STACK.style.width = HTMLCSS.Em(data.dx);
}
}
//
// Move the proper part of the base
//
if (this.data[this.base]) {
if (start.length > 1) {
this.data[this.base].HTMLmoveSlice(start.slice(1),end.slice(1),span,state,values,"paddingLeft");
} else {
if (end.length <= 1) {this.data[this.base].HTMLmoveSpan(span,state,values)}
else {this.data[this.base].HTMLmoveSlice([],end.slice(1),span,state,values,"paddingRight")}
}
}
//
// If this is the end, check for super and subscripts, and move those
// by moving the stack that contains them, and shifting by the amount of the
// base that has been removed. Remove the empty base box from the stack.
//
if (end.length === 0) {
if (this.data[this.base]) {stack.removeChild(stack.firstChild)}
for (box = stack.firstChild; box; box = box.nextSibling)
{box.style.left = HTMLCSS.Em(HTMLCSS.unEm(box.style.left)-data.px)}
stack.bbox.w -= data.px; stack.style.width = HTMLCSS.Em(stack.bbox.w);
this.HTMLcombineBBoxes(stack,span.bbox);
span.appendChild(stack);
}
}
});
/**************************************************************************/
MML.mo.Augment({
//
// Override the method for checking line breaks to properly handle <mo>
//
HTMLbetterBreak: function (info,state) {
if (info.values && info.values.id === this.spanID) {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, mo = (info.embellished||this); delete info.embellished;
var span = mo.HTMLspanElement(), w = span.bbox.w;
if (span.style.paddingLeft) {w += HTMLCSS.unEm(span.style.paddingLeft)}
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 = HTMLCSS.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.HTMLgetAlign(state,values),
shift = this.HTMLgetShift(state,values,align);
offset += (info.shift - shift);
}
//
var penalty = Math.floor(offset / HTMLCSS.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 = HTMLCSS.length2em(values.lineleading,1,state.VALUES.lineleading);
values.id = this.spanID;
return true;
}
});
/**************************************************************************/
MML.mspace.Augment({
//
// Override the method for checking line breaks to properly handle <mspace>
//
HTMLbetterBreak: function (info,state) {
if (info.values && info.values.id === this.spanID) {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, span = this.HTMLspanElement(), w = span.bbox.w;
if (span.style.paddingLeft) {w += HTMLCSS.unEm(span.style.paddingLeft)}
if (W - info.shift === 0) {return false} // don't break at zero width (FIXME?)
var offset = HTMLCSS.linebreakWidth - W;
//
var penalty = Math.floor(offset / HTMLCSS.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.spanID;
return true;
}
});
//
// Hook into the mathchoice extension
//
MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () {
MML.TeXmathchoice.Augment({
HTMLbetterBreak: function (info,state) {
return this.Core().HTMLbetterBreak(info,state);
},
HTMLmoveLine: function (start,end,span,state,values) {
return this.Core().HTMLmoveSlice(start,end,span,state,values);
}
});
});
//
// Have maction process only the selected item
//
MML.maction.Augment({
HTMLbetterBreak: function (info,state) {
return this.Core().HTMLbetterBreak(info,state);
},
HTMLmoveLine: function (start,end,span,state,values) {
return this.Core().HTMLmoveSlice(start,end,span,state,values);
},
//
// Split and move the hit boxes as well
//
HTMLmoveSlice: function (start,end,span,state,values,padding) {
var hitbox = document.getElementById("MathJax-HitBox-"+this.spanID+HTMLCSS.idPostfix);
if (hitbox) {hitbox.parentNode.removeChild(hitbox)}
var slice = this.SUPER(arguments).HTMLmoveSlice.apply(this,arguments);
if (end.length === 0) {
span = this.HTMLspanElement(); var n = 0;
while (span) {
hitbox = this.HTMLhandleHitBox(span,"-Continue-"+n);
span = span.nextMathJaxSpan; n++;
}
}
return slice;
}
});
//
// Have semantics only do the first element
// (FIXME: do we need to do anything special about annotation-xml?)
//
MML.semantics.Augment({
HTMLbetterBreak: function (info,state) {
return (this.data[0] ? this.data[0].HTMLbetterBreak(info,state) : false);
},
HTMLmoveLine: function (start,end,span,state,values) {
return (this.data[0] ? this.data[0].HTMLmoveSlice(start,end,span,state,values) : null);
}
});
/**************************************************************************/
MathJax.Hub.Startup.signal.Post("HTML-CSS multiline Ready");
MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/multiline.js");
});

BIN
web/assets/MathJax/unpacked/jax/output/HTML-CSS/blank.gif vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 43 B

176
web/assets/MathJax/unpacked/jax/output/HTML-CSS/config.js vendored Normal file
View File

@@ -0,0 +1,176 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/config.js
*
* Initializes the HTML-CCS OutputJax (the main definition is in
* MathJax/jax/input/HTML-CSS/jax.js, which is loaded when needed).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.OutputJax["HTML-CSS"] = MathJax.OutputJax({
id: "HTML-CSS",
version: "2.7.8",
directory: MathJax.OutputJax.directory + "/HTML-CSS",
extensionDir: MathJax.OutputJax.extensionDir + "/HTML-CSS",
autoloadDir: MathJax.OutputJax.directory + "/HTML-CSS/autoload",
fontDir: MathJax.OutputJax.directory + "/HTML-CSS/fonts", // font name added later
webfontDir: MathJax.OutputJax.fontDir + "/HTML-CSS", // font name added later
config: {
noReflows: true, // true uses internal measurements to avoid browser reflows
matchFontHeight: true, // try to match math font height to surrounding font?
scale: 100, minScaleAdjust: 50, // global math scaling factor, and minimum adjusted scale factor
availableFonts: ["STIX","TeX"], // list of local fonts to check for
preferredFont: "TeX", // preferred local font (TeX or STIX)
webFont: "TeX", // web-based font to use when no local fonts found (TeX is only choice)
imageFont: "TeX", // font to use for image fallback mode (TeX is only choice)
undefinedFamily: "STIXGeneral,'Arial Unicode MS',serif", // fonts to use for unknown unicode characters
mtextFontInherit: false, // to make <mtext> be in page font rather than MathJax font
EqnChunk: (MathJax.Hub.Browser.isMobile ? 10: 50),
// 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
},
styles: {
".MathJax_Display": {
"text-align": "center",
margin: "1em 0em"
},
".MathJax .merror": {
"background-color": "#FFFF88",
color: "#CC0000",
border: "1px solid #CC0000",
padding: "1px 3px",
"font-style": "normal",
"font-size": "90%"
},
//
// For mtextFontInherit version of \texttt{}
//
".MathJax .MJX-monospace": {
"font-family": "monospace"
},
//
// For mtextFontInherit version of \textsf{}
//
".MathJax .MJX-sans-serif": {
"font-family": "sans-serif"
},
"#MathJax_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", // Forefox 3.5
"-khtml-box-shadow": "2px 2px 5px #AAAAAA", // Konqueror
filter: "progid:DXImageTransform.Microsoft.dropshadow(OffX=2, OffY=2, Color='gray', Positive='true')", // IE
padding: "3px 4px",
"z-index": 401
}
}
}
});
if (MathJax.Hub.Browser.isMSIE && document.documentMode >= 9)
{delete MathJax.OutputJax["HTML-CSS"].config.styles["#MathJax_Tooltip"].filter}
if (!MathJax.Hub.config.delayJaxRegistration)
{MathJax.OutputJax["HTML-CSS"].Register("jax/mml")}
MathJax.Hub.Register.StartupHook("End Config",[function (HUB,HTMLCSS) {
var CONFIG = HUB.Insert({
//
// The minimum versions that HTML-CSS supports
//
minBrowserVersion: {
Firefox: 3.0,
Opera: 9.52,
MSIE: 6.0,
Chrome: 0.3,
Safari: 2.0,
Konqueror: 4.0
},
//
// For unsupported browsers, put back these delimiters for the preview
//
inlineMathDelimiters: ['$','$'], // or ["",""] or ["\\(","\\)"]
displayMathDelimiters: ['$$','$$'], // or ["",""] or ["\\[","\\]"]
//
// For displayed math, insert <BR> for \n?
//
multilineDisplay: true,
//
// The function to call to display the math for unsupported browsers
//
minBrowserTranslate: function (script) {
var MJ = HUB.getJaxFor(script), text = ["[Math]"], delim;
var span = document.createElement("span",{className: "MathJax_Preview"});
if (MJ.inputJax === "TeX") {
if (MJ.root.Get("displaystyle")) {
delim = CONFIG.displayMathDelimiters;
text = [delim[0]+MJ.originalText+delim[1]];
if (CONFIG.multilineDisplay) text = text[0].split(/\n/);
} else {
delim = CONFIG.inlineMathDelimiters;
text = [delim[0]+MJ.originalText.replace(/^\s+/,"").replace(/\s+$/,"")+delim[1]];
}
}
for (var i = 0, m = text.length; i < m; i++) {
span.appendChild(document.createTextNode(text[i]));
if (i < m-1) {span.appendChild(document.createElement("br"))}
}
script.parentNode.insertBefore(span,script);
}
},(HUB.config["HTML-CSS"]||{}));
if (HUB.Browser.version !== "0.0" &&
!HUB.Browser.versionAtLeast(CONFIG.minBrowserVersion[HUB.Browser]||0.0)) {
HTMLCSS.Translate = CONFIG.minBrowserTranslate;
HUB.Config({showProcessingMessages: false});
MathJax.Message.Set(["MathJaxNotSupported",
"Your browser does not support MathJax"],null,4000);
HUB.Startup.signal.Post("MathJax not supported");
}
},MathJax.Hub,MathJax.OutputJax["HTML-CSS"]]);
MathJax.OutputJax["HTML-CSS"].loadComplete("config.js");

170
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Alphabets/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,170 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Alphabets/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Alphabets'] = {
directory: 'Alphabets/Regular',
family: 'AsanaMathJax_Alphabets',
testString: '\u0384\u0385\u0386\u0387\u0388\u0389\u038A\u038C\u038E\u038F\u0390\u03AA\u03AB\u03AC\u03AD',
0x20: [0,0,249,0,0],
0x384: [685,-476,374,134,241],
0x385: [685,-476,332,-6,339],
0x386: [700,3,777,15,756],
0x387: [453,-327,216,45,172],
0x388: [692,3,755,22,717],
0x389: [692,3,987,22,966],
0x38A: [692,3,476,22,455],
0x38C: [709,20,863,22,842],
0x38E: [691,4,854,3,855],
0x38F: [709,6,904,34,871],
0x390: [730,16,318,15,360],
0x3AA: [819,3,388,22,367],
0x3AB: [819,4,733,3,735],
0x3AC: [730,16,594,44,571],
0x3AD: [730,13,480,69,436],
0x3AE: [730,275,531,-11,464],
0x3AF: [730,16,310,94,305],
0x3B0: [730,12,547,13,490],
0x3CA: [645,16,310,15,360],
0x3CB: [645,12,547,13,490],
0x3CC: [730,20,545,32,514],
0x3CD: [730,12,547,13,490],
0x3CE: [730,12,715,36,659],
0x13A0: [692,4,793,22,751],
0x13A1: [692,3,667,22,669],
0x13A2: [692,3,612,18,595],
0x13A3: [699,-3,813,26,776],
0x13A4: [689,20,729,29,702],
0x13A5: [687,3,290,21,271],
0x13A6: [709,20,835,26,809],
0x13A7: [748,-49,647,27,617],
0x13A8: [692,3,577,22,559],
0x13A9: [692,0,709,50,675],
0x13AA: [700,3,777,15,756],
0x13AB: [692,196,509,22,487],
0x13AC: [692,3,610,22,572],
0x13AD: [697,3,785,27,758],
0x13AE: [689,3,519,22,499],
0x13AF: [693,0,602,20,577],
0x13B0: [692,3,505,22,483],
0x13B1: [692,3,555,22,536],
0x13B2: [687,1,806,14,781],
0x13B3: [692,9,967,8,956],
0x13B4: [674,20,878,32,846],
0x13B5: [692,3,555,22,580],
0x13B6: [710,20,730,22,692],
0x13B7: [692,13,1004,16,985],
0x13B8: [725,195,572,23,538],
0x13B9: [692,-4,920,11,908],
0x13BA: [709,20,1105,22,1073],
0x13BB: [692,3,831,22,810],
0x13BC: [692,19,525,27,493],
0x13BD: [692,-2,759,27,730],
0x13BE: [709,20,786,22,764],
0x13BF: [691,210,579,14,550],
0x13C0: [710,20,839,22,805],
0x13C1: [697,11,662,19,634],
0x13C2: [790,3,581,6,572],
0x13C3: [692,3,666,15,638],
0x13C4: [700,-2,616,24,583],
0x13C5: [708,21,1018,23,991],
0x13C6: [689,-4,466,25,441],
0x13C7: [691,12,715,41,671],
0x13C8: [692,4,525,29,509],
0x13C9: [705,6,1186,22,1168],
0x13CA: [652,12,715,38,671],
0x13CB: [710,20,547,30,524],
0x13CC: [692,20,778,12,759],
0x13CD: [698,20,839,19,814],
0x13CE: [698,3,563,2,534],
0x13CF: [692,3,603,22,580],
0x13D0: [692,3,526,14,507],
0x13D1: [693,11,549,10,514],
0x13D2: [692,3,696,22,674],
0x13D3: [692,195,509,22,487],
0x13D4: [693,6,869,9,859],
0x13D5: [709,20,578,24,544],
0x13D6: [692,3,665,30,633],
0x13D7: [692,11,466,10,446],
0x13D8: [691,0,447,15,427],
0x13D9: [693,6,681,8,661],
0x13DA: [709,19,525,24,503],
0x13DB: [692,36,725,18,716],
0x13DC: [719,33,674,25,649],
0x13DD: [693,0,500,12,478],
0x13DE: [692,3,611,22,586],
0x13DF: [733,20,709,22,664],
0x13E0: [692,196,647,26,625],
0x13E1: [722,13,902,32,884],
0x13E2: [692,3,604,22,580],
0x13E3: [710,20,764,22,742],
0x13E4: [692,0,636,10,606],
0x13E5: [692,3,680,22,658],
0x13E6: [692,3,726,22,692],
0x13E7: [692,-6,491,14,469],
0x13E8: [688,16,875,22,854],
0x13E9: [719,11,712,21,684],
0x13EA: [692,9,981,10,959],
0x13EB: [709,20,786,22,764],
0x13EC: [694,22,922,4,908],
0x13ED: [693,0,577,20,552],
0x13EE: [690,20,496,28,467],
0x13EF: [693,20,785,20,755],
0x13F0: [677,158,512,7,486],
0x13F1: [691,-2,596,27,565],
0x13F2: [728,3,590,23,567],
0x13F3: [759,9,840,22,814],
0x13F4: [692,3,610,26,576],
0x2100: [436,72,719,29,691],
0x2101: [436,72,719,34,686],
0x2103: [709,20,899,27,873],
0x2105: [436,72,719,24,696],
0x2106: [436,72,729,18,712],
0x2107: [719,5,549,23,527],
0x2109: [707,3,755,22,734],
0x2116: [692,20,1108,17,1076],
0x2117: [705,164,906,18,889],
0x211E: [692,15,667,22,669],
0x2120: [668,-273,834,23,823],
0x2121: [692,3,1099,33,1067],
0x2122: [659,-282,929,15,917],
0x2126: [704,6,824,34,791],
0x2129: [473,16,310,94,304],
0x212A: [692,3,725,22,719],
0x212B: [943,3,777,15,756],
0x212E: [535,17,599,44,561],
0x2139: [706,3,332,34,298],
0x213A: [638,104,919,18,902],
0x213B: [692,3,1099,28,1072],
0x2142: [694,0,540,68,473],
0x2143: [694,0,540,68,473],
0x2144: [694,0,665,3,663],
0x214B: [689,21,777,43,753],
0x214D: [663,56,777,39,739],
0x214E: [456,4,418,33,390],
0x10143: [700,0,671,55,630],
0x10144: [700,0,671,55,630],
0x10145: [700,0,671,55,630],
0x10146: [700,0,671,55,630],
0x10147: [700,0,671,55,630]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Alphabets"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Alphabets/Regular/Main.js"]
);

220
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Arrows/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,220 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Arrows/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Arrows'] = {
directory: 'Arrows/Regular',
family: 'AsanaMathJax_Arrows',
testString: '\u219C\u219D\u219F\u21A1\u21A4\u21A5\u21A7\u21A8\u21AF\u21B2\u21B3\u21B4\u21B5\u21B8\u21B9',
0x20: [0,0,249,0,0],
0x219C: [486,-55,1061,62,1062],
0x219D: [486,-55,1061,-3,997],
0x219F: [712,172,524,47,478],
0x21A1: [712,172,524,47,478],
0x21A4: [486,-55,1013,36,978],
0x21A5: [742,200,524,47,478],
0x21A7: [742,200,524,47,478],
0x21A8: [712,200,524,47,480],
0x21AF: [476,222,524,20,504],
0x21B2: [753,0,506,65,442],
0x21B3: [753,0,506,65,442],
0x21B4: [565,-140,714,24,691],
0x21B5: [686,-19,524,50,475],
0x21B8: [785,172,1013,64,950],
0x21B9: [688,-20,899,51,849],
0x21C5: [712,172,883,48,836],
0x21D6: [724,246,1101,65,1037],
0x21D7: [724,246,1101,65,1037],
0x21D8: [724,246,1101,65,1037],
0x21D9: [724,246,1101,65,1037],
0x21DC: [485,-54,1149,34,1116],
0x21DE: [712,172,524,47,478],
0x21DF: [712,172,524,47,478],
0x21E1: [737,196,524,47,478],
0x21E3: [737,196,524,47,478],
0x21E4: [499,-31,899,51,849],
0x21E5: [500,-32,899,51,849],
0x21E6: [554,12,1013,64,950],
0x21E7: [713,172,678,56,622],
0x21E8: [554,12,1013,64,950],
0x21E9: [713,172,678,56,622],
0x21EA: [713,172,678,56,622],
0x21EB: [713,199,678,56,622],
0x21EC: [713,199,678,56,622],
0x21ED: [713,200,678,48,631],
0x21EE: [856,172,678,56,622],
0x21EF: [834,199,678,56,622],
0x21F0: [555,11,989,39,951],
0x21F1: [750,208,1019,25,988],
0x21F2: [750,208,1019,25,988],
0x21F3: [713,172,678,56,622],
0x21F4: [504,-33,1089,27,1063],
0x21F5: [712,172,883,48,836],
0x21F6: [845,305,1013,65,949],
0x21F7: [487,-56,1013,65,949],
0x21F8: [486,-55,1013,65,949],
0x21F9: [486,-55,1013,65,949],
0x21FA: [486,-55,913,72,842],
0x21FB: [486,-55,913,72,842],
0x21FC: [488,-57,1013,65,949],
0x21FD: [509,-38,1013,65,949],
0x21FE: [509,-38,1013,65,949],
0x21FF: [509,-38,1013,53,961],
0x27F0: [713,173,1013,130,884],
0x27F1: [713,173,1013,130,884],
0x27F2: [759,0,987,73,929],
0x27F3: [759,0,987,72,929],
0x27F4: [524,-17,1013,65,949],
0x27FB: [486,-55,1513,36,1478],
0x27FD: [537,-5,1513,65,1449],
0x27FE: [537,-5,1513,65,1449],
0x27FF: [486,-55,1513,38,1476],
0x2900: [486,-55,1013,65,949],
0x2901: [486,-55,1013,65,949],
0x2902: [537,-6,1013,65,949],
0x2903: [537,-6,1013,65,949],
0x2904: [537,-6,1013,59,954],
0x2905: [486,-55,1013,65,949],
0x2906: [537,-5,1013,65,949],
0x2907: [537,-5,1013,65,949],
0x2908: [712,172,559,65,495],
0x2909: [712,172,559,65,495],
0x290A: [712,172,803,65,739],
0x290B: [713,171,803,65,739],
0x290C: [486,-55,1013,65,949],
0x290D: [486,-55,1013,65,949],
0x290E: [486,-55,1013,65,949],
0x290F: [486,-55,1013,65,949],
0x2910: [486,-55,1150,27,1124],
0x2911: [486,-55,1211,63,1147],
0x2912: [667,131,559,87,473],
0x2913: [667,131,559,87,473],
0x2914: [489,-58,1150,28,1123],
0x2915: [486,-55,1150,86,1066],
0x2916: [486,-55,1150,28,1122],
0x2917: [486,-55,1150,28,1123],
0x2918: [486,-55,1150,28,1123],
0x2919: [486,-55,1009,57,953],
0x291A: [486,-55,1009,57,953],
0x291B: [486,-55,1059,65,996],
0x291C: [486,-55,1059,65,996],
0x291D: [488,-57,1369,66,1304],
0x291E: [488,-57,1369,66,1304],
0x291F: [490,-59,1426,66,1362],
0x2920: [490,-59,1426,66,1362],
0x2921: [715,173,1013,63,951],
0x2922: [715,173,1013,63,951],
0x2923: [803,175,1013,76,938],
0x2924: [803,175,1013,76,939],
0x2925: [802,176,1013,76,939],
0x2926: [802,176,1013,76,938],
0x2927: [713,172,1013,65,949],
0x2928: [712,172,1013,64,950],
0x2929: [713,172,1013,65,949],
0x292A: [712,172,1013,64,950],
0x292B: [648,172,1013,65,949],
0x292C: [648,172,1013,65,949],
0x292D: [713,172,1013,64,950],
0x292E: [712,172,1013,65,950],
0x292F: [712,172,1013,65,950],
0x2930: [713,172,1013,65,950],
0x2931: [714,172,1013,64,950],
0x2932: [714,172,1013,64,950],
0x2933: [484,-53,961,-3,902],
0x2934: [585,-76,729,54,676],
0x2935: [588,-80,729,54,676],
0x2936: [622,0,729,111,622],
0x2937: [622,0,729,110,619],
0x2938: [643,117,559,105,454],
0x2939: [643,117,559,105,455],
0x293A: [446,-97,869,55,815],
0x293B: [447,-97,869,55,815],
0x293C: [446,-97,869,55,815],
0x293D: [446,-95,869,55,815],
0x293E: [580,62,887,63,825],
0x293F: [580,62,887,62,825],
0x2940: [698,164,987,121,885],
0x2941: [702,160,987,120,883],
0x2942: [665,124,1013,65,949],
0x2943: [665,124,1013,65,949],
0x2944: [665,124,1013,65,949],
0x2945: [665,-98,1013,65,949],
0x2946: [665,-98,1013,65,949],
0x2947: [486,-55,1013,65,949],
0x2948: [504,-33,1260,54,1207],
0x2949: [761,219,541,56,486],
0x294A: [381,52,1013,65,949],
0x294B: [381,52,1013,65,949],
0x294C: [713,171,559,63,497],
0x294D: [713,171,559,63,497],
0x294E: [194,52,1013,65,949],
0x294F: [713,171,459,107,353],
0x2950: [194,52,1013,65,949],
0x2951: [713,171,459,107,353],
0x2952: [489,-21,899,51,849],
0x2953: [489,-21,899,51,849],
0x2954: [667,131,559,46,514],
0x2955: [667,131,559,46,514],
0x2956: [496,-28,899,51,849],
0x2957: [489,-21,899,51,849],
0x2958: [667,131,559,46,514],
0x2959: [667,131,559,46,514],
0x295A: [486,-55,1013,29,985],
0x295B: [486,-55,1013,29,985],
0x295C: [761,195,524,47,478],
0x295D: [761,195,524,47,478],
0x295E: [486,-55,1013,29,985],
0x295F: [486,-55,1013,29,985],
0x2960: [761,195,524,47,478],
0x2961: [761,195,524,47,478],
0x2962: [594,52,1013,65,949],
0x2963: [713,171,759,57,703],
0x2964: [594,52,1013,65,949],
0x2965: [713,171,759,57,703],
0x2966: [594,52,1013,65,949],
0x2967: [560,19,1013,65,949],
0x2968: [627,19,1013,65,949],
0x2969: [627,19,1013,65,949],
0x296A: [594,-135,1013,65,949],
0x296B: [594,-135,1013,65,949],
0x296C: [594,-135,1013,65,949],
0x296D: [594,-135,1013,65,949],
0x296E: [713,171,759,57,703],
0x296F: [713,171,759,57,703],
0x2970: [407,-140,1013,51,963],
0x2971: [613,-41,1013,65,949],
0x2972: [486,-55,1013,65,949],
0x2973: [486,-55,1013,65,949],
0x2974: [486,-55,1013,65,949],
0x2975: [486,136,1013,65,949],
0x2976: [695,154,1013,65,949],
0x2977: [535,-7,1013,65,960],
0x2978: [695,154,1013,65,949],
0x2979: [723,179,1013,65,949],
0x297A: [535,-10,1013,65,957],
0x297B: [723,179,1013,65,949],
0x297C: [576,35,803,65,739],
0x297D: [576,35,803,65,739],
0x297E: [608,66,743,66,678],
0x297F: [608,66,743,66,678]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Arrows"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Arrows/Regular/Main.js"]
);

102
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/DoubleStruck/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,102 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/DoubleStruck/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_DoubleStruck'] = {
directory: 'DoubleStruck/Regular',
family: 'AsanaMathJax_DoubleStruck',
testString: '\u2102\u210D\u2115\u2119\u211A\u211D\u2124\u213C\u213D\u213E\u213F\u2140\u2145\u2146\u2147',
0x20: [0,0,249,0,0],
0x2102: [709,20,708,22,669],
0x210D: [692,3,948,22,927],
0x2115: [692,3,951,17,934],
0x2119: [692,3,720,22,697],
0x211A: [709,176,785,22,764],
0x211D: [692,3,784,22,786],
0x2124: [692,3,816,15,788],
0x213C: [525,15,718,10,688],
0x213D: [485,230,494,-10,466],
0x213E: [692,3,727,22,703],
0x213F: [692,3,899,27,873],
0x2140: [696,1,645,30,618],
0x2145: [692,3,898,-39,888],
0x2146: [694,10,667,-7,707],
0x2147: [463,20,546,24,522],
0x2148: [669,0,388,-17,298],
0x2149: [669,210,409,-98,353],
0x1D538: [700,3,887,15,866],
0x1D539: [692,3,739,26,705],
0x1D53B: [692,3,898,22,876],
0x1D53C: [692,3,727,22,689],
0x1D53D: [692,3,672,22,653],
0x1D53E: [709,20,762,22,728],
0x1D540: [692,3,453,22,432],
0x1D541: [692,194,440,-15,419],
0x1D542: [692,3,842,22,836],
0x1D543: [692,3,727,22,703],
0x1D544: [692,13,1066,16,1047],
0x1D546: [709,20,785,22,764],
0x1D54A: [709,20,524,24,503],
0x1D54B: [694,3,737,18,720],
0x1D54C: [692,22,907,12,889],
0x1D54D: [692,9,851,8,836],
0x1D54E: [700,9,1119,8,1104],
0x1D54F: [700,3,783,14,765],
0x1D550: [704,3,666,9,654],
0x1D552: [463,14,602,42,596],
0x1D553: [694,10,667,18,649],
0x1D554: [456,16,546,29,517],
0x1D555: [694,10,667,17,649],
0x1D556: [462,20,546,28,518],
0x1D557: [720,0,448,18,456],
0x1D558: [460,214,602,38,576],
0x1D559: [699,0,673,24,650],
0x1D55A: [669,0,388,42,346],
0x1D55B: [669,210,409,-35,316],
0x1D55C: [698,0,639,25,619],
0x1D55D: [690,0,390,44,372],
0x1D55E: [466,0,977,25,959],
0x1D55F: [457,0,684,27,665],
0x1D560: [462,11,602,27,572],
0x1D561: [442,194,681,29,666],
0x1D562: [442,194,681,22,660],
0x1D563: [442,0,509,27,497],
0x1D564: [454,14,496,32,463],
0x1D565: [615,11,499,23,482],
0x1D566: [442,11,699,23,675],
0x1D567: [441,11,669,17,653],
0x1D568: [437,12,889,17,844],
0x1D569: [431,0,704,15,676],
0x1D56A: [431,204,700,17,674],
0x1D56B: [447,0,560,12,548],
0x1D7D8: [689,16,600,28,568],
0x1D7D9: [689,3,600,44,556],
0x1D7DA: [679,3,600,30,570],
0x1D7DB: [679,17,600,36,564],
0x1D7DC: [689,3,600,50,550],
0x1D7DD: [675,17,600,27,573],
0x1D7DE: [679,17,600,29,571],
0x1D7DF: [675,3,600,29,571],
0x1D7E0: [679,17,600,38,562],
0x1D7E1: [679,17,600,38,562]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_DoubleStruck"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/DoubleStruck/Regular/Main.js"]
);

132
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Fraktur/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,132 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Fraktur/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Fraktur'] = {
directory: 'Fraktur/Regular',
family: 'AsanaMathJax_Fraktur',
testString: '\u210C\u2128\u212D\uD835\uDD04\uD835\uDD05\uD835\uDD07\uD835\uDD08\uD835\uDD09\uD835\uDD0A\uD835\uDD0D\uD835\uDD0E\uD835\uDD0F\uD835\uDD10\uD835\uDD11\uD835\uDD12',
0x20: [0,0,249,0,0],
0x210C: [719,166,697,29,657],
0x2128: [709,171,697,-7,608],
0x212D: [719,4,645,53,629],
0x1D504: [721,4,697,20,675],
0x1D505: [720,7,801,60,747],
0x1D507: [708,4,801,69,746],
0x1D508: [719,4,645,54,629],
0x1D509: [715,157,697,74,663],
0x1D50A: [721,4,801,88,740],
0x1D50D: [719,162,645,-1,586],
0x1D50E: [716,4,697,2,659],
0x1D50F: [719,4,645,37,603],
0x1D510: [714,4,957,11,936],
0x1D511: [716,6,748,16,716],
0x1D512: [707,4,801,42,754],
0x1D513: [721,163,801,37,715],
0x1D514: [706,4,801,41,800],
0x1D516: [706,4,801,103,757],
0x1D517: [707,4,697,42,688],
0x1D518: [720,4,697,49,683],
0x1D519: [714,4,801,48,705],
0x1D51A: [713,-2,957,25,931],
0x1D51B: [719,4,645,29,629],
0x1D51C: [719,165,748,19,641],
0x1D51E: [504,6,478,67,469],
0x1D51F: [683,9,478,23,436],
0x1D520: [500,4,374,85,356],
0x1D521: [696,4,478,54,447],
0x1D522: [503,5,426,78,392],
0x1D523: [719,162,322,27,293],
0x1D524: [505,163,478,54,443],
0x1D525: [696,165,478,25,438],
0x1D526: [703,4,270,32,258],
0x1D527: [705,169,270,32,229],
0x1D528: [702,4,322,21,308],
0x1D529: [696,5,270,42,265],
0x1D52A: [499,4,801,24,774],
0x1D52B: [499,4,530,16,518],
0x1D52C: [502,4,478,69,447],
0x1D52D: [505,161,530,68,496],
0x1D52E: [499,168,478,66,455],
0x1D52F: [504,4,374,17,362],
0x1D530: [500,6,426,56,409],
0x1D531: [696,6,322,19,293],
0x1D532: [501,4,530,25,513],
0x1D533: [496,4,478,28,434],
0x1D534: [501,4,748,46,708],
0x1D535: [503,4,426,31,402],
0x1D536: [505,163,530,36,465],
0x1D537: [505,165,374,39,344],
0x1D56C: [719,9,748,54,726],
0x1D56D: [715,7,748,52,723],
0x1D56E: [718,8,697,77,667],
0x1D56F: [715,8,697,51,668],
0x1D570: [719,8,697,63,684],
0x1D571: [719,167,645,37,633],
0x1D572: [718,9,801,76,756],
0x1D573: [718,167,748,33,709],
0x1D574: [718,11,645,29,611],
0x1D575: [719,167,645,16,609],
0x1D576: [718,14,748,14,732],
0x1D577: [718,11,593,32,556],
0x1D578: [719,15,968,16,952],
0x1D579: [719,11,801,53,785],
0x1D57A: [718,7,697,69,681],
0x1D57B: [719,167,748,47,749],
0x1D57C: [717,11,759,52,748],
0x1D57D: [719,11,801,49,782],
0x1D57E: [719,5,697,62,672],
0x1D57F: [716,8,645,71,632],
0x1D580: [718,12,697,32,676],
0x1D581: [718,9,748,43,746],
0x1D582: [713,4,968,38,968],
0x1D583: [718,6,645,32,642],
0x1D584: [718,167,748,49,705],
0x1D585: [717,167,655,20,601],
0x1D586: [537,9,499,63,489],
0x1D587: [709,17,520,43,472],
0x1D588: [540,7,364,61,354],
0x1D589: [717,8,530,52,481],
0x1D58A: [541,11,416,49,411],
0x1D58B: [718,166,374,43,348],
0x1D58C: [536,167,478,43,466],
0x1D58D: [718,166,520,37,474],
0x1D58E: [719,11,312,22,302],
0x1D58F: [718,168,322,35,289],
0x1D590: [718,8,374,52,345],
0x1D591: [716,9,312,52,304],
0x1D592: [537,9,822,27,800],
0x1D593: [539,7,541,2,542],
0x1D594: [549,8,478,40,455],
0x1D595: [544,167,551,36,505],
0x1D596: [549,167,488,54,458],
0x1D597: [545,8,416,41,414],
0x1D598: [542,4,468,60,429],
0x1D599: [704,11,322,23,317],
0x1D59A: [543,11,530,24,529],
0x1D59B: [536,4,520,28,477],
0x1D59C: [546,6,748,32,709],
0x1D59D: [537,8,426,21,417],
0x1D59E: [536,166,478,25,447],
0x1D59F: [541,168,374,36,345]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Fraktur"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Fraktur/Regular/Main.js"]
);

109
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Latin/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,109 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Latin/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Latin'] = {
directory: 'Latin/Regular',
family: 'AsanaMathJax_Latin',
testString: '\u00A1\u00A2\u00A4\u00A6\u00A9\u00AA\u00AB\u00B2\u00B3\u00B6\u00B8\u00B9\u00BA\u00BB\u00BC',
0x20: [0,0,249,0,0],
0xA1: [469,225,277,81,197],
0xA2: [562,101,499,61,448],
0xA4: [531,-96,499,30,470],
0xA6: [713,172,210,76,135],
0xA9: [705,164,906,18,889],
0xAA: [709,-422,332,24,310],
0xAB: [428,-71,499,50,450],
0xB2: [686,-271,299,6,284],
0xB3: [686,-261,299,5,281],
0xB6: [694,150,627,39,589],
0xB8: [-10,225,332,96,304],
0xB9: [689,-271,299,32,254],
0xBA: [709,-416,332,10,323],
0xBB: [428,-71,499,50,450],
0xBC: [692,3,749,30,727],
0xBD: [692,3,749,15,735],
0xBE: [689,3,749,15,735],
0xBF: [469,231,443,43,395],
0xC0: [908,3,777,15,756],
0xC1: [908,3,777,15,756],
0xC2: [908,3,777,15,756],
0xC3: [871,3,777,15,756],
0xC4: [868,3,777,15,756],
0xC5: [943,3,777,15,756],
0xC6: [692,3,943,-10,908],
0xC7: [709,225,708,22,670],
0xC8: [908,3,610,22,572],
0xC9: [908,3,610,22,572],
0xCA: [908,3,610,22,572],
0xCB: [868,3,610,22,572],
0xCC: [908,3,336,22,315],
0xCD: [908,3,336,22,315],
0xCE: [908,3,336,13,325],
0xCF: [868,3,336,19,318],
0xD0: [692,3,773,14,751],
0xD1: [871,20,830,17,813],
0xD2: [908,20,785,22,764],
0xD3: [908,20,785,22,764],
0xD4: [908,20,785,22,764],
0xD5: [871,20,785,22,764],
0xD6: [868,20,785,22,764],
0xD8: [709,20,832,30,797],
0xD9: [908,20,777,12,759],
0xDA: [908,20,777,12,759],
0xDB: [908,20,777,12,759],
0xDC: [868,20,777,12,759],
0xDD: [908,3,666,9,654],
0xDE: [692,3,603,32,574],
0xDF: [731,9,555,23,519],
0xE0: [677,12,499,32,471],
0xE1: [677,12,499,32,471],
0xE2: [677,12,499,32,471],
0xE3: [640,12,499,32,471],
0xE4: [637,12,499,32,471],
0xE5: [712,12,499,32,471],
0xE6: [469,20,757,30,732],
0xE7: [469,225,443,26,413],
0xE8: [677,20,478,26,448],
0xE9: [677,20,478,26,448],
0xEA: [677,20,478,26,448],
0xEB: [637,20,478,26,448],
0xEC: [677,3,286,8,271],
0xED: [677,3,286,21,279],
0xEE: [677,3,286,-12,300],
0xEF: [657,3,286,-6,293],
0xF1: [640,3,581,6,572],
0xF2: [677,20,545,32,514],
0xF3: [677,20,545,32,514],
0xF4: [677,20,545,32,514],
0xF5: [640,20,545,32,514],
0xF6: [637,20,545,32,514],
0xF8: [474,23,555,16,530],
0xF9: [677,12,602,18,581],
0xFA: [677,12,602,18,581],
0xFB: [677,12,602,18,581],
0xFC: [637,12,602,18,581],
0xFD: [682,283,555,12,544],
0xFE: [726,281,600,-2,544],
0xFF: [637,283,555,12,544]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Latin"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Latin/Regular/Main.js"]
);

544
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Main/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,544 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Main/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Main'] = {
directory: 'Main/Regular',
family: 'AsanaMathJax_Main',
testString: '\u00A3\u00A5\u00A7\u00A8\u00AC\u00AE\u00B1\u00B5\u00B7\u00D7\u00F0\u00F7\u0131\u02C6\u02C7',
0x20: [0,0,249,0,0],
0x21: [694,5,277,81,197],
0x22: [709,-469,370,52,319],
0x23: [684,0,499,4,495],
0x24: [731,116,499,30,471],
0x25: [709,20,839,39,802],
0x26: [689,20,777,43,753],
0x27: [709,-446,277,45,233],
0x28: [726,215,332,60,301],
0x29: [726,215,332,32,273],
0x2A: [442,-95,388,32,359],
0x2B: [538,0,668,65,604],
0x2C: [123,155,249,16,218],
0x2D: [287,-215,332,18,314],
0x2E: [111,5,249,67,183],
0x2F: [714,169,286,-37,297],
0x30: [689,20,499,29,465],
0x31: [700,3,499,60,418],
0x32: [689,3,499,16,468],
0x33: [689,20,499,15,462],
0x34: [697,3,499,2,472],
0x35: [690,20,499,13,459],
0x36: [689,20,499,32,468],
0x37: [689,1,499,44,497],
0x38: [689,20,499,30,464],
0x39: [689,20,499,20,457],
0x3A: [456,5,249,66,182],
0x3B: [456,153,249,16,218],
0x3C: [528,0,668,65,604],
0x3D: [406,-134,668,65,604],
0x3E: [528,0,668,65,604],
0x3F: [694,5,443,43,395],
0x40: [694,20,746,24,724],
0x41: [700,3,777,15,756],
0x42: [692,3,610,26,576],
0x43: [709,20,708,22,670],
0x44: [692,3,793,22,751],
0x45: [692,3,610,22,572],
0x46: [692,3,555,22,536],
0x47: [709,20,762,22,728],
0x48: [692,3,831,22,810],
0x49: [692,3,336,22,315],
0x4A: [692,195,332,-15,311],
0x4B: [692,3,725,22,719],
0x4C: [692,3,610,22,586],
0x4D: [692,13,945,16,926],
0x4E: [692,6,830,17,813],
0x4F: [709,20,785,22,764],
0x50: [692,3,603,22,580],
0x51: [709,176,785,22,764],
0x52: [692,3,667,22,669],
0x53: [709,20,524,24,503],
0x54: [692,3,612,18,595],
0x55: [692,20,777,12,759],
0x56: [692,9,721,8,706],
0x57: [700,9,1000,8,984],
0x58: [700,3,666,14,648],
0x59: [705,3,666,9,654],
0x5A: [692,3,666,15,638],
0x5B: [726,184,332,79,288],
0x5C: [714,169,286,-9,324],
0x5D: [726,184,332,45,254],
0x5E: [689,-283,605,51,554],
0x5F: [-75,125,499,0,500],
0x60: [709,-446,277,45,233],
0x61: [469,12,499,32,471],
0x62: [726,28,552,-15,508],
0x63: [497,20,443,25,413],
0x64: [726,12,610,34,579],
0x65: [469,20,478,26,448],
0x66: [737,3,332,23,341],
0x67: [469,283,555,32,544],
0x68: [726,3,581,6,572],
0x69: [687,3,290,21,271],
0x6A: [688,283,233,-40,167],
0x6B: [726,12,555,21,549],
0x6C: [726,3,290,21,271],
0x6D: [469,3,882,16,869],
0x6E: [469,3,581,6,572],
0x6F: [469,20,545,32,514],
0x70: [477,281,600,8,556],
0x71: [477,281,600,45,593],
0x72: [469,3,394,21,374],
0x73: [469,20,423,30,391],
0x74: [621,12,325,22,319],
0x75: [469,12,602,18,581],
0x76: [459,7,564,6,539],
0x77: [469,7,833,6,808],
0x78: [469,3,515,20,496],
0x79: [459,283,555,12,544],
0x7A: [462,3,499,16,466],
0x7B: [726,175,332,58,289],
0x7C: [713,172,210,76,135],
0x7D: [726,175,332,44,275],
0x7E: [341,-182,605,51,555],
0xA3: [694,13,499,12,478],
0xA5: [701,3,499,5,496],
0xA7: [709,219,499,26,465],
0xA8: [637,-537,332,17,316],
0xAC: [360,-88,673,65,608],
0xAE: [705,164,906,18,889],
0xB1: [541,0,668,65,604],
0xB5: [473,286,610,89,567],
0xB7: [319,-203,249,67,183],
0xD7: [547,5,668,59,611],
0xF0: [728,20,545,32,504],
0xF7: [512,-10,605,51,555],
0x131: [469,3,290,21,271],
0x2C6: [677,-510,312,0,312],
0x2C7: [677,-510,312,0,312],
0x2C9: [591,-538,338,13,325],
0x2D8: [699,-534,269,-4,273],
0x2D9: [676,-568,333,112,220],
0x2DA: [717,-535,267,36,231],
0x2DC: [682,-571,329,-5,334],
0x300: [677,-506,0,-302,-78],
0x301: [677,-506,0,-255,-31],
0x302: [677,-510,0,-312,0],
0x303: [640,-535,0,-330,0],
0x304: [591,-538,0,-332,-20],
0x306: [664,-506,0,-307,-25],
0x307: [637,-537,0,-175,-75],
0x308: [637,-537,0,-318,-17],
0x30A: [718,-518,0,-235,-35],
0x30C: [677,-510,0,-322,-10],
0x338: [714,169,0,-408,0],
0x382: [0,0,768,0,0],
0x391: [700,3,777,15,756],
0x392: [692,3,610,26,576],
0x393: [692,3,555,22,536],
0x394: [697,4,688,27,662],
0x395: [692,3,610,22,572],
0x396: [692,3,666,15,638],
0x397: [692,3,831,22,810],
0x398: [709,20,785,22,764],
0x399: [692,3,336,22,315],
0x39A: [692,3,725,22,719],
0x39B: [697,4,753,17,729],
0x39C: [692,13,945,16,926],
0x39D: [692,20,830,17,813],
0x39E: [689,4,692,42,651],
0x39F: [709,20,785,22,764],
0x3A0: [689,4,812,25,788],
0x3A1: [692,3,603,22,580],
0x3A3: [689,4,684,45,643],
0x3A4: [692,3,612,18,595],
0x3A5: [691,4,733,3,735],
0x3A6: [689,4,755,23,723],
0x3A7: [700,3,666,14,648],
0x3A8: [689,4,870,18,852],
0x3A9: [704,6,824,34,791],
0x3B1: [473,16,594,44,571],
0x3B2: [680,283,512,68,460],
0x3B3: [473,273,581,-31,489],
0x3B4: [702,16,497,56,468],
0x3B5: [468,13,480,69,436],
0x3B6: [712,149,504,61,509],
0x3B7: [473,275,531,-11,464],
0x3B8: [702,16,613,83,555],
0x3B9: [473,16,310,94,305],
0x3BA: [473,16,571,13,553],
0x3BB: [702,16,618,86,616],
0x3BC: [473,286,610,89,567],
0x3BD: [473,7,497,-24,443],
0x3BE: [701,148,547,65,507],
0x3BF: [469,20,545,32,514],
0x3C0: [467,15,653,27,628],
0x3C1: [473,284,566,83,490],
0x3C2: [463,155,501,43,430],
0x3C3: [474,15,552,35,487],
0x3C4: [463,16,519,35,439],
0x3C5: [471,12,547,13,490],
0x3C6: [485,277,681,8,606],
0x3C7: [479,193,608,51,548],
0x3C8: [682,281,695,6,626],
0x3C9: [463,12,715,36,659],
0x3D0: [701,13,562,30,492],
0x3D1: [702,15,620,62,583],
0x3D5: [705,289,665,27,613],
0x3D6: [529,12,715,41,671],
0x3DC: [692,3,555,22,536],
0x3DD: [495,233,514,23,495],
0x3F0: [510,16,705,48,659],
0x3F1: [474,260,478,72,461],
0x3F4: [709,20,785,22,764],
0x3F5: [466,12,480,46,439],
0x2013: [277,-219,499,0,500],
0x2014: [277,-219,1000,0,1000],
0x2016: [713,172,420,76,345],
0x2018: [709,-446,277,45,233],
0x2019: [709,-446,277,45,233],
0x201C: [709,-446,510,45,466],
0x201D: [709,-446,510,45,466],
0x2020: [694,5,499,34,466],
0x2021: [694,249,499,34,466],
0x2026: [111,5,746,100,647],
0x2032: [495,-47,364,53,313],
0x2033: [495,-47,599,53,548],
0x2034: [495,-47,834,53,783],
0x2035: [495,-47,364,53,313],
0x203E: [1726,-1614,1024,0,1024],
0x2044: [558,279,313,0,314],
0x2057: [495,-47,1069,53,1018],
0x20D7: [790,-519,557,0,558],
0x210F: [733,9,499,10,471],
0x2111: [721,4,645,12,594],
0x2113: [713,13,470,16,455],
0x2118: [504,203,656,58,617],
0x211C: [717,4,748,17,702],
0x2127: [704,6,824,34,791],
0x2132: [692,3,555,22,536],
0x2135: [746,13,672,32,641],
0x2136: [734,0,675,31,635],
0x2137: [734,0,331,26,306],
0x2138: [734,0,559,36,526],
0x2141: [727,9,778,53,708],
0x2190: [486,-55,1013,65,949],
0x2191: [713,172,524,47,478],
0x2192: [486,-55,1013,65,949],
0x2193: [713,172,524,47,478],
0x2194: [486,-55,1013,65,949],
0x2195: [712,172,524,47,478],
0x2196: [713,172,1013,65,949],
0x2197: [713,172,1013,65,949],
0x2198: [713,172,1013,65,949],
0x2199: [713,172,1013,65,949],
0x219A: [486,-55,1013,65,949],
0x219B: [486,-55,1013,65,949],
0x219E: [486,-55,1013,65,949],
0x21A0: [486,-55,1013,65,949],
0x21A2: [486,-55,1150,65,1075],
0x21A3: [486,-55,1150,76,1085],
0x21A6: [486,-55,1013,36,978],
0x21A9: [494,-55,1013,65,949],
0x21AA: [494,-55,1013,65,949],
0x21AB: [493,-55,1013,65,949],
0x21AC: [493,-55,1013,65,949],
0x21AD: [486,-55,1211,34,1178],
0x21AE: [486,-55,1013,65,949],
0x21B0: [753,0,506,65,442],
0x21B1: [753,0,506,65,442],
0x21B6: [458,0,1124,34,1115],
0x21B7: [458,0,1124,34,1115],
0x21BA: [751,0,987,114,875],
0x21BB: [751,0,987,114,875],
0x21BC: [394,-149,1013,64,950],
0x21BD: [394,-148,1013,64,950],
0x21BE: [714,171,524,233,478],
0x21BF: [714,171,524,47,293],
0x21C0: [394,-149,1013,64,950],
0x21C1: [394,-148,1013,64,950],
0x21C2: [714,171,524,233,478],
0x21C3: [714,171,524,47,293],
0x21C4: [665,124,1013,65,949],
0x21C6: [665,124,1013,65,949],
0x21C7: [665,124,1013,65,949],
0x21C8: [714,171,883,47,837],
0x21C9: [665,124,1013,65,949],
0x21CA: [714,171,883,47,837],
0x21CB: [594,52,1013,65,949],
0x21CC: [594,52,1013,65,949],
0x21CD: [537,-6,1013,65,949],
0x21CE: [537,-6,1013,59,954],
0x21CF: [537,-6,1013,65,949],
0x21D0: [539,-7,1013,65,949],
0x21D1: [713,172,578,24,555],
0x21D2: [539,-7,1013,65,949],
0x21D3: [713,172,578,24,555],
0x21D4: [537,-5,1013,59,954],
0x21D5: [718,176,578,24,556],
0x21DA: [607,67,1013,65,949],
0x21DB: [608,66,1013,65,949],
0x21DD: [485,-54,1149,34,1116],
0x21E0: [485,-54,1063,65,998],
0x21E2: [485,-54,1063,65,998],
0x2200: [697,15,617,26,592],
0x2201: [906,146,753,114,640],
0x2202: [750,11,494,35,460],
0x2203: [697,0,617,46,572],
0x2204: [836,141,617,46,572],
0x2205: [591,13,733,65,668],
0x2207: [697,4,688,27,662],
0x2208: [533,-8,563,55,509],
0x2209: [648,107,563,55,509],
0x220B: [533,-8,563,55,509],
0x220D: [482,3,511,65,446],
0x2212: [299,-243,605,51,555],
0x2213: [541,0,668,65,604],
0x2214: [629,89,668,65,604],
0x2215: [726,119,605,87,519],
0x2216: [501,-50,799,101,699],
0x2217: [446,-99,388,31,358],
0x2218: [417,-124,388,47,342],
0x2219: [319,-203,249,67,183],
0x221A: [1079,59,760,63,793],
0x221D: [466,-75,668,65,604],
0x221E: [463,-65,897,55,843],
0x2220: [577,0,535,65,471],
0x2221: [577,0,535,65,471],
0x2222: [515,-26,535,65,471],
0x2223: [714,171,437,189,248],
0x2224: [714,171,437,0,438],
0x2225: [714,171,641,186,456],
0x2226: [714,171,641,0,642],
0x2227: [585,0,687,65,623],
0x2228: [585,0,687,65,623],
0x2229: [603,0,687,65,623],
0x222A: [603,0,687,65,623],
0x222B: [885,442,768,54,694],
0x2234: [524,6,661,65,597],
0x2235: [524,6,661,65,597],
0x223C: [355,-186,668,58,610],
0x223D: [355,-186,668,58,610],
0x2240: [593,4,277,57,221],
0x2241: [491,-51,668,56,614],
0x2242: [434,-106,668,65,604],
0x2243: [400,-107,668,65,604],
0x2245: [587,-134,668,65,604],
0x2246: [605,-18,668,65,604],
0x2248: [465,-79,668,56,614],
0x224A: [534,-62,668,65,604],
0x224D: [478,-63,668,54,616],
0x224E: [479,-62,668,65,604],
0x224F: [479,-134,668,65,604],
0x2250: [503,-38,668,65,604],
0x2251: [599,58,668,65,604],
0x2252: [599,58,668,65,604],
0x2253: [599,58,668,65,604],
0x2256: [404,-131,668,65,604],
0x2257: [649,-134,668,65,604],
0x225C: [640,-134,687,65,623],
0x2260: [596,55,668,65,604],
0x2261: [479,-62,668,65,604],
0x2264: [604,61,669,65,604],
0x2265: [604,61,669,65,604],
0x2266: [672,131,668,65,604],
0x2267: [672,131,668,65,604],
0x2268: [672,183,668,65,604],
0x2269: [672,183,668,65,604],
0x226A: [535,-5,965,55,912],
0x226B: [535,-5,965,55,912],
0x226C: [705,179,430,65,366],
0x226E: [648,107,668,65,604],
0x226F: [648,107,668,65,604],
0x2270: [712,171,668,65,604],
0x2271: [712,171,668,65,604],
0x2272: [604,118,668,65,604],
0x2273: [604,118,668,65,604],
0x2276: [626,85,668,65,604],
0x2277: [626,85,668,65,604],
0x227A: [553,14,668,65,604],
0x227B: [553,14,668,65,604],
0x227C: [632,91,668,65,604],
0x227D: [632,91,668,65,604],
0x227E: [621,118,668,65,604],
0x227F: [621,118,668,65,604],
0x2280: [648,107,668,65,604],
0x2281: [648,107,668,65,604],
0x2282: [533,-8,668,55,615],
0x2283: [533,-8,668,55,615],
0x2286: [602,61,668,55,615],
0x2287: [602,61,668,55,615],
0x2288: [712,171,668,55,615],
0x2289: [712,171,668,55,615],
0x228A: [602,114,668,55,615],
0x228B: [602,114,668,55,615],
0x228E: [603,0,687,65,623],
0x228F: [533,-8,668,55,615],
0x2290: [533,-8,668,55,615],
0x2291: [602,61,668,55,615],
0x2292: [602,61,668,55,615],
0x2293: [576,0,687,65,623],
0x2294: [576,0,687,65,623],
0x2295: [587,46,668,18,652],
0x2296: [587,46,668,18,652],
0x2297: [587,46,668,18,652],
0x2298: [587,46,668,18,652],
0x2299: [587,46,668,18,652],
0x229A: [587,46,668,18,652],
0x229B: [587,46,668,18,652],
0x229D: [587,46,668,18,652],
0x229E: [541,0,668,64,605],
0x229F: [541,0,668,64,605],
0x22A0: [541,0,668,64,605],
0x22A1: [541,0,668,64,605],
0x22A2: [599,20,748,85,664],
0x22A3: [599,20,748,85,664],
0x22A4: [579,0,748,65,684],
0x22A5: [579,0,748,65,684],
0x22A8: [541,0,490,65,425],
0x22A9: [541,0,618,65,554],
0x22AA: [541,0,746,65,682],
0x22AC: [541,0,490,-47,425],
0x22AD: [592,50,490,204,776],
0x22AE: [541,0,618,-47,554],
0x22AF: [541,0,748,-47,684],
0x22B2: [535,-6,669,65,604],
0x22B3: [535,-6,669,65,604],
0x22B4: [604,61,669,65,604],
0x22B5: [604,61,669,65,604],
0x22B8: [446,-94,1016,65,952],
0x22BA: [579,0,748,125,625],
0x22BB: [639,99,687,65,623],
0x22BC: [639,99,687,65,623],
0x22C4: [453,-89,273,22,253],
0x22C5: [329,-213,249,67,183],
0x22C6: [577,37,708,32,678],
0x22C8: [515,-23,758,65,694],
0x22C9: [515,-23,758,65,694],
0x22CA: [518,-26,758,65,694],
0x22CB: [714,36,858,55,804],
0x22CC: [714,36,858,55,804],
0x22CD: [434,-106,668,58,611],
0x22CE: [541,-2,668,52,617],
0x22CF: [541,-2,668,52,617],
0x22D0: [533,-8,668,55,615],
0x22D1: [533,-8,668,55,615],
0x22D2: [603,0,687,65,623],
0x22D3: [603,0,687,65,623],
0x22D4: [771,0,687,65,623],
0x22D6: [535,-5,668,65,604],
0x22D7: [535,-5,668,65,604],
0x22D8: [536,-6,1278,55,1224],
0x22D9: [536,-6,1278,55,1224],
0x22DA: [831,289,668,65,604],
0x22DB: [831,289,668,65,604],
0x22DE: [632,91,668,65,604],
0x22DF: [632,91,668,65,604],
0x22E0: [648,107,668,65,604],
0x22E1: [648,107,668,65,604],
0x22E6: [604,118,668,65,604],
0x22E7: [604,118,668,65,604],
0x22E8: [621,118,668,65,604],
0x22E9: [621,118,668,65,604],
0x22EA: [648,107,668,65,604],
0x22EB: [648,107,668,65,604],
0x22EC: [712,171,668,65,604],
0x22ED: [712,171,668,65,604],
0x22EE: [674,142,249,67,183],
0x22EF: [329,-213,1000,109,891],
0x22F1: [568,16,774,95,680],
0x2308: [713,172,390,93,355],
0x2309: [713,172,390,36,298],
0x230A: [713,172,390,93,355],
0x230B: [713,172,390,36,298],
0x2322: [333,-164,691,65,627],
0x2323: [333,-164,691,65,627],
0x23B4: [755,-545,601,0,602],
0x23B5: [-165,375,601,0,602],
0x23DC: [786,-545,1069,64,1006],
0x23DD: [-545,786,1069,64,1006],
0x23DE: [776,-545,1029,64,966],
0x23DF: [-545,776,1029,64,966],
0x23E0: [755,-545,1029,65,965],
0x23E1: [-545,755,1029,65,965],
0x25A0: [541,0,669,64,605],
0x25A1: [560,0,688,65,623],
0x25B2: [577,0,667,44,623],
0x25B3: [577,0,667,44,623],
0x25B6: [578,1,667,45,622],
0x25BC: [577,0,667,44,623],
0x25BD: [577,0,667,44,623],
0x25C0: [578,1,667,45,622],
0x2660: [592,0,570,44,526],
0x2661: [591,7,636,44,593],
0x2662: [642,101,559,44,516],
0x2663: [584,0,607,44,564],
0x266D: [668,122,436,69,387],
0x266E: [758,216,396,63,347],
0x266F: [775,234,422,53,384],
0x2713: [742,7,782,44,749],
0x2720: [682,95,876,49,827],
0x27E8: [713,172,381,53,329],
0x27E9: [713,172,381,53,329],
0x27EE: [726,223,245,61,213],
0x27EF: [726,223,245,32,184],
0x27F5: [488,-57,1513,65,1444],
0x27F6: [488,-57,1513,65,1444],
0x27F7: [486,-55,1513,65,1449],
0x27F8: [537,-5,1513,65,1449],
0x27F9: [537,-5,1513,65,1449],
0x27FA: [537,-5,1513,59,1454],
0x27FC: [486,-55,1513,36,1478],
0x2997: [709,191,384,87,298],
0x2998: [709,191,384,87,298],
0x29EB: [642,101,559,44,516],
0x29F5: [714,169,463,65,399],
0x29F8: [1021,510,402,0,403],
0x29F9: [1021,510,402,0,403],
0x2A3F: [617,76,812,25,788],
0x2A5E: [636,262,687,65,623],
0x2A7D: [615,74,668,65,604],
0x2A7E: [615,74,668,65,604],
0x2A85: [672,187,668,65,604],
0x2A86: [672,187,668,65,604],
0x2A87: [604,114,668,65,604],
0x2A88: [604,114,668,65,604],
0x2A89: [672,187,668,65,604],
0x2A8A: [672,187,668,65,604],
0x2A8B: [831,289,668,65,604],
0x2A8C: [831,289,668,65,604],
0x2A95: [615,74,668,65,604],
0x2A96: [615,74,668,65,604],
0x2AAF: [623,81,668,65,604],
0x2AB0: [620,84,668,65,604],
0x2AB5: [680,191,668,65,604],
0x2AB6: [680,191,668,65,604],
0x2AB7: [688,187,668,65,604],
0x2AB8: [688,187,668,65,604],
0x2AB9: [688,187,668,65,604],
0x2ABA: [688,187,668,65,604],
0x2AC5: [669,131,668,55,615],
0x2AC6: [669,131,668,55,615],
0x2ACB: [669,183,668,55,615],
0x2ACC: [669,183,668,55,615]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Main"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Main/Regular/Main.js"]
);

91
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Marks/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,91 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Marks/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Marks'] = {
directory: 'Marks/Regular',
family: 'AsanaMathJax_Marks',
testString: '\u02DB\u0305\u0332\u0333\u033F\u0342\u2015\u2017\u201A\u201B\u201E\u2022\u2024\u2025\u2030',
0x20: [0,0,249,0,0],
0x2DB: [0,188,333,63,269],
0x305: [587,-542,0,-433,0],
0x332: [-130,175,0,-433,0],
0x333: [-130,283,0,-433,0],
0x33F: [695,-542,0,-433,0],
0x342: [729,-653,0,-324,-31],
0x2015: [271,-213,1000,0,1000],
0x2017: [-75,225,499,0,500],
0x201A: [100,165,403,141,334],
0x201B: [709,-446,277,45,233],
0x201E: [100,165,605,141,536],
0x2022: [466,-75,522,65,458],
0x2024: [111,5,315,100,216],
0x2025: [111,5,530,100,431],
0x2030: [709,20,1143,123,1021],
0x2036: [495,-47,599,53,548],
0x2037: [495,-47,834,53,783],
0x203B: [547,5,668,59,614],
0x203C: [694,5,973,81,394],
0x203F: [96,58,834,36,798],
0x2040: [642,-488,834,36,798],
0x2045: [726,184,332,79,288],
0x2046: [726,184,332,45,254],
0x2050: [688,0,980,43,937],
0x205D: [623,3,226,55,171],
0x205E: [630,3,226,55,171],
0x20D0: [791,-636,557,0,558],
0x20D1: [791,-636,557,0,558],
0x20D2: [813,31,416,252,312],
0x20D3: [1014,0,987,679,738],
0x20D4: [780,-492,680,0,681],
0x20D5: [780,-492,680,0,681],
0x20D6: [790,-519,557,0,558],
0x20D8: [417,-124,388,47,342],
0x20D9: [542,-236,447,47,401],
0x20DA: [541,-235,447,47,401],
0x20DB: [694,-578,519,27,493],
0x20DC: [694,-578,694,27,668],
0x20DD: [825,218,0,-1045,0],
0x20DE: [705,164,0,-870,1],
0x20DF: [1114,117,0,-1230,0],
0x20E0: [705,164,0,-872,-1],
0x20E1: [790,-519,556,0,557],
0x20E2: [655,55,0,-1255,0],
0x20E3: [960,259,0,-1219,0],
0x20E4: [896,62,0,-849,0],
0x20E5: [714,169,0,-333,0],
0x20E6: [713,172,0,-345,-76],
0x20E7: [710,15,0,-283,283],
0x20E8: [-142,258,519,27,493],
0x20E9: [723,-514,629,0,630],
0x20EA: [486,-55,1013,65,949],
0x20EB: [714,169,0,-609,-65],
0x20EC: [673,-518,557,0,558],
0x20ED: [673,-518,557,0,558],
0x20EE: [-83,354,556,0,557],
0x20EF: [-83,354,556,0,557],
0x3014: [709,191,384,87,298],
0x3015: [709,191,384,87,298],
0x3018: [709,191,384,87,298],
0x3019: [730,212,384,77,308]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Marks"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Marks/Regular/Main.js"]
);

112
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Misc/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,112 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Misc/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Misc'] = {
directory: 'Misc/Regular',
family: 'AsanaMathJax_Misc',
testString: '\u2070\u2071\u2074\u2075\u2076\u2077\u2078\u2079\u207A\u207B\u207C\u207D\u207E\u207F\u2080',
0x20: [0,0,249,0,0],
0x2070: [696,-271,300,14,286],
0x2071: [685,-271,209,27,183],
0x2074: [690,-271,299,2,296],
0x2075: [696,-271,304,14,292],
0x2076: [696,-271,299,14,286],
0x2077: [687,-271,299,9,290],
0x2078: [696,-271,299,15,285],
0x2079: [696,-271,299,13,286],
0x207A: [593,-271,406,35,372],
0x207B: [449,-415,385,35,351],
0x207C: [513,-349,406,35,372],
0x207D: [727,-162,204,35,186],
0x207E: [727,-162,204,19,170],
0x207F: [555,-271,412,30,383],
0x2080: [154,271,300,14,286],
0x2081: [147,271,299,32,254],
0x2082: [144,271,299,6,284],
0x2083: [154,271,299,5,281],
0x2084: [148,271,299,2,296],
0x2085: [154,271,304,14,292],
0x2086: [154,271,299,14,286],
0x2087: [145,271,299,9,290],
0x2088: [154,271,299,15,285],
0x2089: [154,271,299,13,286],
0x208A: [51,271,406,35,372],
0x208B: [-93,127,385,35,351],
0x208C: [-29,193,406,35,372],
0x208D: [197,368,204,35,186],
0x208E: [197,368,204,19,170],
0x2090: [12,277,334,31,304],
0x2091: [22,271,328,30,294],
0x2092: [22,271,361,31,331],
0x2093: [11,273,359,31,329],
0x2094: [22,271,323,30,294],
0x20AC: [683,0,721,0,689],
0x2153: [692,3,750,15,735],
0x2154: [689,3,781,15,766],
0x2155: [692,7,766,15,751],
0x2156: [689,7,781,15,766],
0x2157: [691,7,766,15,751],
0x2158: [690,7,766,15,751],
0x2159: [692,7,750,15,735],
0x215A: [692,7,750,15,735],
0x215B: [693,1,750,14,736],
0x215C: [691,1,750,15,736],
0x215D: [690,1,750,15,736],
0x215E: [691,2,677,15,662],
0x215F: [692,0,392,15,625],
0x2160: [692,3,336,22,315],
0x2161: [692,3,646,30,618],
0x2162: [692,3,966,43,924],
0x2163: [692,9,1015,12,1004],
0x2164: [692,9,721,8,706],
0x2165: [692,9,1015,12,1004],
0x2166: [692,9,1315,15,1301],
0x2167: [692,9,1609,16,1594],
0x2168: [700,3,979,26,954],
0x2169: [700,3,666,14,648],
0x216A: [700,3,954,14,940],
0x216B: [700,3,1254,14,1236],
0x216C: [692,3,610,22,586],
0x216D: [709,20,708,22,670],
0x216E: [692,3,773,22,751],
0x216F: [692,13,945,16,926],
0x2170: [687,3,290,21,271],
0x2171: [687,3,544,21,523],
0x2172: [687,3,794,21,773],
0x2173: [687,7,826,21,802],
0x2174: [459,7,564,6,539],
0x2175: [687,7,834,6,813],
0x2176: [687,7,1094,6,1065],
0x2177: [687,7,1339,6,1313],
0x2178: [687,3,768,21,749],
0x2179: [469,3,515,20,496],
0x217A: [687,3,764,20,746],
0x217B: [687,3,1019,20,997],
0x217C: [726,3,290,21,271],
0x217D: [469,20,443,26,413],
0x217E: [726,12,610,35,579],
0x217F: [469,3,882,16,869],
0x2731: [669,-148,601,55,546],
0x2736: [572,0,592,45,547]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Misc"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Misc/Regular/Main.js"]
);

93
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Monospace/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,93 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Monospace/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Monospace'] = {
directory: 'Monospace/Regular',
family: 'AsanaMathJax_Monospace',
testString: '\u00A0\uD835\uDE70\uD835\uDE71\uD835\uDE72\uD835\uDE73\uD835\uDE74\uD835\uDE75\uD835\uDE76\uD835\uDE77\uD835\uDE78\uD835\uDE79\uD835\uDE7A\uD835\uDE7B\uD835\uDE7C\uD835\uDE7D',
0x20: [0,0,524,0,0],
0xA0: [0,0,524,0,0],
0x1D670: [623,0,524,27,497],
0x1D671: [611,0,524,23,482],
0x1D672: [622,11,524,40,484],
0x1D673: [611,0,524,19,485],
0x1D674: [611,0,524,26,502],
0x1D675: [611,0,524,28,490],
0x1D676: [622,11,524,38,496],
0x1D677: [611,0,524,22,502],
0x1D678: [611,0,524,79,446],
0x1D679: [611,11,524,71,478],
0x1D67A: [611,0,524,26,495],
0x1D67B: [611,0,524,32,488],
0x1D67C: [611,0,524,17,507],
0x1D67D: [611,0,524,28,496],
0x1D67E: [622,11,524,56,468],
0x1D67F: [611,0,524,26,480],
0x1D680: [622,139,524,56,468],
0x1D681: [611,11,524,22,522],
0x1D682: [622,11,524,52,472],
0x1D683: [611,0,524,26,498],
0x1D684: [611,11,524,4,520],
0x1D685: [611,8,524,18,506],
0x1D686: [611,8,524,11,513],
0x1D687: [611,0,524,27,496],
0x1D688: [611,0,524,19,505],
0x1D689: [611,0,524,48,481],
0x1D68A: [440,6,524,55,524],
0x1D68B: [611,6,524,12,488],
0x1D68C: [440,6,524,73,466],
0x1D68D: [611,6,524,36,512],
0x1D68E: [440,6,524,55,464],
0x1D68F: [617,0,524,42,437],
0x1D690: [442,229,524,29,509],
0x1D691: [611,0,524,12,512],
0x1D692: [612,0,524,78,455],
0x1D693: [612,228,524,48,368],
0x1D694: [611,0,524,21,508],
0x1D695: [611,0,524,58,467],
0x1D696: [437,0,524,-4,516],
0x1D697: [437,0,524,12,512],
0x1D698: [440,6,524,57,467],
0x1D699: [437,222,524,12,488],
0x1D69A: [437,222,524,40,537],
0x1D69B: [437,0,524,32,487],
0x1D69C: [440,6,524,72,459],
0x1D69D: [554,6,524,25,449],
0x1D69E: [431,6,524,12,512],
0x1D69F: [431,4,524,24,500],
0x1D6A0: [431,4,524,16,508],
0x1D6A1: [431,0,524,27,496],
0x1D6A2: [431,228,524,26,500],
0x1D6A3: [431,0,524,33,475],
0x1D7F6: [691,12,499,48,451],
0x1D7F7: [691,0,499,100,421],
0x1D7F8: [691,0,499,50,450],
0x1D7F9: [691,12,499,42,457],
0x1D7FA: [692,0,499,28,471],
0x1D7FB: [679,12,499,50,450],
0x1D7FC: [691,12,499,50,449],
0x1D7FD: [697,12,499,42,457],
0x1D7FE: [691,12,499,42,457],
0x1D7FF: [691,12,499,50,449]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Monospace"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Monospace/Regular/Main.js"]
);

310
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/NonUnicode/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,310 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/NonUnicode/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_NonUnicode'] = {
directory: 'NonUnicode/Regular',
family: 'AsanaMathJax_NonUnicode',
testString: '\uE000\uE001\uE002\uE003\uE004\uE005\uE006\uE007\uE008\uE009\uE00A\uE00B\uE00C\uE00D\uE00E',
0x20: [0,0,249,0,0],
0xE000: [705,3,751,28,724],
0xE001: [692,6,610,26,559],
0xE002: [706,18,687,45,651],
0xE003: [692,3,777,28,741],
0xE004: [692,3,610,30,570],
0xE005: [692,3,555,0,548],
0xE006: [706,18,721,50,694],
0xE007: [692,3,777,-3,800],
0xE008: [692,3,332,7,354],
0xE009: [692,206,332,-35,358],
0xE00A: [692,3,666,13,683],
0xE00B: [692,3,555,16,523],
0xE00C: [698,18,953,-19,950],
0xE00D: [692,11,777,2,802],
0xE00E: [706,18,777,53,748],
0xE00F: [692,3,610,9,594],
0xE010: [706,201,777,53,748],
0xE011: [691,3,666,9,639],
0xE012: [706,18,555,42,506],
0xE013: [692,3,610,53,635],
0xE014: [692,19,777,88,798],
0xE015: [692,8,721,75,754],
0xE016: [700,8,943,71,980],
0xE017: [692,3,721,20,734],
0xE018: [705,3,666,52,675],
0xE019: [692,3,666,20,637],
0xE01A: [482,11,443,4,406],
0xE01B: [733,11,462,37,433],
0xE01C: [482,11,406,25,389],
0xE01D: [733,11,499,17,483],
0xE01E: [483,11,388,15,374],
0xE01F: [733,276,550,-25,550],
0xE020: [482,276,499,-37,498],
0xE021: [733,9,499,10,471],
0xE022: [712,9,277,34,264],
0xE023: [712,276,277,-70,265],
0xE024: [733,9,468,14,455],
0xE025: [733,9,277,36,251],
0xE026: [482,9,777,24,740],
0xE027: [482,9,555,24,514],
0xE028: [482,11,443,17,411],
0xE029: [482,276,499,-7,465],
0xE02A: [482,276,462,24,432],
0xE02B: [482,9,388,26,384],
0xE02C: [482,11,388,9,345],
0xE02D: [646,9,332,41,310],
0xE02E: [482,11,555,32,512],
0xE02F: [482,11,499,21,477],
0xE030: [482,11,721,21,699],
0xE031: [482,11,499,9,484],
0xE032: [482,276,499,-8,490],
0xE033: [482,11,443,-1,416],
0xE034: [705,3,751,28,724],
0xE035: [692,6,610,26,559],
0xE036: [706,18,687,45,651],
0xE037: [692,3,777,28,741],
0xE038: [692,3,610,30,570],
0xE039: [692,3,555,0,548],
0xE03A: [706,18,721,50,694],
0xE03B: [692,3,777,-3,800],
0xE03C: [692,3,332,7,354],
0xE03D: [692,206,332,-35,358],
0xE03E: [692,3,666,13,683],
0xE03F: [692,3,555,16,523],
0xE040: [698,18,953,-19,950],
0xE041: [692,11,777,2,802],
0xE042: [706,18,777,53,748],
0xE043: [692,3,610,9,594],
0xE044: [706,201,777,53,748],
0xE045: [691,3,666,9,639],
0xE046: [706,18,555,42,506],
0xE047: [692,3,610,53,635],
0xE048: [692,19,777,88,798],
0xE049: [692,8,721,75,754],
0xE04A: [700,8,943,71,980],
0xE04B: [692,3,721,20,734],
0xE04C: [705,3,666,52,675],
0xE04D: [692,3,666,20,637],
0xE04E: [482,11,443,4,406],
0xE04F: [733,11,462,37,433],
0xE050: [482,11,406,25,389],
0xE051: [733,11,499,17,483],
0xE052: [483,11,388,15,374],
0xE053: [733,276,550,-25,550],
0xE054: [482,276,499,-37,498],
0xE055: [733,9,499,10,471],
0xE056: [712,9,277,34,264],
0xE057: [712,276,277,-70,265],
0xE058: [733,9,468,14,455],
0xE059: [733,9,277,36,251],
0xE05A: [482,9,777,24,740],
0xE05B: [482,9,555,24,514],
0xE05C: [482,11,443,17,411],
0xE05D: [482,276,499,-7,465],
0xE05E: [482,276,462,24,432],
0xE05F: [482,9,388,26,384],
0xE060: [482,11,388,9,345],
0xE061: [646,9,332,41,310],
0xE062: [482,11,555,32,512],
0xE063: [482,11,499,21,477],
0xE064: [482,11,721,21,699],
0xE065: [482,11,499,9,484],
0xE066: [482,276,499,-8,490],
0xE067: [482,11,443,-1,416],
0xE068: [689,20,499,29,465],
0xE069: [694,3,499,60,418],
0xE06A: [689,3,499,16,468],
0xE06B: [689,20,499,15,462],
0xE06C: [694,3,499,2,472],
0xE06D: [689,20,499,13,459],
0xE06E: [689,20,499,32,468],
0xE06F: [689,3,499,44,497],
0xE070: [689,20,499,30,464],
0xE071: [689,20,499,20,457],
0xE072: [689,20,499,29,465],
0xE073: [694,3,499,60,418],
0xE074: [689,3,499,16,468],
0xE075: [689,20,499,15,462],
0xE076: [694,3,499,2,472],
0xE077: [689,20,499,13,459],
0xE078: [689,20,499,32,468],
0xE079: [689,3,499,44,497],
0xE07A: [689,20,499,30,464],
0xE07B: [689,20,499,20,457],
0xE07C: [469,12,499,32,471],
0xE07D: [726,27,552,-15,508],
0xE07E: [497,20,443,25,413],
0xE07F: [726,12,610,34,579],
0xE080: [469,20,478,26,448],
0xE081: [737,3,332,23,341],
0xE082: [469,283,555,32,544],
0xE083: [726,3,581,6,572],
0xE084: [687,3,290,21,271],
0xE085: [688,283,233,-40,167],
0xE086: [726,12,555,21,549],
0xE087: [726,3,290,21,271],
0xE088: [469,3,882,16,869],
0xE089: [469,3,581,6,572],
0xE08A: [469,20,545,32,514],
0xE08B: [476,281,600,8,556],
0xE08C: [477,281,600,44,593],
0xE08D: [469,3,394,21,374],
0xE08E: [469,20,423,30,391],
0xE08F: [621,12,325,22,319],
0xE090: [469,12,602,18,581],
0xE091: [459,7,564,6,539],
0xE092: [469,7,833,6,808],
0xE093: [469,3,515,20,496],
0xE094: [459,283,555,12,544],
0xE095: [462,3,499,16,466],
0xE096: [469,12,499,32,471],
0xE097: [726,27,552,-15,508],
0xE098: [497,20,443,25,413],
0xE099: [726,12,610,34,579],
0xE09A: [469,20,478,26,448],
0xE09B: [737,3,332,23,341],
0xE09C: [469,283,555,32,544],
0xE09D: [726,3,581,6,572],
0xE09E: [687,3,290,21,271],
0xE09F: [688,283,233,-40,167],
0xE0A0: [726,12,555,21,549],
0xE0A1: [726,3,290,21,271],
0xE0A2: [469,3,882,16,869],
0xE0A3: [469,3,581,6,572],
0xE0A4: [469,20,545,32,514],
0xE0A5: [476,281,600,8,556],
0xE0A6: [477,281,600,44,593],
0xE0A7: [469,3,394,21,374],
0xE0A8: [469,20,423,30,391],
0xE0A9: [621,12,325,22,319],
0xE0AA: [469,12,602,18,581],
0xE0AB: [459,7,564,6,539],
0xE0AC: [469,7,833,6,808],
0xE0AD: [469,3,515,20,496],
0xE0AE: [459,283,555,12,544],
0xE0AF: [462,3,499,16,466],
0xE0B0: [689,4,870,18,852],
0xE0B1: [704,6,824,34,791],
0xE0B2: [692,3,555,22,536],
0xE0B3: [697,4,688,27,662],
0xE0B4: [709,20,785,22,764],
0xE0B5: [697,4,753,17,729],
0xE0B6: [689,4,692,42,651],
0xE0B7: [689,4,812,25,788],
0xE0B8: [689,4,684,45,643],
0xE0B9: [691,4,733,3,735],
0xE0BA: [689,4,755,23,723],
0xE0BB: [692,3,555,22,536],
0xE0BC: [697,4,688,27,662],
0xE0BD: [709,20,785,22,764],
0xE0BE: [697,4,753,17,729],
0xE0BF: [689,4,692,42,651],
0xE0C0: [689,4,812,25,788],
0xE0C1: [689,4,684,45,643],
0xE0C2: [691,4,733,3,735],
0xE0C3: [689,4,755,23,723],
0xE0C4: [689,4,870,18,852],
0xE0C5: [704,6,824,34,791],
0xE0C6: [700,3,777,15,756],
0xE0C7: [692,3,610,26,576],
0xE0C8: [709,20,708,22,670],
0xE0C9: [692,3,773,22,751],
0xE0CA: [692,3,610,22,572],
0xE0CB: [692,3,555,22,536],
0xE0CC: [709,20,762,22,728],
0xE0CD: [692,3,831,22,810],
0xE0CE: [692,3,336,22,315],
0xE0CF: [692,194,347,0,326],
0xE0D0: [692,3,725,22,719],
0xE0D1: [692,3,610,22,586],
0xE0D2: [692,13,945,16,926],
0xE0D3: [692,6,830,17,813],
0xE0D4: [709,20,785,22,764],
0xE0D5: [692,3,603,22,580],
0xE0D6: [709,176,785,22,764],
0xE0D7: [692,3,667,22,669],
0xE0D8: [709,20,524,24,503],
0xE0D9: [692,3,612,18,595],
0xE0DA: [692,20,777,12,759],
0xE0DB: [692,9,721,8,706],
0xE0DC: [700,9,1000,8,984],
0xE0DD: [700,3,666,14,648],
0xE0DE: [705,3,666,9,654],
0xE0DF: [692,3,666,15,638],
0xE0E0: [700,3,777,15,756],
0xE0E1: [692,3,610,26,576],
0xE0E2: [709,20,708,22,670],
0xE0E3: [692,3,773,22,751],
0xE0E4: [692,3,610,22,572],
0xE0E5: [692,3,555,22,536],
0xE0E6: [709,20,762,22,728],
0xE0E7: [692,3,831,22,810],
0xE0E8: [692,3,336,22,315],
0xE0E9: [692,194,347,0,326],
0xE0EA: [692,3,725,22,719],
0xE0EB: [692,3,610,22,586],
0xE0EC: [692,13,945,16,926],
0xE0ED: [692,6,830,17,813],
0xE0EE: [691,2,765,41,745],
0xE0EF: [692,3,603,22,580],
0xE0F0: [709,176,785,22,764],
0xE0F1: [692,3,667,22,669],
0xE0F2: [709,20,524,24,503],
0xE0F3: [692,3,612,18,595],
0xE0F4: [692,20,777,12,759],
0xE0F5: [692,9,721,8,706],
0xE0F6: [700,9,1000,8,984],
0xE0F7: [700,3,666,14,648],
0xE0F8: [705,3,666,9,654],
0xE0F9: [692,3,666,15,638],
0xE0FA: [713,15,448,19,462],
0xE0FB: [713,13,438,16,455],
0xE0FC: [701,13,562,30,492],
0xE0FD: [702,15,620,62,583],
0xE0FE: [485,277,681,8,606],
0xE0FF: [431,0,524,78,455],
0xE100: [431,228,524,48,368],
0xE101: [451,0,401,80,370],
0xE102: [451,227,301,-110,305],
0xE103: [444,0,237,81,250],
0xE104: [444,205,265,-97,278],
0xE105: [458,0,254,61,194],
0xE106: [458,205,285,-71,224],
0xE107: [444,0,237,81,156],
0xE108: [444,205,265,-61,184],
0xE109: [540,11,312,22,302],
0xE10A: [539,168,322,35,289],
0xE10B: [442,0,388,42,346],
0xE10C: [442,210,409,-35,316],
0xE10D: [501,4,270,32,258],
0xE10E: [504,169,270,32,229],
0xE10F: [431,19,444,55,394],
0xE110: [431,307,870,55,820],
0xE111: [451,22,455,41,391],
0xE112: [451,343,943,41,869],
0xE113: [469,17,332,26,293],
0xE114: [469,271,332,-64,274],
0xE115: [471,3,332,34,298],
0xE116: [471,266,332,3,227],
0xE117: [469,283,233,-40,159]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_NonUnicode"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/NonUnicode/Regular/Main.js"]
);

372
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Normal/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,372 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Normal/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Normal'] = {
directory: 'Normal/Regular',
family: 'AsanaMathJax_Normal',
testString: '\u210E\uD835\uDC00\uD835\uDC01\uD835\uDC02\uD835\uDC03\uD835\uDC04\uD835\uDC05\uD835\uDC06\uD835\uDC07\uD835\uDC08\uD835\uDC09\uD835\uDC0A\uD835\uDC0B\uD835\uDC0C\uD835\uDC0D',
0x20: [0,0,249,0,0],
0x210E: [733,9,499,10,471],
0x1D400: [686,3,777,24,757],
0x1D401: [681,3,666,39,611],
0x1D402: [695,17,721,44,695],
0x1D403: [681,3,832,35,786],
0x1D404: [682,4,610,39,577],
0x1D405: [682,3,555,28,539],
0x1D406: [695,17,832,47,776],
0x1D407: [681,3,832,36,796],
0x1D408: [681,3,388,39,350],
0x1D409: [681,213,388,-11,350],
0x1D40A: [681,3,777,39,763],
0x1D40B: [681,4,610,39,577],
0x1D40C: [681,10,1000,32,968],
0x1D40D: [681,16,832,35,798],
0x1D40E: [695,17,832,47,787],
0x1D40F: [681,3,610,39,594],
0x1D410: [695,184,832,47,787],
0x1D411: [681,3,721,39,708],
0x1D412: [695,17,610,57,559],
0x1D413: [681,3,666,17,650],
0x1D414: [681,17,777,26,760],
0x1D415: [681,3,777,20,763],
0x1D416: [686,3,1000,17,988],
0x1D417: [695,3,666,17,650],
0x1D418: [695,3,666,15,660],
0x1D419: [681,3,666,24,627],
0x1D41A: [471,17,499,40,478],
0x1D41B: [720,17,610,10,556],
0x1D41C: [471,17,443,37,414],
0x1D41D: [720,17,610,42,577],
0x1D41E: [471,17,499,42,461],
0x1D41F: [720,3,388,34,381],
0x1D420: [471,266,555,26,535],
0x1D421: [720,3,610,24,587],
0x1D422: [706,3,332,34,298],
0x1D423: [706,266,332,3,241],
0x1D424: [720,3,610,21,597],
0x1D425: [720,3,332,24,296],
0x1D426: [471,3,888,24,864],
0x1D427: [471,3,610,24,587],
0x1D428: [471,17,555,40,517],
0x1D429: [471,258,610,29,567],
0x1D42A: [471,258,610,52,589],
0x1D42B: [471,3,388,30,389],
0x1D42C: [471,17,443,39,405],
0x1D42D: [632,17,332,22,324],
0x1D42E: [471,17,610,25,583],
0x1D42F: [459,3,555,11,545],
0x1D430: [471,3,832,13,820],
0x1D431: [471,3,499,20,483],
0x1D432: [459,266,555,10,546],
0x1D433: [459,3,499,16,464],
0x1D434: [705,3,751,28,724],
0x1D435: [692,6,610,26,559],
0x1D436: [706,18,687,45,651],
0x1D437: [692,3,777,28,741],
0x1D438: [692,3,610,30,570],
0x1D439: [692,3,555,0,548],
0x1D43A: [706,18,721,50,694],
0x1D43B: [692,3,777,-3,800],
0x1D43C: [692,3,332,7,354],
0x1D43D: [692,206,332,-35,358],
0x1D43E: [692,3,666,13,683],
0x1D43F: [692,3,555,16,523],
0x1D440: [698,18,953,-19,950],
0x1D441: [692,11,777,2,802],
0x1D442: [706,18,777,53,748],
0x1D443: [692,3,610,9,594],
0x1D444: [706,201,777,53,748],
0x1D445: [691,3,666,9,639],
0x1D446: [706,18,555,42,506],
0x1D447: [692,3,610,53,635],
0x1D448: [692,19,777,88,798],
0x1D449: [692,8,721,75,754],
0x1D44A: [700,8,943,71,980],
0x1D44B: [692,3,721,20,734],
0x1D44C: [705,3,666,52,675],
0x1D44D: [692,3,666,20,637],
0x1D44E: [482,11,443,4,406],
0x1D44F: [733,11,462,37,433],
0x1D450: [482,11,406,25,389],
0x1D451: [733,11,499,17,483],
0x1D452: [483,11,388,15,374],
0x1D453: [733,276,550,-25,550],
0x1D454: [482,276,499,-37,498],
0x1D456: [712,9,277,34,264],
0x1D457: [712,276,277,-70,265],
0x1D458: [733,9,468,14,455],
0x1D459: [733,9,277,36,251],
0x1D45A: [482,9,777,24,740],
0x1D45B: [482,9,555,24,514],
0x1D45C: [482,11,443,17,411],
0x1D45D: [482,276,499,-7,465],
0x1D45E: [482,276,462,24,432],
0x1D45F: [482,9,388,26,384],
0x1D460: [482,11,388,9,345],
0x1D461: [646,9,332,41,310],
0x1D462: [482,11,555,32,512],
0x1D463: [482,11,499,21,477],
0x1D464: [482,11,721,21,699],
0x1D465: [482,11,499,9,484],
0x1D466: [482,276,499,-8,490],
0x1D467: [482,11,443,-1,416],
0x1D468: [683,3,721,-35,685],
0x1D469: [682,3,666,8,629],
0x1D46A: [695,17,684,69,695],
0x1D46B: [682,3,777,0,747],
0x1D46C: [681,3,620,11,606],
0x1D46D: [681,3,555,-6,593],
0x1D46E: [695,17,777,72,750],
0x1D46F: [681,3,777,-12,826],
0x1D470: [681,3,388,-1,412],
0x1D471: [681,207,388,-29,417],
0x1D472: [681,3,721,-10,746],
0x1D473: [681,3,610,26,578],
0x1D474: [681,17,943,-23,985],
0x1D475: [681,3,777,-2,829],
0x1D476: [695,17,832,76,794],
0x1D477: [681,3,711,11,673],
0x1D478: [695,222,832,76,794],
0x1D479: [681,3,721,4,697],
0x1D47A: [695,17,555,50,517],
0x1D47B: [681,3,610,56,674],
0x1D47C: [681,17,777,83,825],
0x1D47D: [681,3,666,67,745],
0x1D47E: [689,3,1000,67,1073],
0x1D47F: [681,3,721,-9,772],
0x1D480: [695,3,610,54,675],
0x1D481: [681,3,666,1,676],
0x1D482: [470,17,555,44,519],
0x1D483: [726,17,536,44,494],
0x1D484: [469,17,443,32,436],
0x1D485: [726,17,555,38,550],
0x1D486: [469,17,443,28,418],
0x1D487: [726,271,449,-25,554],
0x1D488: [469,271,499,-50,529],
0x1D489: [726,17,555,22,522],
0x1D48A: [695,17,332,26,312],
0x1D48B: [695,271,332,-64,323],
0x1D48C: [726,17,555,34,528],
0x1D48D: [726,17,332,64,318],
0x1D48E: [469,17,832,19,803],
0x1D48F: [469,17,555,17,521],
0x1D490: [469,17,555,48,502],
0x1D491: [469,271,555,-21,516],
0x1D492: [469,271,536,32,513],
0x1D493: [469,17,388,20,411],
0x1D494: [469,17,443,25,406],
0x1D495: [636,17,388,42,409],
0x1D496: [469,17,555,22,521],
0x1D497: [469,17,555,19,513],
0x1D498: [469,17,832,27,802],
0x1D499: [469,17,499,-8,500],
0x1D49A: [469,271,555,13,541],
0x1D49B: [469,17,499,31,470],
0x1D6A4: [482,9,277,34,241],
0x1D6A5: [482,276,277,-70,228],
0x1D6A8: [686,3,777,24,757],
0x1D6A9: [681,3,666,39,611],
0x1D6AA: [681,3,555,28,533],
0x1D6AB: [693,0,686,31,662],
0x1D6AC: [681,4,610,39,577],
0x1D6AD: [681,3,666,24,627],
0x1D6AE: [681,3,832,36,796],
0x1D6AF: [695,17,832,47,787],
0x1D6B0: [681,3,388,39,350],
0x1D6B1: [681,3,777,39,763],
0x1D6B2: [693,3,777,29,757],
0x1D6B3: [681,9,1000,32,968],
0x1D6B4: [681,16,832,35,798],
0x1D6B5: [689,3,684,34,646],
0x1D6B6: [695,17,832,47,787],
0x1D6B7: [689,3,817,36,782],
0x1D6B8: [681,3,610,39,594],
0x1D6B9: [695,17,832,47,787],
0x1D6BA: [689,3,659,25,614],
0x1D6BB: [681,3,666,17,644],
0x1D6BC: [705,0,698,6,702],
0x1D6BD: [689,3,957,46,913],
0x1D6BE: [695,0,666,17,650],
0x1D6BF: [695,5,935,6,928],
0x1D6C0: [700,3,810,34,773],
0x1D6C1: [693,0,686,25,656],
0x1D6C2: [478,21,663,68,628],
0x1D6C3: [705,282,582,57,527],
0x1D6C4: [480,291,632,-19,556],
0x1D6C5: [707,22,556,75,519],
0x1D6C6: [479,21,463,67,459],
0x1D6C7: [704,193,558,51,533],
0x1D6C8: [480,282,560,-16,492],
0x1D6C9: [701,21,645,87,587],
0x1D6CA: [481,17,272,64,275],
0x1D6CB: [481,17,539,3,534],
0x1D6CC: [698,6,587,54,616],
0x1D6CD: [492,302,610,69,583],
0x1D6CE: [480,16,561,2,513],
0x1D6CF: [704,193,524,59,529],
0x1D6D0: [471,17,555,40,517],
0x1D6D1: [476,16,633,14,628],
0x1D6D2: [476,281,566,38,502],
0x1D6D3: [477,193,515,30,502],
0x1D6D4: [492,25,570,60,554],
0x1D6D5: [480,17,518,37,485],
0x1D6D6: [480,18,576,5,514],
0x1D6D7: [478,277,836,31,753],
0x1D6D8: [480,183,583,1,551],
0x1D6D9: [688,279,762,-3,708],
0x1D6DA: [480,14,817,61,755],
0x1D6DB: [740,17,537,52,482],
0x1D6DC: [470,17,528,38,477],
0x1D6DD: [700,18,590,32,576],
0x1D6DE: [439,24,666,60,712],
0x1D6DF: [688,279,742,47,685],
0x1D6E0: [476,266,562,95,535],
0x1D6E1: [566,14,817,68,762],
0x1D6E2: [705,3,721,-19,677],
0x1D6E3: [692,4,610,26,559],
0x1D6E4: [692,3,555,-39,597],
0x1D6E5: [697,4,688,-33,602],
0x1D6E6: [690,0,610,30,570],
0x1D6E7: [692,3,666,20,637],
0x1D6E8: [689,3,777,-3,800],
0x1D6E9: [706,18,777,53,748],
0x1D6EA: [689,3,332,7,345],
0x1D6EB: [692,3,666,13,683],
0x1D6EC: [697,4,753,-41,670],
0x1D6ED: [697,18,963,-19,940],
0x1D6EE: [692,11,777,2,804],
0x1D6EF: [689,4,692,6,673],
0x1D6F0: [706,18,777,53,748],
0x1D6F1: [689,4,812,-33,845],
0x1D6F2: [692,3,610,9,594],
0x1D6F3: [706,18,777,53,748],
0x1D6F4: [689,4,684,-16,645],
0x1D6F5: [692,3,610,53,635],
0x1D6F6: [691,4,733,41,778],
0x1D6F7: [689,4,745,21,732],
0x1D6F8: [692,3,721,20,734],
0x1D6F9: [689,4,870,79,906],
0x1D6FA: [704,6,824,-11,790],
0x1D6FB: [697,4,688,87,717],
0x1D6FC: [473,16,594,23,558],
0x1D6FD: [680,283,512,-8,476],
0x1D6FE: [473,273,581,18,547],
0x1D6FF: [701,16,497,28,455],
0x1D700: [473,15,493,54,446],
0x1D701: [712,149,504,49,473],
0x1D702: [473,275,531,38,497],
0x1D703: [702,16,613,68,576],
0x1D704: [473,16,310,62,275],
0x1D705: [473,16,571,38,542],
0x1D706: [701,16,618,25,570],
0x1D707: [473,286,610,45,565],
0x1D708: [473,7,497,2,474],
0x1D709: [701,148,547,42,501],
0x1D70A: [482,11,443,17,411],
0x1D70B: [467,15,653,46,613],
0x1D70C: [473,284,566,34,525],
0x1D70D: [463,155,501,44,458],
0x1D70E: [474,15,552,28,524],
0x1D70F: [463,14,519,48,476],
0x1D710: [471,12,547,39,509],
0x1D711: [485,277,681,28,643],
0x1D712: [479,193,608,-1,601],
0x1D713: [682,281,695,39,653],
0x1D714: [463,12,715,24,673],
0x1D715: [754,4,563,53,538],
0x1D716: [481,11,465,13,457],
0x1D717: [702,15,620,41,572],
0x1D718: [439,2,666,24,746],
0x1D719: [705,289,665,26,622],
0x1D71A: [474,260,478,55,493],
0x1D71B: [528,12,715,24,674],
0x1D71C: [686,3,758,-37,703],
0x1D71D: [681,3,666,12,627],
0x1D71E: [681,3,555,-32,595],
0x1D71F: [693,0,686,-30,604],
0x1D720: [681,0,610,12,622],
0x1D721: [681,3,666,-36,683],
0x1D722: [681,3,832,-24,856],
0x1D723: [695,17,832,38,795],
0x1D724: [681,3,388,-21,411],
0x1D725: [681,3,777,-21,798],
0x1D726: [693,3,777,-32,703],
0x1D727: [681,9,1000,-28,1029],
0x1D728: [681,15,832,-24,859],
0x1D729: [689,3,684,-2,660],
0x1D72A: [695,17,832,38,795],
0x1D72B: [689,3,817,-25,843],
0x1D72C: [681,3,610,-21,631],
0x1D72D: [695,17,832,38,795],
0x1D72E: [689,3,659,-36,656],
0x1D72F: [681,3,666,61,704],
0x1D730: [705,0,698,41,742],
0x1D731: [689,3,957,44,921],
0x1D732: [695,3,666,-44,708],
0x1D733: [695,5,935,62,989],
0x1D734: [700,3,810,-11,779],
0x1D735: [693,0,686,83,717],
0x1D736: [478,21,663,46,635],
0x1D737: [705,282,582,-21,581],
0x1D738: [480,291,632,32,614],
0x1D739: [707,22,556,45,505],
0x1D73A: [479,21,463,47,436],
0x1D73B: [704,193,558,32,535],
0x1D73C: [480,279,560,31,518],
0x1D73D: [701,21,645,70,605],
0x1D73E: [481,17,272,30,249],
0x1D73F: [481,17,539,29,546],
0x1D740: [698,7,587,2,565],
0x1D741: [492,302,610,24,581],
0x1D742: [480,16,561,29,542],
0x1D743: [705,193,524,37,550],
0x1D744: [471,17,555,32,523],
0x1D745: [476,16,633,26,624],
0x1D746: [476,279,566,-17,536],
0x1D747: [477,193,515,49,484],
0x1D748: [492,25,570,46,600],
0x1D749: [480,17,518,46,529],
0x1D74A: [480,18,576,38,529],
0x1D74B: [478,277,836,50,791],
0x1D74C: [480,183,583,-47,600],
0x1D74D: [688,279,762,33,735],
0x1D74E: [480,14,817,47,767],
0x1D74F: [750,13,493,26,466],
0x1D750: [470,17,528,28,508],
0x1D751: [700,20,590,10,566],
0x1D752: [439,24,666,-7,787],
0x1D753: [688,279,742,48,695],
0x1D754: [476,266,566,81,565],
0x1D755: [566,14,817,45,768],
0x1D7CE: [689,18,499,33,468],
0x1D7CF: [699,3,499,35,455],
0x1D7D0: [689,3,499,25,472],
0x1D7D1: [689,18,499,22,458],
0x1D7D2: [702,3,499,12,473],
0x1D7D3: [685,18,499,42,472],
0x1D7D4: [689,18,499,37,469],
0x1D7D5: [685,3,499,46,493],
0x1D7D6: [689,18,499,34,467],
0x1D7D7: [689,18,499,31,463]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Normal"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Normal/Regular/Main.js"]
);

350
web/assets/MathJax/unpacked/jax/output/HTML-CSS/fonts/Asana-Math/Operators/Regular/Main.js vendored Normal file
View File

@@ -0,0 +1,350 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/fonts/Asana-Math/Operators/Regular/Main.js
*
* 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['HTML-CSS'].FONTDATA.FONTS['AsanaMathJax_Operators'] = {
directory: 'Operators/Regular',
family: 'AsanaMathJax_Operators',
testString: '\u2206\u220A\u220C\u220E\u220F\u2210\u2211\u221B\u221C\u221F\u222C\u222D\u222E\u222F\u2230',
0x20: [0,0,249,0,0],
0x2206: [697,4,688,27,662],
0x220A: [482,3,511,66,446],
0x220C: [648,107,563,55,509],
0x220E: [406,0,508,52,457],
0x220F: [626,311,994,54,941],
0x2210: [626,311,994,54,941],
0x2211: [620,310,850,62,788],
0x221B: [1048,59,739,63,772],
0x221C: [1045,59,739,63,771],
0x221F: [368,0,498,65,434],
0x222C: [885,442,1132,54,1058],
0x222D: [885,442,1496,54,1422],
0x222E: [885,442,768,54,694],
0x222F: [885,442,1132,54,1058],
0x2230: [885,442,1496,54,1422],
0x2231: [885,442,787,54,713],
0x2232: [885,442,787,54,713],
0x2233: [885,442,787,54,713],
0x2236: [518,-23,249,66,184],
0x2237: [518,-23,570,76,495],
0x2238: [538,-286,668,65,604],
0x2239: [518,-23,890,65,806],
0x223A: [518,-23,668,65,604],
0x223B: [518,-23,668,58,610],
0x223E: [422,-123,729,32,706],
0x223F: [587,3,784,34,750],
0x2244: [596,55,668,65,604],
0x2247: [596,55,668,65,604],
0x2249: [596,55,668,58,611],
0x224B: [614,-14,668,53,614],
0x224C: [587,-134,668,58,610],
0x2254: [518,-23,890,85,826],
0x2255: [518,-23,890,65,806],
0x2258: [587,-134,668,62,604],
0x2259: [646,-134,687,65,623],
0x225A: [646,-134,687,65,623],
0x225B: [652,-134,687,65,623],
0x225D: [658,-134,687,65,623],
0x225E: [632,-134,687,65,623],
0x225F: [751,-134,687,65,623],
0x2262: [596,55,668,65,604],
0x2263: [566,27,668,65,604],
0x226D: [596,55,668,54,616],
0x2274: [712,171,668,65,604],
0x2275: [712,171,668,65,604],
0x2278: [712,171,668,65,604],
0x2279: [712,171,668,65,604],
0x2284: [648,107,668,55,615],
0x2285: [648,107,668,55,615],
0x228C: [603,0,687,65,623],
0x228D: [603,0,687,65,623],
0x229C: [587,46,668,18,652],
0x22A6: [541,0,490,65,425],
0x22A7: [620,-1,709,85,624],
0x22AB: [541,0,748,64,684],
0x22B0: [652,118,748,75,673],
0x22B1: [652,118,748,75,674],
0x22B6: [446,-94,1363,65,1299],
0x22B7: [446,-94,1363,65,1299],
0x22B9: [505,-5,687,96,598],
0x22BD: [620,78,687,65,623],
0x22BE: [410,0,535,63,473],
0x22BF: [368,0,498,65,434],
0x22C0: [626,313,897,86,813],
0x22C1: [626,313,897,86,813],
0x22C2: [626,313,897,86,812],
0x22C3: [626,313,897,86,812],
0x22C7: [547,5,668,59,611],
0x22D5: [714,177,641,65,604],
0x22DC: [615,74,668,65,604],
0x22DD: [615,74,668,65,604],
0x22E2: [712,171,668,55,615],
0x22E3: [712,171,668,55,615],
0x22E4: [602,114,668,55,615],
0x22E5: [602,114,668,55,615],
0x22F0: [570,14,774,95,680],
0x22F2: [580,-22,876,53,824],
0x22F3: [533,-8,563,55,509],
0x22F4: [482,3,511,66,478],
0x22F5: [618,79,563,55,509],
0x22F6: [597,55,563,55,509],
0x22F7: [583,42,511,66,446],
0x22F8: [597,55,563,55,509],
0x22F9: [533,-8,563,55,509],
0x22FA: [580,-22,876,53,824],
0x22FB: [533,-8,563,55,509],
0x22FC: [482,3,511,66,478],
0x22FD: [597,55,563,55,509],
0x22FE: [583,42,511,66,446],
0x22FF: [697,0,617,46,572],
0x2A00: [830,316,1320,86,1235],
0x2A01: [833,316,1320,86,1235],
0x2A02: [833,316,1320,86,1235],
0x2A03: [741,198,897,86,812],
0x2A04: [741,198,897,86,812],
0x2A05: [734,192,897,86,812],
0x2A06: [734,192,897,86,812],
0x2A07: [626,313,1035,86,950],
0x2A08: [626,313,1035,86,950],
0x2A09: [734,192,1098,86,1013],
0x2A0A: [882,434,1158,60,1069],
0x2A0B: [885,442,850,27,764],
0x2A0C: [885,442,1860,54,1786],
0x2A0D: [885,442,768,54,694],
0x2A0E: [885,442,768,54,694],
0x2A0F: [885,442,768,54,694],
0x2A10: [885,442,768,54,694],
0x2A11: [885,442,810,54,736],
0x2A12: [885,442,768,54,694],
0x2A13: [885,442,768,54,694],
0x2A14: [885,442,768,54,694],
0x2A15: [885,442,768,54,694],
0x2A16: [885,442,768,54,694],
0x2A17: [885,442,1005,52,936],
0x2A18: [885,442,768,54,694],
0x2A19: [885,442,768,54,694],
0x2A1A: [885,442,768,54,694],
0x2A1B: [994,442,775,54,701],
0x2A1C: [994,442,775,54,701],
0x2A1D: [515,-23,758,65,694],
0x2A1E: [535,-6,668,65,604],
0x2A1F: [703,355,552,16,521],
0x2A20: [556,10,826,48,770],
0x2A21: [714,171,524,233,478],
0x2A22: [672,129,668,65,604],
0x2A23: [609,68,668,65,604],
0x2A24: [631,88,668,65,604],
0x2A25: [538,180,668,65,604],
0x2A26: [538,178,668,65,604],
0x2A27: [538,95,668,65,604],
0x2A28: [538,0,668,65,604],
0x2A29: [570,-233,605,51,555],
0x2A2A: [289,-74,605,51,555],
0x2A2B: [492,-30,605,51,555],
0x2A2C: [492,-30,605,51,555],
0x2A2D: [587,52,602,26,571],
0x2A2E: [587,52,602,26,571],
0x2A2F: [489,-53,554,59,496],
0x2A30: [688,5,668,59,611],
0x2A31: [545,142,668,59,611],
0x2A32: [547,5,760,58,702],
0x2A33: [554,11,671,53,619],
0x2A34: [587,52,603,54,550],
0x2A35: [587,52,603,54,550],
0x2A36: [634,192,668,18,652],
0x2A37: [587,46,668,18,652],
0x2A38: [587,46,668,18,652],
0x2A39: [559,18,666,44,623],
0x2A3A: [559,18,666,44,623],
0x2A3B: [559,18,666,44,623],
0x2A3C: [360,-88,672,65,608],
0x2A3D: [360,-88,672,65,608],
0x2A3E: [703,166,396,54,344],
0x2A40: [573,30,687,65,623],
0x2A41: [573,30,687,65,623],
0x2A42: [634,91,687,65,623],
0x2A43: [634,91,687,65,623],
0x2A44: [578,25,687,65,623],
0x2A45: [578,25,687,65,623],
0x2A46: [622,80,407,64,344],
0x2A47: [622,80,407,64,344],
0x2A48: [622,80,407,64,344],
0x2A49: [622,80,407,64,344],
0x2A4A: [422,-120,659,64,596],
0x2A4B: [422,-120,659,64,596],
0x2A4C: [601,58,779,64,716],
0x2A4D: [601,58,779,64,716],
0x2A4E: [559,17,687,65,623],
0x2A4F: [559,17,687,65,623],
0x2A50: [601,58,779,64,716],
0x2A51: [570,29,537,57,481],
0x2A52: [570,29,537,57,481],
0x2A53: [563,22,687,65,623],
0x2A54: [563,22,687,65,623],
0x2A55: [563,22,836,65,772],
0x2A56: [563,22,836,65,772],
0x2A57: [598,42,670,66,605],
0x2A58: [598,41,669,66,604],
0x2A59: [621,79,687,65,623],
0x2A5A: [563,22,687,65,623],
0x2A5B: [563,22,687,65,623],
0x2A5C: [563,22,687,65,623],
0x2A5D: [563,22,687,65,623],
0x2A5F: [720,27,687,65,623],
0x2A60: [640,267,687,65,623],
0x2A61: [497,-45,687,65,623],
0x2A62: [636,262,687,65,623],
0x2A63: [645,262,687,65,623],
0x2A64: [535,-6,668,65,604],
0x2A65: [535,-6,668,65,604],
0x2A66: [445,19,668,65,604],
0x2A67: [571,29,668,65,604],
0x2A68: [540,0,668,65,604],
0x2A69: [540,0,668,65,604],
0x2A6A: [429,-113,668,58,611],
0x2A6B: [500,-41,668,58,611],
0x2A6C: [514,-14,668,56,614],
0x2A6D: [581,39,668,65,604],
0x2A6E: [530,-12,668,65,604],
0x2A6F: [649,-51,668,58,611],
0x2A70: [596,55,668,65,604],
0x2A71: [667,126,668,66,604],
0x2A72: [667,126,668,66,604],
0x2A73: [507,-35,668,65,604],
0x2A74: [518,-23,1092,85,1028],
0x2A75: [406,-134,1347,85,1263],
0x2A76: [406,-134,1986,85,1902],
0x2A77: [599,58,668,65,604],
0x2A78: [567,25,668,65,604],
0x2A79: [535,-5,668,65,604],
0x2A7A: [535,-5,668,65,604],
0x2A7B: [623,82,668,65,604],
0x2A7C: [623,82,668,65,604],
0x2A7F: [615,74,668,65,604],
0x2A80: [615,74,668,65,604],
0x2A81: [615,74,668,65,604],
0x2A82: [615,74,668,65,604],
0x2A83: [700,159,668,65,604],
0x2A84: [700,159,668,65,604],
0x2A8D: [672,186,668,65,604],
0x2A8E: [672,186,668,65,604],
0x2A8F: [821,279,668,65,604],
0x2A90: [821,279,668,65,604],
0x2A91: [755,159,668,65,604],
0x2A92: [755,159,668,65,604],
0x2A93: [944,279,668,65,604],
0x2A94: [944,279,668,65,604],
0x2A97: [615,74,668,65,604],
0x2A98: [615,74,668,65,604],
0x2A99: [672,131,668,65,604],
0x2A9A: [672,131,668,65,604],
0x2A9B: [701,147,668,66,605],
0x2A9C: [701,147,668,66,605],
0x2A9D: [605,122,668,65,604],
0x2A9E: [605,122,668,65,604],
0x2A9F: [801,193,668,65,604],
0x2AA0: [801,193,668,65,604],
0x2AA1: [535,-5,668,65,604],
0x2AA2: [535,-5,668,65,604],
0x2AA3: [606,61,965,55,912],
0x2AA4: [535,-5,768,56,713],
0x2AA5: [535,-5,1251,55,1198],
0x2AA6: [535,-7,725,64,661],
0x2AA7: [535,-7,725,64,662],
0x2AA8: [613,74,725,64,661],
0x2AA9: [613,74,725,64,662],
0x2AAA: [553,5,713,65,649],
0x2AAB: [553,5,713,65,649],
0x2AAC: [635,61,713,65,649],
0x2AAD: [635,61,713,65,649],
0x2AAE: [550,8,668,65,604],
0x2AB1: [623,134,668,65,604],
0x2AB2: [623,134,668,65,604],
0x2AB3: [680,139,668,65,604],
0x2AB4: [680,139,668,65,604],
0x2ABB: [553,14,1057,65,993],
0x2ABC: [553,14,1057,65,993],
0x2ABD: [533,-8,668,55,615],
0x2ABE: [533,-8,668,55,615],
0x2ABF: [588,46,465,65,401],
0x2AC0: [588,46,465,65,401],
0x2AC1: [623,81,465,65,401],
0x2AC2: [623,81,465,65,401],
0x2AC3: [645,103,607,65,543],
0x2AC4: [645,103,607,65,543],
0x2AC7: [656,115,668,55,615],
0x2AC8: [656,115,668,55,615],
0x2AC9: [739,227,668,55,615],
0x2ACA: [739,227,668,55,615],
0x2ACD: [543,-2,1145,64,1082],
0x2ACE: [543,-2,1145,64,1082],
0x2ACF: [533,-8,668,55,615],
0x2AD0: [533,-8,668,55,615],
0x2AD1: [603,61,668,55,615],
0x2AD2: [603,61,668,55,615],
0x2AD3: [611,69,407,53,355],
0x2AD4: [611,69,407,53,355],
0x2AD5: [611,69,407,53,355],
0x2AD6: [611,69,407,53,355],
0x2AD7: [410,-130,764,53,711],
0x2AD8: [410,-130,764,53,711],
0x2AD9: [498,-44,613,45,569],
0x2ADA: [656,115,687,65,623],
0x2ADB: [771,150,687,65,623],
0x2ADC: [648,107,687,65,623],
0x2ADD: [571,31,687,65,623],
0x2ADE: [541,0,400,65,337],
0x2ADF: [408,-136,670,65,607],
0x2AE0: [408,-136,670,65,607],
0x2AE1: [579,0,748,65,684],
0x2AE2: [580,39,748,85,664],
0x2AE3: [580,39,859,85,795],
0x2AE4: [580,39,728,85,664],
0x2AE5: [580,39,859,85,795],
0x2AE6: [580,39,730,87,666],
0x2AE7: [473,-70,670,65,607],
0x2AE8: [473,-70,670,65,607],
0x2AE9: [579,37,670,65,607],
0x2AEA: [559,20,748,65,684],
0x2AEB: [559,20,748,65,684],
0x2AEC: [407,-135,672,65,608],
0x2AED: [407,-135,672,65,608],
0x2AEE: [714,171,437,0,438],
0x2AEF: [715,173,521,85,437],
0x2AF0: [714,174,521,85,437],
0x2AF1: [714,174,560,65,496],
0x2AF2: [714,171,644,70,575],
0x2AF3: [714,171,668,58,611],
0x2AF4: [714,171,560,61,500],
0x2AF5: [714,171,691,65,627],
0x2AF6: [709,164,286,85,202],
0x2AF7: [535,-7,668,65,604],
0x2AF8: [535,-7,668,65,604],
0x2AF9: [695,153,668,66,605],
0x2AFA: [695,153,668,66,605],
0x2AFB: [714,169,885,65,821],
0x2AFC: [763,222,620,71,550],
0x2AFD: [714,169,673,65,609],
0x2AFE: [541,0,383,64,320],
0x2AFF: [654,112,383,64,320]
};
MathJax.Callback.Queue(
["initFont",MathJax.OutputJax["HTML-CSS"],"AsanaMathJax_Operators"],
["loadComplete",MathJax.Ajax,MathJax.OutputJax["HTML-CSS"].fontDir+"/Operators/Regular/Main.js"]
);

Some files were not shown because too many files have changed in this diff Show More