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

Actualización

Browse Source
This commit is contained in:
Xes
2025-04-10 11:37:29 +02:00
parent 4bfeadb360
commit 8969cc929d
39112 changed files with 975884 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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