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

161
web/assets/MathJax/unpacked/extensions/AssistiveMML.js vendored Normal file
View File

@@ -0,0 +1,161 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/AssistiveMML.js
*
* Implements an extension that inserts hidden MathML into the
* page for screen readers or other asistive technology.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2015-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function (AJAX,CALLBACK,HUB,HTML) {
var SETTINGS = HUB.config.menuSettings;
var AssistiveMML = MathJax.Extension["AssistiveMML"] = {
version: "2.7.8",
config: HUB.CombineConfig("AssistiveMML",{
disabled: false,
styles: {
".MJX_Assistive_MathML": {
position:"absolute!important",
top: 0, left: 0,
clip: (HUB.Browser.isMSIE && (document.documentMode||0) < 8 ?
"rect(1px 1px 1px 1px)" : "rect(1px, 1px, 1px, 1px)"),
padding: "1px 0 0 0!important",
border: "0!important",
height: "1px!important",
width: "1px!important",
overflow: "hidden!important",
display:"block!important",
//
// Don't allow the assistive MathML become part of the selection
//
"-webkit-touch-callout": "none",
"-webkit-user-select": "none",
"-khtml-user-select": "none",
"-moz-user-select": "none",
"-ms-user-select": "none",
"user-select": "none"
},
".MJX_Assistive_MathML.MJX_Assistive_MathML_Block": {
width: "100%!important"
}
}
}),
Config: function () {
if (!this.config.disabled && SETTINGS.assistiveMML == null)
HUB.Config({menuSettings:{assistiveMML:true}});
AJAX.Styles(this.config.styles);
HUB.Register.MessageHook("End Math",function (msg) {
if (SETTINGS.assistiveMML) return AssistiveMML.AddAssistiveMathML(msg[1])
});
},
//
// This sets up a state object that lists the jax and index into the jax,
// and a dummy callback that is used to synchronizing with MathJax.
// It will be called when the jax are all processed, and that will
// let the MathJax queue continue (it will block until then).
//
AddAssistiveMathML: function (node) {
var state = {
jax: HUB.getAllJax(node), i: 0,
callback: MathJax.Callback({})
};
this.HandleMML(state);
return state.callback;
},
//
// This removes the data-mathml attribute and the assistive MathML from
// all the jax.
//
RemoveAssistiveMathML: function (node) {
var jax = HUB.getAllJax(node), frame;
for (var i = 0, m = jax.length; i < m; i++) {
frame = document.getElementById(jax[i].inputID+"-Frame");
if (frame && frame.getAttribute("data-mathml")) {
frame.removeAttribute("data-mathml");
if (frame.lastChild && frame.lastChild.className.match(/MJX_Assistive_MathML/))
frame.removeChild(frame.lastChild);
}
}
},
//
// For each jax in the state, look up the frame.
// If the jax doesn't use NativeMML and hasn't already been handled:
// Get the MathML for the jax, taking resets into account.
// Add a data-mathml attribute to the frame, and
// Create a span that is not visible on screen and put the MathML in it,
// and add it to the frame.
// When all the jax are processed, call the callback.
//
HandleMML: function (state) {
var m = state.jax.length, jax, mml, frame, span;
while (state.i < m) {
jax = state.jax[state.i];
frame = document.getElementById(jax.inputID+"-Frame");
if (jax.outputJax !== "NativeMML" && jax.outputJax !== "PlainSource" &&
frame && !frame.getAttribute("data-mathml")) {
try {
mml = jax.root.toMathML("").replace(/\n */g,"").replace(/<!--.*?-->/g,"");
} catch (err) {
if (!err.restart) throw err; // an actual error
return MathJax.Callback.After(["HandleMML",this,state],err.restart);
}
frame.setAttribute("data-mathml",mml);
span = HTML.addElement(frame,"span",{
isMathJax: true, unselectable: "on",
className: "MJX_Assistive_MathML"
+ (jax.root.Get("display") === "block" ? " MJX_Assistive_MathML_Block" : "")
});
try {span.innerHTML = mml} catch (err) {}
frame.style.position = "relative";
frame.setAttribute("role","presentation");
frame.firstChild.setAttribute("aria-hidden","true");
span.setAttribute("role","presentation");
}
state.i++;
}
state.callback();
}
};
HUB.Startup.signal.Post("AssistiveMML Ready");
})(MathJax.Ajax,MathJax.Callback,MathJax.Hub,MathJax.HTML);
//
// Make sure the toMathML extension is loaded before we signal
// the load complete for this extension. Then wait for the end
// of the user configuration before configuring this extension.
//
MathJax.Callback.Queue(
["Require",MathJax.Ajax,"[MathJax]/extensions/toMathML.js"],
["loadComplete",MathJax.Ajax,"[MathJax]/extensions/AssistiveMML.js"],
function () {
MathJax.Hub.Register.StartupHook("End Config",["Config",MathJax.Extension.AssistiveMML]);
}
);

30
web/assets/MathJax/unpacked/extensions/CHTML-preview.js vendored Normal file
View File

@@ -0,0 +1,30 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/CHTML-preview.js
*
* Backward compatibility with old CHTML-preview extension.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2014-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.Callback.Queue(
["Require",MathJax.Ajax,"[MathJax]/extensions/fast-preview.js"],
["loadComplete",MathJax.Ajax,"[MathJax]/extensions/CHTML-preview.js"]
);

313
web/assets/MathJax/unpacked/extensions/FontWarnings.js vendored Normal file
View File

@@ -0,0 +1,313 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/FontWarnings.js
*
* Implements a font warning message window that appears when
* the image fonts, no fonts, or web fonts are used, informing
* the user where to download the fonts, or to update to a more
* modern browser. The window will fade out automatically after
* a time, and the user can dismiss it by a close box.
*
* To include font warning messages, add "FontWarnings.js" to the
* extensions array in your MathJax configuration.
*
* You can customize the warning messages in a number of ways. Use the
* FontWarnings section of the configuration to specify any of the items
* shown in the CONFIG variable below. These include
*
* messageStyle the style to apply to the warning box that is
* displayed when MathJax uses one of its fallback
* methods.
*
* removeAfter the amount of time to show the warning message (in ms)
* fadeoutTime how long the message should take to fade out
* fadeoutSteps how many separate steps to use during the fade out
* (set to 0 to use no fadeout and simply remove the window)
*
* Messages stores the descriptions of the messages to use for the
* various warnings (webFonts, imageFonts, and noFonts).
* These are arrays of strings to be inserted into the window,
* or identifiers within brackets, which refer to the HTML
* snippets in the HTML section described below. To disable a
* specific message, set its value to null (see example below).
*
* HTML stores snippets of HTML descriptions for various
* common parts of the error messages. These include
* the closeBox, the message about web fonts being available
* in modern browser, and messages about downloadable fonts.
* The STIX and TeX font messages are used when only one
* of these is in the availableFonts list. The data for these
* are arrays of either strings to include or a description of
* an HTML item enclosed in square brackets. That description
* has (up to) three parts: the name of the tag to be included,
* a list (enclosed in braces) of attributes and their values
* to be set on the tag (optional), and an array of the contents
* of the tag (optional). See the definitions below for examples.
*
* For example,
*
* MathJax.Hub.Config({
* ...
* extensions: ["FontWarnings.js"],
* FontWarnings: {
* removeAfter: 20*1000, // 20 seconds
* messageStyle: {
* border: "2px solid black",
* padding: "2em"
* },
* Message: {
* webFont: null // no webfont messages (only image and no fonts)
* }
* }
* });
*
* would extend the time the message is displayed from 12 seconds to 20,
* and changes the border to a solid black one, with 2em of padding
* rather than the default of 1em.
*
* ---------------------------------------------------------------------
*
* 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 (HUB,HTML) {
var VERSION = "2.7.8";
var STIXURL = "http://www.stixfonts.org/";
var MATHJAXURL = "https://github.com/mathjax/MathJax/tree/master/fonts/HTML-CSS/TeX/otf";
var CONFIG = HUB.CombineConfig("FontWarnings",{
//
// The CSS for the message window
//
messageStyle: {
position:"fixed", bottom:"4em", left:"3em", width:"40em",
border: "3px solid #880000", "background-color": "#E0E0E0", color: "black",
padding: "1em", "font-size":"small", "white-space":"normal",
"border-radius": ".75em", // Opera 10.5 and IE9
"-webkit-border-radius": ".75em", // Safari and Chrome
"-moz-border-radius": ".75em", // Firefox
"-khtml-border-radius": ".75em", // Konqueror
"box-shadow": "4px 4px 10px #AAAAAA", // Opera 10.5 and IE9
"-webkit-box-shadow": "4px 4px 10px #AAAAAA", // Safari 3 and Chrome
"-moz-box-shadow": "4px 4px 10px #AAAAAA", // Forefox 3.5
"-khtml-box-shadow": "4px 4px 10px #AAAAAA", // Konqueror
filter: "progid:DXImageTransform.Microsoft.dropshadow(OffX=3, OffY=3, Color='gray', Positive='true')" // IE
},
//
// The messages for the various situations
//
Message: {
webFont: [
["closeBox"],
["webFont",
"MathJax is using web-based fonts to display the mathematics "+
"on this page. These take time to download, so the page would "+
"render faster if you installed math fonts directly in your "+
"system's font folder."],
["fonts"]
],
imageFonts: [
["closeBox"],
["imageFonts",
"MathJax is using its image fonts rather than local or web-based fonts. "+
"This will render slower than usual, and the mathematics may not print "+
"at the full resolution of your printer."],
["fonts"],
["webFonts"]
],
noFonts: [
["closeBox"],
["noFonts",
"MathJax is unable to locate a font to use to display "+
"its mathematics, and image fonts are not available, so it "+
"is falling back on generic unicode characters in hopes that "+
"your browser will be able to display them. Some characters "+
"may not show up properly, or possibly not at all."],
["fonts"],
["webFonts"]
]
},
//
// HTML objects that can be referred to in the message definitions
//
HTML: {
//
// The definition of the close box
//
closeBox: [[
"div",{
style: {
position:"absolute", overflow:"hidden", top:".1em", right:".1em",
border: "1px outset", width:"1em", height:"1em",
"text-align": "center", cursor: "pointer",
"background-color": "#EEEEEE", color:"#606060",
"border-radius": ".5em", // Opera 10.5
"-webkit-border-radius": ".5em", // Safari and Chrome
"-moz-border-radius": ".5em", // Firefox
"-khtml-border-radius": ".5em" // Konqueror
},
onclick: function () {
if (DATA.div && DATA.fade === 0)
{if (DATA.timer) {clearTimeout(DATA.timer)}; DATA.div.style.display = "none"}
}
},
[["span",{style:{position:"relative", bottom:".2em"}},["x"]]]
]],
webFonts: [
["p"],
["webFonts",
"Most modern browsers allow for fonts to be downloaded over the web. "+
"Updating to a more recent version of your browser (or changing "+
"browsers) could improve the quality of the mathematics on this page."
]
],
fonts: [
["p"],
["fonts",
"MathJax can use either the [STIX fonts](%1) or the [MathJax TeX fonts](%2). " +
"Download and install one of those fonts to improve your MathJax experience.",
STIXURL,MATHJAXURL
]
],
STIXfonts: [
["p"],
["STIXPage",
"This page is designed to use the [STIX fonts](%1). " +
"Download and install those fonts to improve your MathJax experience.",
STIXURL
]
],
TeXfonts: [
["p"],
["TeXPage",
"This page is designed to use the [MathJax TeX fonts](%1). " +
"Download and install those fonts to improve your MathJax experience.",
MATHJAXURL
]
]
},
removeAfter: 12*1000, // time to show message (in ms)
fadeoutSteps: 10, // fade-out steps
fadeoutTime: 1.5*1000 // fadeout over this amount of time (in ms)
});
if (MathJax.Hub.Browser.isIE9 && document.documentMode >= 9)
{delete CONFIG.messageStyle.filter}
//
// Data for the window
//
var DATA = {
div: null, // the message window, when displayed
fade: 0 // number of fade-out steps so far
};
//
// Create the message window and start the fade-out timer
//
var CREATEMESSAGE = function (data) {
if (DATA.div) return;
var HTMLCSS = MathJax.OutputJax["HTML-CSS"], frame = document.body;
if (HUB.Browser.isMSIE) {
if (CONFIG.messageStyle.position === "fixed") {
MathJax.Message.Init(); // make sure MathJax_MSIE_frame exists
frame = document.getElementById("MathJax_MSIE_Frame") || frame;
if (frame !== document.body) {CONFIG.messageStyle.position = "absolute"}
}
} else {delete CONFIG.messageStyle.filter}
CONFIG.messageStyle.maxWidth = (document.body.clientWidth-75) + "px";
var i = 0; while (i < data.length) {
if (MathJax.Object.isArray(data[i])) {
if (data[i].length === 1 && CONFIG.HTML[data[i][0]]) {
data.splice.apply(data,[i,1].concat(CONFIG.HTML[data[i][0]]));
} else if (typeof data[i][1] === "string") {
var message = MathJax.Localization.lookupPhrase(["FontWarnings",data[i][0]],data[i][1]);
message = MathJax.Localization.processMarkdown(message,data[i].slice(2),"FontWarnings");
data.splice.apply(data,[i,1].concat(message));
i += message.length;
} else {i++}
} else {i++}
}
DATA.div = HTMLCSS.addElement(frame,"div",
{id:"MathJax_FontWarning",style:CONFIG.messageStyle},data);
MathJax.Localization.setCSS(DATA.div);
if (CONFIG.removeAfter) {
HUB.Register.StartupHook("End",function ()
{DATA.timer = setTimeout(FADEOUT,CONFIG.removeAfter)});
}
HTML.Cookie.Set("fontWarn",{warned:true});
};
//
// Set the opacity based on the number of steps taken so far
// and remove the window when it gets to 0
//
var FADEOUT = function () {
DATA.fade++; if (DATA.timer) {delete DATA.timer}
if (DATA.fade < CONFIG.fadeoutSteps) {
var opacity = 1 - DATA.fade/CONFIG.fadeoutSteps;
DATA.div.style.opacity = opacity;
DATA.div.style.filter = "alpha(opacity="+Math.floor(100*opacity)+")";
setTimeout(FADEOUT,CONFIG.fadeoutTime/CONFIG.fadeoutSteps);
} else {
DATA.div.style.display = "none";
}
};
//
// Check that we haven't already issued a warning
//
if (!HTML.Cookie.Get("fontWarn").warned) {
//
// Hook into the Startup signal and look for font warning messages.
// When one comes, issue the correct message.
//
HUB.Startup.signal.Interest(function (message) {
if (message.match(/HTML-CSS Jax - /) && !DATA.div) {
var HTMLCSS = MathJax.OutputJax["HTML-CSS"], FONTS = HTMLCSS.config.availableFonts, MSG;
var localFonts = (FONTS && FONTS.length);
if (!localFonts) {CONFIG.HTML.fonts = [""]}
else if (FONTS.length === 1) {CONFIG.HTML.fonts = CONFIG.HTML[FONTS[0]+"fonts"]}
if (HTMLCSS.allowWebFonts) {CONFIG.HTML.webfonts = [""]}
if (message.match(/- Web-Font/)) {if (localFonts) {MSG = "webFont"}}
else if (message.match(/- using image fonts/)) {MSG = "imageFonts"}
else if (message.match(/- no valid font/)) {MSG = "noFonts"}
if (MSG && CONFIG.Message[MSG])
{MathJax.Localization.loadDomain("FontWarnings",[CREATEMESSAGE,CONFIG.Message[MSG]])}
}
});
}
})(MathJax.Hub,MathJax.HTML);
MathJax.Ajax.loadComplete("[MathJax]/extensions/FontWarnings.js");

49
web/assets/MathJax/unpacked/extensions/HTML-CSS/handle-floats.js vendored Normal file
View File

@@ -0,0 +1,49 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/HTML-CSS/handle-floats.js
*
* This extension allows HTML-CSS output to deal with floating elements
* better. In particular, when there are tags or equation numbers, these
* would overlap floating elements, but with this extension, the width of
* the line should properly correspond to the amount of space remaining.
*
* To load it, include
*
* "HTML-CSS": {
* extensions: ["handle-floats.js"]
* }
*
* in your configuration.
*
* ---------------------------------------------------------------------
*
* 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.Extension["HTML-CSS/handle-floats"] = {
version: "2.7.8"
};
//
// This file is now obsolete, since the HTML-CSS output already handles
// floating elements properly.
//
MathJax.Hub.Startup.signal.Post("HTML-CSS handle-floats Ready");
MathJax.Ajax.loadComplete("[MathJax]/extensions/HTML-CSS/handle-floats.js");

203
web/assets/MathJax/unpacked/extensions/HelpDialog.js vendored Normal file
View File

@@ -0,0 +1,203 @@
/*************************************************************
*
* MathJax/extensions/HelpDialog.js
*
* Implements the MathJax Help dialog box.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2013-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function (HUB,HTML,AJAX,OUTPUT,LOCALE) {
var HELP = MathJax.Extension.Help = {
version: "2.7.8"
};
var STIXURL = "http://www.stixfonts.org/";
var MENU = MathJax.Menu;
var FALSE, KEY;
HUB.Register.StartupHook("MathEvents Ready",function () {
FALSE = MathJax.Extension.MathEvents.Event.False;
KEY = MathJax.Extension.MathEvents.Event.KEY;
});
var CONFIG = HUB.CombineConfig("HelpDialog",{
styles: {
"#MathJax_Help": {
position:"fixed", left:"50%", width:"auto", "max-width": "90%", "text-align":"center",
border:"3px outset", padding:"1em 2em", "background-color":"#DDDDDD", color:"black",
cursor: "default", "font-family":"message-box", "font-size":"120%",
"font-style":"normal", "text-indent":0, "text-transform":"none",
"line-height":"normal", "letter-spacing":"normal", "word-spacing":"normal",
"word-wrap":"normal", "white-space":"wrap", "float":"none", "z-index":201,
"border-radius": "15px", // Opera 10.5 and IE9
"-webkit-border-radius": "15px", // Safari and Chrome
"-moz-border-radius": "15px", // Firefox
"-khtml-border-radius": "15px", // Konqueror
"box-shadow":"0px 10px 20px #808080", // Opera 10.5 and IE9
"-webkit-box-shadow":"0px 10px 20px #808080", // Safari 3 and Chrome
"-moz-box-shadow":"0px 10px 20px #808080", // Forefox 3.5
"-khtml-box-shadow":"0px 10px 20px #808080", // Konqueror
filter: "progid:DXImageTransform.Microsoft.dropshadow(OffX=2, OffY=2, Color='gray', Positive='true')" // IE
},
"#MathJax_Help.MathJax_MousePost": {
outline:"none"
},
"#MathJax_HelpContent": {
overflow:"auto", "text-align":"left", "font-size":"80%",
padding:".4em .6em", border:"1px inset", margin:"1em 0px",
"max-height":"20em", "max-width":"30em", "background-color":"#EEEEEE"
},
"#MathJax_HelpClose": {
position:"absolute", top:".2em", right:".2em",
cursor:"pointer",
display:"inline-block",
border:"2px solid #AAA",
"border-radius":"18px",
"-webkit-border-radius": "18px", // Safari and Chrome
"-moz-border-radius": "18px", // Firefox
"-khtml-border-radius": "18px", // Konqueror
"font-family":"'Courier New',Courier",
"font-size":"24px",
color:"#F0F0F0"
},
"#MathJax_HelpClose span": {
display:"block", "background-color":"#AAA", border:"1.5px solid",
"border-radius":"18px",
"-webkit-border-radius": "18px", // Safari and Chrome
"-moz-border-radius": "18px", // Firefox
"-khtml-border-radius": "18px", // Konqueror
"line-height":0,
padding:"8px 0 6px" // may need to be browser-specific
},
"#MathJax_HelpClose:hover": {
color:"white!important",
border:"2px solid #CCC!important"
},
"#MathJax_HelpClose:hover span": {
"background-color":"#CCC!important"
},
"#MathJax_HelpClose:hover:focus": {
outline:"none"
}
}
});
/*
* Handle the Help Dialog box
*/
HELP.Dialog = function (event) {
LOCALE.loadDomain("HelpDialog",["Post",HELP,event]);
};
HELP.Post = function (event) {
this.div = MENU.Background(this);
var help = HTML.addElement(this.div,"div",{
id: "MathJax_Help", tabIndex: 0, onkeydown: HELP.Keydown
},LOCALE._("HelpDialog",[
["b",{style:{fontSize:"120%"}},[["Help","MathJax Help"]]],
["div",{id: "MathJax_HelpContent", tabIndex: 0},[
["p",{},[["MathJax",
"*MathJax* is a JavaScript library that allows page authors to include " +
"mathematics within their web pages. As a reader, you don't need to do " +
"anything to make that happen."]]
],
["p",{},[["Browsers",
"*Browsers*: MathJax works with all modern browsers including IE6+, Firefox 3+, " +
"Chrome 0.2+, Safari 2+, Opera 9.6+ and most mobile browsers."]]
],
["p",{},[["Menu",
"*Math Menu*: MathJax adds a contextual menu to equations. Right-click or " +
"CTRL-click on any mathematics to access the menu."]]
],
["div",{style:{"margin-left":"1em"}},[
["p",{},[["ShowMath",
"*Show Math As* allows you to view the formula's source markup " +
"for copy & paste (as MathML or in its original format)."]]
],
["p",{},[["Settings",
"*Settings* gives you control over features of MathJax, such as the " +
"size of the mathematics, and the mechanism used to display equations."]]
],
["p",{},[["Language",
"*Language* lets you select the language used by MathJax for its menus " +
"and warning messages."]]
],
]],
["p",{},[["Zoom",
"*Math Zoom*: If you are having difficulty reading an equation, MathJax can " +
"enlarge it to help you see it better."]]
],
["p",{},[["Accessibilty",
"*Accessibility*: MathJax will automatically work with screen readers to make " +
"mathematics accessible to the visually impaired."]]
],
["p",{},[["Fonts",
"*Fonts*: MathJax will use certain math fonts if they are installed on your " +
"computer; otherwise, it will use web-based fonts. Although not required, " +
"locally installed fonts will speed up typesetting. We suggest installing " +
"the [STIX fonts](%1).",STIXURL]]
]
]],
["a",{href:"http://www.mathjax.org/"},["www.mathjax.org"]],
["span",{id: "MathJax_HelpClose", onclick: HELP.Remove,
onkeydown: HELP.Keydown, tabIndex: 0, role: "button",
"aria-label": LOCALE._(["HelpDialog","CloseDialog"],"Close help dialog")},
[["span",{},["\u00D7"]]]
]
]));
if (event.type === "mouseup") help.className += " MathJax_MousePost";
help.focus();
LOCALE.setCSS(help);
var doc = (document.documentElement||{});
var H = window.innerHeight || doc.clientHeight || doc.scrollHeight || 0;
if (MENU.prototype.msieAboutBug) {
help.style.width = "20em"; help.style.position = "absolute";
help.style.left = Math.floor((document.documentElement.scrollWidth - help.offsetWidth)/2)+"px";
help.style.top = (Math.floor((H-help.offsetHeight)/3)+document.body.scrollTop)+"px";
} else {
help.style.marginLeft = Math.floor(-help.offsetWidth/2)+"px";
help.style.top = Math.floor((H-help.offsetHeight)/3)+"px";
}
};
HELP.Remove = function (event) {
if (HELP.div) {document.body.removeChild(HELP.div); delete HELP.div}
};
HELP.Keydown = function(event) {
if (event.keyCode === KEY.ESCAPE ||
(this.id === "MathJax_HelpClose" &&
(event.keyCode === KEY.SPACE || event.keyCode === KEY.RETURN))) {
HELP.Remove(event);
MENU.CurrentNode().focus();
FALSE(event);
}
},
MathJax.Callback.Queue(
HUB.Register.StartupHook("End Config",{}), // wait until config is complete
["Styles",AJAX,CONFIG.styles],
["Post",HUB.Startup.signal,"HelpDialog Ready"],
["loadComplete",AJAX,"[MathJax]/extensions/HelpDialog.js"]
);
})(MathJax.Hub,MathJax.HTML,MathJax.Ajax,MathJax.OutputJax,MathJax.Localization);

309
web/assets/MathJax/unpacked/extensions/MatchWebFonts.js vendored Normal file
View File

@@ -0,0 +1,309 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/MatchWebFonts.js
*
* Adds code to the output jax so that if web fonts are used on the page,
* MathJax will be able to detect their arrival and update the math to
* accommodate the change in font. For the NativeMML output, this works
* both for web fonts in main text, and for web fonts in the math as well.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2013-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function (HUB,AJAX) {
var VERSION = "2.7.8";
var CONFIG = MathJax.Hub.CombineConfig("MatchWebFonts",{
matchFor: {
"HTML-CSS": true,
NativeMML: true,
SVG: true
},
fontCheckDelay: 500, // initial delay for the first check for web fonts
fontCheckTimeout: 15 * 1000, // how long to keep looking for fonts (15 seconds)
});
MathJax.Extension.MatchWebFonts = {
version: VERSION,
config: CONFIG
};
HUB.Register.StartupHook("HTML-CSS Jax Ready",function () {
var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
var POSTTRANSLATE = HTMLCSS.postTranslate;
HTMLCSS.Augment({
postTranslate: function (state,partial) {
if (!partial && CONFIG.matchFor["HTML-CSS"] && this.config.matchFontHeight) {
//
// Check for changes in the web fonts that might affect the font
// size for math elements. This is a periodic check that goes on
// until a timeout is reached.
//
AJAX.timer.start(AJAX,["checkFonts",this,state.jax[this.id]],
CONFIG.fontCheckDelay,CONFIG.fontCheckTimeout);
}
return POSTTRANSLATE.apply(this,arguments); // do the original function
},
checkFonts: function (check,scripts) {
if (check.time(function () {})) return;
var size = [], i, m, retry = false;
//
// Add the elements used for testing ex and em sizes
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i];
if (script.parentNode && script.MathJax.elementJax) {
script.parentNode.insertBefore(this.EmExSpan.cloneNode(true),script);
}
}
//
// Check to see if anything has changed
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i]; if (!script.parentNode) continue; retry = true;
var jax = script.MathJax.elementJax; if (!jax) continue;
//
// Check if ex or mex has changed
//
var test = script.previousSibling;
var ex = test.firstChild.offsetHeight/60;
var em = test.lastChild.lastChild.offsetHeight/60;
if (ex === 0 || ex === "NaN") {ex = this.defaultEx; em = this.defaultEm}
if (ex !== jax.HTMLCSS.ex || em !== jax.HTMLCSS.em) {
var scale = ex/this.TeX.x_height/em;
scale = Math.floor(Math.max(this.config.minScaleAdjust/100,scale)*this.config.scale);
if (scale/100 !== jax.scale) {size.push(script); scripts[i] = {}}
}
}
//
// Remove markers
//
scripts = scripts.concat(size); // some scripts have been moved to the size array
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i];
if (script && script.parentNode && script.MathJax.elementJax) {
script.parentNode.removeChild(script.previousSibling);
}
}
//
// Rerender the changed items
//
if (size.length) {HUB.Queue(["Rerender",HUB,[size],{}])}
//
// Try again later
//
if (retry) {setTimeout(check,check.delay)}
}
});
});
HUB.Register.StartupHook("SVG Jax Ready",function () {
var SVG = MathJax.OutputJax.SVG;
var POSTTRANSLATE = SVG.postTranslate;
SVG.Augment({
postTranslate: function (state,partial) {
if (!partial && CONFIG.matchFor.SVG) {
//
// Check for changes in the web fonts that might affect the font
// size for math elements. This is a periodic check that goes on
// until a timeout is reached.
//
AJAX.timer.start(AJAX,["checkFonts",this,state.jax[this.id]],
CONFIG.fontCheckDelay,CONFIG.fontCheckTimeout);
}
return POSTTRANSLATE.apply(this,arguments); // do the original function
},
checkFonts: function (check,scripts) {
if (check.time(function () {})) return;
var size = [], i, m, retry = false;
//
// Add the elements used for testing ex and em sizes
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i];
if (script.parentNode && script.MathJax.elementJax) {
script.parentNode.insertBefore(this.ExSpan.cloneNode(true),script);
}
}
//
// Check to see if anything has changed
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i]; if (!script.parentNode) continue; retry = true;
var jax = script.MathJax.elementJax; if (!jax) continue;
//
// Check if ex or mex has changed
//
var test = script.previousSibling;
var ex = test.firstChild.offsetHeight/60;
if (ex === 0 || ex === "NaN") {ex = this.defaultEx}
if (ex !== jax.SVG.ex) {size.push(script); scripts[i] = {}}
}
//
// Remove markers
//
scripts = scripts.concat(size); // some scripts have been moved to the size array
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i];
if (script.parentNode && script.MathJax.elementJax) {
script.parentNode.removeChild(script.previousSibling);
}
}
//
// Rerender the changed items
//
if (size.length) {HUB.Queue(["Rerender",HUB,[size],{}])}
//
// Try again later (if not all the scripts are null)
//
if (retry) setTimeout(check,check.delay);
}
});
});
HUB.Register.StartupHook("NativeMML Jax Ready",function () {
var nMML = MathJax.OutputJax.NativeMML;
var POSTTRANSLATE = nMML.postTranslate;
nMML.Augment({
postTranslate: function (state) {
if (!HUB.Browser.isMSIE && CONFIG.matchFor.NativeMML) {
//
// Check for changes in the web fonts that might affect the sizes
// of math elements. This is a periodic check that goes on until
// a timeout is reached.
//
AJAX.timer.start(AJAX,["checkFonts",this,state.jax[this.id]],
CONFIG.fontCheckDelay,CONFIG.fontCheckTimeout);
}
POSTTRANSLATE.apply(this,arguments); // do the original routine
},
//
// Check to see if web fonts have been loaded that change the ex size
// of the surrounding font, the ex size within the math, or the widths
// of math elements. We do this by rechecking the ex and mex sizes
// (to see if the font scaling needs adjusting) and by checking the
// size of the inner mrow of math elements and mtd elements. The
// sizes of these have been stored in the NativeMML object of the
// element jax so that we can check for them here.
//
checkFonts: function (check,scripts) {
if (check.time(function () {})) return;
var adjust = [], mtd = [], size = [], i, m, script;
//
// Add the elements used for testing ex and em sizes
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i];
if (script.parentNode && script.MathJax.elementJax) {
script.parentNode.insertBefore(this.EmExSpan.cloneNode(true),script);
}
}
//
// Check to see if anything has changed
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i]; if (!script.parentNode) continue;
var jax = script.MathJax.elementJax; if (!jax) continue;
var span = document.getElementById(jax.inputID+"-Frame");
var math = span.getElementsByTagName("math")[0]; if (!math) continue;
jax = jax.NativeMML;
//
// Check if ex or mex has changed
//
var test = script.previousSibling;
var ex = test.firstChild.offsetWidth/60;
var mex = test.lastChild.offsetWidth/60;
if (ex === 0 || ex === "NaN") {ex = this.defaultEx; mex = this.defaultMEx}
var newEx = (ex !== jax.ex);
if (newEx || mex != jax.mex) {
var scale = (this.config.matchFontHeight && mex > 1 ? ex/mex : 1);
scale = Math.floor(Math.max(this.config.minScaleAdjust/100,scale) * this.config.scale);
if (scale/100 !== jax.scale) {size.push([span.style,scale])}
jax.scale = scale/100; jax.fontScale = scale+"%"; jax.ex = ex; jax.mex = mex;
}
//
// Check width of math elements
//
if ("scrollWidth" in jax && (newEx || jax.scrollWidth !== math.firstChild.scrollWidth)) {
jax.scrollWidth = math.firstChild.scrollWidth;
adjust.push([math.parentNode.style,jax.scrollWidth/jax.ex/jax.scale]);
}
//
// Check widths of mtd elements
//
if (math.MathJaxMtds) {
for (var j = 0, n = math.MathJaxMtds.length; j < n; j++) {
if (!math.MathJaxMtds[j].parentNode) continue;
if (newEx || math.MathJaxMtds[j].firstChild.scrollWidth !== jax.mtds[j]) {
jax.mtds[j] = math.MathJaxMtds[j].firstChild.scrollWidth;
mtd.push([math.MathJaxMtds[j],jax.mtds[j]/jax.ex]);
}
}
}
}
//
// Remove markers
//
for (i = 0, m = scripts.length; i < m; i++) {
script = scripts[i];
if (script.parentNode && script.MathJax.elementJax) {
script.parentNode.removeChild(script.previousSibling);
}
}
//
// Adjust scaling factor
//
for (i = 0, m = size.length; i < m; i++) {
size[i][0].fontSize = size[i][1] + "%";
}
//
// Adjust width of spans containing math elements that have changed
//
for (i = 0, m = adjust.length; i < m; i++) {
adjust[i][0].width = adjust[i][1].toFixed(3)+"ex";
}
//
// Adjust widths of mtd elements that have changed
//
for (i = 0, m = mtd.length; i < m; i++) {
var style = mtd[i][0].getAttribute("style");
style = style.replace(/(($|;)\s*min-width:).*?ex/,"$1 "+mtd[i][1].toFixed(3)+"ex");
mtd[i][0].setAttribute("style",style);
}
//
// Try again later
//
setTimeout(check,check.delay);
}
});
});
HUB.Startup.signal.Post("MatchWebFonts Extension Ready");
AJAX.loadComplete("[MathJax]/extensions/MatchWebFonts.js");
})(MathJax.Hub,MathJax.Ajax);

619
web/assets/MathJax/unpacked/extensions/MathEvents.js vendored Normal file
View File

@@ -0,0 +1,619 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/MathEvents.js
*
* Implements the event handlers needed by the output jax to perform
* menu, hover, and other events.
*
* ---------------------------------------------------------------------
*
* 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.
*/
(function (HUB,HTML,AJAX,CALLBACK,LOCALE,OUTPUT,INPUT) {
var VERSION = "2.7.8";
var EXTENSION = MathJax.Extension;
var ME = EXTENSION.MathEvents = {version: VERSION};
var SETTINGS = HUB.config.menuSettings;
var CONFIG = {
hover: 500, // time required to be considered a hover
frame: {
x: 3.5, y: 5, // frame padding and
bwidth: 1, // frame border width (in pixels)
bcolor: "#A6D", // frame border color
hwidth: "15px", // haze width
hcolor: "#83A" // haze color
},
button: {
x: -6, y: -3, // menu button offsets
wx: -2 // button offset for full-width equations
},
fadeinInc: .2, // increment for fade-in
fadeoutInc: .05, // increment for fade-out
fadeDelay: 50, // delay between fade-in or fade-out steps
fadeoutStart: 400, // delay before fade-out after mouseout
fadeoutDelay: 15*1000, // delay before automatic fade-out
styles: {
".MathJax_Hover_Frame": {
"border-radius": ".25em", // Opera 10.5 and IE9
"-webkit-border-radius": ".25em", // Safari and Chrome
"-moz-border-radius": ".25em", // Firefox
"-khtml-border-radius": ".25em", // Konqueror
"box-shadow": "0px 0px 15px #83A", // Opera 10.5 and IE9
"-webkit-box-shadow": "0px 0px 15px #83A", // Safari and Chrome
"-moz-box-shadow": "0px 0px 15px #83A", // Forefox
"-khtml-box-shadow": "0px 0px 15px #83A", // Konqueror
border: "1px solid #A6D ! important",
display: "inline-block", position:"absolute"
},
".MathJax_Menu_Button .MathJax_Hover_Arrow": {
position:"absolute",
cursor:"pointer",
display:"inline-block",
border:"2px solid #AAA",
"border-radius":"4px",
"-webkit-border-radius": "4px", // Safari and Chrome
"-moz-border-radius": "4px", // Firefox
"-khtml-border-radius": "4px", // Konqueror
"font-family":"'Courier New',Courier",
"font-size":"9px",
color:"#F0F0F0"
},
".MathJax_Menu_Button .MathJax_Hover_Arrow span": {
display:"block",
"background-color":"#AAA",
border:"1px solid",
"border-radius":"3px",
"line-height":0,
padding:"4px"
},
".MathJax_Hover_Arrow:hover": {
color:"white!important",
border:"2px solid #CCC!important"
},
".MathJax_Hover_Arrow:hover span": {
"background-color":"#CCC!important"
}
}
};
//
// Common event-handling code
//
var EVENT = ME.Event = {
LEFTBUTTON: 0, // the event.button value for left button
RIGHTBUTTON: 2, // the event.button value for right button
MENUKEY: "altKey", // the event value for alternate context menu
/*************************************************************/
/*
* Enum element for key codes.
*/
KEY: {
RETURN: 13,
ESCAPE: 27,
SPACE: 32,
LEFT: 37,
UP: 38,
RIGHT: 39,
DOWN: 40
},
Mousedown: function (event) {return EVENT.Handler(event,"Mousedown",this)},
Mouseup: function (event) {return EVENT.Handler(event,"Mouseup",this)},
Mousemove: function (event) {return EVENT.Handler(event,"Mousemove",this)},
Mouseover: function (event) {return EVENT.Handler(event,"Mouseover",this)},
Mouseout: function (event) {return EVENT.Handler(event,"Mouseout",this)},
Click: function (event) {return EVENT.Handler(event,"Click",this)},
DblClick: function (event) {return EVENT.Handler(event,"DblClick",this)},
Menu: function (event) {return EVENT.Handler(event,"ContextMenu",this)},
//
// Call the output jax's event handler or the zoom handler
//
Handler: function (event,type,math) {
if (AJAX.loadingMathMenu) {return EVENT.False(event)}
var jax = OUTPUT[math.jaxID];
if (!event) {event = window.event}
event.isContextMenu = (type === "ContextMenu");
if (jax[type]) {return jax[type](event,math)}
if (EXTENSION.MathZoom) {return EXTENSION.MathZoom.HandleEvent(event,type,math)}
},
//
// Try to cancel the event in every way we can
//
False: function (event) {
if (!event) {event = window.event}
if (event) {
if (event.preventDefault) {event.preventDefault()} else {event.returnValue = false}
if (event.stopPropagation) {event.stopPropagation()}
event.cancelBubble = true;
}
return false;
},
//
// Keydown event handler. Should only fire on Space key.
//
Keydown: function (event, math) {
if (!event) event = window.event;
if (event.keyCode === EVENT.KEY.SPACE) {
EVENT.ContextMenu(event, this);
};
},
//
// Load the contextual menu code, if needed, and post the menu
//
ContextMenu: function (event,math,force) {
//
// Check if we are showing menus
//
var JAX = OUTPUT[math.jaxID], jax = JAX.getJaxFromMath(math);
var show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu;
if (!show || (SETTINGS.context !== "MathJax" && !force)) return;
//
// Remove selections, remove hover fades
//
if (ME.msieEventBug) {event = window.event || event}
EVENT.ClearSelection(); HOVER.ClearHoverTimer();
if (jax.hover) {
if (jax.hover.remove) {clearTimeout(jax.hover.remove); delete jax.hover.remove}
jax.hover.nofade = true;
}
//
// If the menu code is loaded,
// Check if localization needs loading;
// If not, post the menu, and return.
// Otherwise wait for the localization to load
// Otherwse load the menu code.
// Try again after the file is loaded.
//
var MENU = MathJax.Menu; var load, fn;
if (MENU) {
if (MENU.loadingDomain) {return EVENT.False(event)}
load = LOCALE.loadDomain("MathMenu");
if (!load) {
MENU.jax = jax;
var source = MENU.menu.Find("Show Math As").submenu;
source.items[0].name = jax.sourceMenuTitle;
source.items[0].format = (jax.sourceMenuFormat||"MathML");
source.items[1].name = INPUT[jax.inputJax].sourceMenuTitle;
source.items[5].disabled = !INPUT[jax.inputJax].annotationEncoding;
//
// Try and find each known annotation format and enable the menu
// items accordingly.
//
var annotations = source.items[2]; annotations.disabled = true;
var annotationItems = annotations.submenu.items;
annotationList = MathJax.Hub.Config.semanticsAnnotations;
for (var i = 0, m = annotationItems.length; i < m; i++) {
var name = annotationItems[i].name[1]
if (jax.root && jax.root.getAnnotation(name) !== null) {
annotations.disabled = false;
annotationItems[i].hidden = false;
} else {
annotationItems[i].hidden = true;
}
}
var MathPlayer = MENU.menu.Find("Math Settings","MathPlayer");
MathPlayer.hidden = !(jax.outputJax === "NativeMML" && HUB.Browser.hasMathPlayer);
return MENU.menu.Post(event);
}
MENU.loadingDomain = true;
fn = function () {delete MENU.loadingDomain};
} else {
if (AJAX.loadingMathMenu) {return EVENT.False(event)}
AJAX.loadingMathMenu = true;
load = AJAX.Require("[MathJax]/extensions/MathMenu.js");
fn = function () {
delete AJAX.loadingMathMenu;
if (!MathJax.Menu) {MathJax.Menu = {}}
}
}
var ev = {
pageX:event.pageX, pageY:event.pageY,
clientX:event.clientX, clientY:event.clientY
};
CALLBACK.Queue(
load, fn, // load the file and delete the marker when done
["ContextMenu",EVENT,ev,math,force] // call this function again
);
return EVENT.False(event);
},
//
// Mousedown handler for alternate means of accessing menu
//
AltContextMenu: function (event,math) {
var JAX = OUTPUT[math.jaxID];
var show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu;
if (show) {
show = (JAX.config.showMathMenuMSIE != null ? JAX : HUB).config.showMathMenuMSIE;
if (SETTINGS.context === "MathJax" && !SETTINGS.mpContext && show) {
if (!ME.noContextMenuBug || event.button !== EVENT.RIGHTBUTTON) return;
} else {
if (!event[EVENT.MENUKEY] || event.button !== EVENT.LEFTBUTTON) return;
}
return JAX.ContextMenu(event,math,true);
}
},
ClearSelection: function () {
if (ME.safariContextMenuBug) {setTimeout("window.getSelection().empty()",0)}
if (document.selection) {setTimeout("document.selection.empty()",0)}
},
getBBox: function (span) {
span.appendChild(ME.topImg);
var h = ME.topImg.offsetTop, d = span.offsetHeight-h, w = span.offsetWidth;
span.removeChild(ME.topImg);
return {w:w, h:h, d:d};
}
};
//
// Handle hover "discoverability"
//
var HOVER = ME.Hover = {
//
// Check if we are moving from a non-MathJax element to a MathJax one
// and either start fading in again (if it is fading out) or start the
// timer for the hover
//
Mouseover: function (event,math) {
if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") {
var from = event.fromElement || event.relatedTarget,
to = event.toElement || event.target;
if (from && to && (HUB.isMathJaxNode(from) !== HUB.isMathJaxNode(to) ||
HUB.getJaxFor(from) !== HUB.getJaxFor(to))) {
var jax = this.getJaxFromMath(math);
if (jax.hover) {HOVER.ReHover(jax)} else {HOVER.HoverTimer(jax,math)}
return EVENT.False(event);
}
}
},
//
// Check if we are moving from a MathJax element to a non-MathJax one
// and either start fading out, or clear the timer if we haven't
// hovered yet
//
Mouseout: function (event,math) {
if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") {
var from = event.fromElement || event.relatedTarget,
to = event.toElement || event.target;
if (from && to && (HUB.isMathJaxNode(from) !== HUB.isMathJaxNode(to) ||
HUB.getJaxFor(from) !== HUB.getJaxFor(to))) {
var jax = this.getJaxFromMath(math);
if (jax.hover) {HOVER.UnHover(jax)} else {HOVER.ClearHoverTimer()}
return EVENT.False(event);
}
}
},
//
// Restart hover timer if the mouse moves
//
Mousemove: function (event,math) {
if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") {
var jax = this.getJaxFromMath(math); if (jax.hover) return;
if (HOVER.lastX == event.clientX && HOVER.lastY == event.clientY) return;
HOVER.lastX = event.clientX; HOVER.lastY = event.clientY;
HOVER.HoverTimer(jax,math);
return EVENT.False(event);
}
},
//
// Clear the old timer and start a new one
//
HoverTimer: function (jax,math) {
this.ClearHoverTimer();
this.hoverTimer = setTimeout(CALLBACK(["Hover",this,jax,math]),CONFIG.hover);
},
ClearHoverTimer: function () {
if (this.hoverTimer) {clearTimeout(this.hoverTimer); delete this.hoverTimer}
},
//
// Handle putting up the hover frame
//
Hover: function (jax,math) {
//
// Check if Zoom handles the hover event
//
if (EXTENSION.MathZoom && EXTENSION.MathZoom.Hover({},math)) return;
//
// Get the hover data
//
var JAX = OUTPUT[jax.outputJax],
span = JAX.getHoverSpan(jax,math),
bbox = JAX.getHoverBBox(jax,span,math),
show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu;
var dx = CONFIG.frame.x, dy = CONFIG.frame.y, dd = CONFIG.frame.bwidth; // frame size
if (ME.msieBorderWidthBug) {dd = 0}
jax.hover = {opacity:0, id:jax.inputID+"-Hover"};
//
// The frame and menu button
//
var frame = HTML.Element("span",{
id:jax.hover.id, isMathJax: true,
style:{display:"inline-block", width:0, height:0, position:"relative"}
},[["span",{
className:"MathJax_Hover_Frame", isMathJax: true,
style:{
display:"inline-block", position:"absolute",
top:this.Px(-bbox.h-dy-dd-(bbox.y||0)), left:this.Px(-dx-dd+(bbox.x||0)),
width:this.Px(bbox.w+2*dx), height:this.Px(bbox.h+bbox.d+2*dy),
opacity:0, filter:"alpha(opacity=0)"
}}
]]
);
var button = HTML.Element("span",{
isMathJax: true, id:jax.hover.id+"Menu", className:"MathJax_Menu_Button",
style:{display:"inline-block", "z-index": 1, width:0, height:0, position:"relative"}
},[["span",{
className: "MathJax_Hover_Arrow", isMathJax: true, math: math,
onclick: this.HoverMenu, jax:JAX.id,
style: {
left:this.Px(bbox.w+dx+dd+(bbox.x||0)+CONFIG.button.x),
top:this.Px(-bbox.h-dy-dd-(bbox.y||0)-CONFIG.button.y),
opacity:0, filter:"alpha(opacity=0)"
}
},[["span",{isMathJax:true},"\u25BC"]]]]
);
if (bbox.width) {
frame.style.width = button.style.width = bbox.width;
frame.style.marginRight = button.style.marginRight = "-"+bbox.width;
frame.firstChild.style.width = bbox.width;
button.firstChild.style.left = "";
button.firstChild.style.right = this.Px(CONFIG.button.wx);
}
//
// Add the frame and button
//
span.parentNode.insertBefore(frame,span);
if (show) {span.parentNode.insertBefore(button,span)}
if (span.style) {span.style.position = "relative"} // so math is on top of hover frame
//
// Start the hover fade-in
//
this.ReHover(jax);
},
//
// Restart the hover fade in and fade-out timers
//
ReHover: function (jax) {
if (jax.hover.remove) {clearTimeout(jax.hover.remove)}
jax.hover.remove = setTimeout(CALLBACK(["UnHover",this,jax]),CONFIG.fadeoutDelay);
this.HoverFadeTimer(jax,CONFIG.fadeinInc);
},
//
// Start the fade-out
//
UnHover: function (jax) {
if (!jax.hover.nofade) {this.HoverFadeTimer(jax,-CONFIG.fadeoutInc,CONFIG.fadeoutStart)}
},
//
// Handle the fade-in and fade-out
//
HoverFade: function (jax) {
delete jax.hover.timer;
jax.hover.opacity = Math.max(0,Math.min(1,jax.hover.opacity + jax.hover.inc));
jax.hover.opacity = Math.floor(1000*jax.hover.opacity)/1000;
var frame = document.getElementById(jax.hover.id),
button = document.getElementById(jax.hover.id+"Menu");
frame.firstChild.style.opacity = jax.hover.opacity;
frame.firstChild.style.filter = "alpha(opacity="+Math.floor(100*jax.hover.opacity)+")";
if (button) {
button.firstChild.style.opacity = jax.hover.opacity;
button.firstChild.style.filter = frame.style.filter;
}
if (jax.hover.opacity === 1) {return}
if (jax.hover.opacity > 0) {this.HoverFadeTimer(jax,jax.hover.inc); return}
frame.parentNode.removeChild(frame);
if (button) {button.parentNode.removeChild(button)}
if (jax.hover.remove) {clearTimeout(jax.hover.remove)}
delete jax.hover;
},
//
// Set the fade to in or out (via inc) and start the timer, if needed
//
HoverFadeTimer: function (jax,inc,delay) {
jax.hover.inc = inc;
if (!jax.hover.timer) {
jax.hover.timer = setTimeout(CALLBACK(["HoverFade",this,jax]),(delay||CONFIG.fadeDelay));
}
},
//
// Handle a click on the menu button
//
HoverMenu: function (event) {
if (!event) {event = window.event}
return OUTPUT[this.jax].ContextMenu(event,this.math,true);
},
//
// Clear all hover timers
//
ClearHover: function (jax) {
if (jax.hover.remove) {clearTimeout(jax.hover.remove)}
if (jax.hover.timer) {clearTimeout(jax.hover.timer)}
HOVER.ClearHoverTimer();
delete jax.hover;
},
//
// Make a measurement in pixels
//
Px: function (m) {
if (Math.abs(m) < .006) {return "0px"}
return m.toFixed(2).replace(/\.?0+$/,"") + "px";
},
//
// Preload images so they show up with the menu
//
getImages: function () {
if (SETTINGS.discoverable) {
var menu = new Image();
menu.src = CONFIG.button.src;
}
}
};
//
// Handle touch events.
//
// Use double-tap-and-hold as a replacement for context menu event.
// Use double-tap as a replacement for double click.
//
var TOUCH = ME.Touch = {
last: 0, // time of last tap event
delay: 500, // delay time for double-click
//
// Check if this is a double-tap, and if so, start the timer
// for the double-tap and hold (to trigger the contextual menu)
//
start: function (event) {
var now = new Date().getTime();
var dblTap = (now - TOUCH.last < TOUCH.delay && TOUCH.up);
TOUCH.last = now; TOUCH.up = false;
if (dblTap) {
TOUCH.timeout = setTimeout(TOUCH.menu,TOUCH.delay,event,this);
event.preventDefault();
}
},
//
// Check if there is a timeout pending, i.e., we have a
// double-tap and were waiting to see if it is held long
// enough for the menu. Since we got the end before the
// timeout, it is a double-click, not a double-tap-and-hold.
// Prevent the default action and issue a double click.
//
end: function (event) {
var now = new Date().getTime();
TOUCH.up = (now - TOUCH.last < TOUCH.delay);
if (TOUCH.timeout) {
clearTimeout(TOUCH.timeout);
delete TOUCH.timeout; TOUCH.last = 0; TOUCH.up = false;
event.preventDefault();
return EVENT.Handler((event.touches[0]||event.touch),"DblClick",this);
}
},
//
// If the timeout passes without an end event, we issue
// the contextual menu event.
//
menu: function (event,math) {
delete TOUCH.timeout; TOUCH.last = 0; TOUCH.up = false;
return EVENT.Handler((event.touches[0]||event.touch),"ContextMenu",math);
}
};
/*
* //
* // Mobile screens are small, so use larger version of arrow
* //
* if (HUB.Browser.isMobile) {
* var arrow = CONFIG.styles[".MathJax_Hover_Arrow"];
* arrow.width = "25px"; arrow.height = "18px";
* CONFIG.button.x = -6;
* }
*/
//
// Set up browser-specific values
//
HUB.Browser.Select({
MSIE: function (browser) {
var mode = (document.documentMode || 0);
var isIE8 = browser.versionAtLeast("8.0");
ME.msieBorderWidthBug = (document.compatMode === "BackCompat"); // borders are inside offsetWidth/Height
ME.msieEventBug = browser.isIE9; // must get event from window even though event is passed
ME.msieAlignBug = (!isIE8 || mode < 8); // inline-block spans don't rest on baseline
if (mode < 9) {EVENT.LEFTBUTTON = 1} // IE < 9 has wrong event.button values
},
Safari: function (browser) {
ME.safariContextMenuBug = true; // selection can be started by contextmenu event
},
Opera: function (browser) {
ME.operaPositionBug = true; // position is wrong unless border is used
},
Konqueror: function (browser) {
ME.noContextMenuBug = true; // doesn't produce contextmenu event
}
});
//
// Used in measuring zoom and hover positions
//
ME.topImg = (ME.msieAlignBug ?
HTML.Element("img",{style:{width:0,height:0,position:"relative"},src:"about:blank"}) :
HTML.Element("span",{style:{width:0,height:0,display:"inline-block"}})
);
if (ME.operaPositionBug) {ME.topImg.style.border="1px solid"}
//
// Get configuration from user
//
ME.config = CONFIG = HUB.CombineConfig("MathEvents",CONFIG);
var SETFRAME = function () {
var haze = CONFIG.styles[".MathJax_Hover_Frame"];
haze.border = CONFIG.frame.bwidth+"px solid "+CONFIG.frame.bcolor+" ! important";
haze["box-shadow"] = haze["-webkit-box-shadow"] =
haze["-moz-box-shadow"] = haze["-khtml-box-shadow"] =
"0px 0px "+CONFIG.frame.hwidth+" "+CONFIG.frame.hcolor;
};
//
// Queue the events needed for startup
//
CALLBACK.Queue(
HUB.Register.StartupHook("End Config",{}), // wait until config is complete
[SETFRAME],
["getImages",HOVER],
["Styles",AJAX,CONFIG.styles],
["Post",HUB.Startup.signal,"MathEvents Ready"],
["loadComplete",AJAX,"[MathJax]/extensions/MathEvents.js"]
);
})(MathJax.Hub,MathJax.HTML,MathJax.Ajax,MathJax.Callback,
MathJax.Localization,MathJax.OutputJax,MathJax.InputJax);

1743
web/assets/MathJax/unpacked/extensions/MathML/content-mathml.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

784
web/assets/MathJax/unpacked/extensions/MathML/mml3.js vendored Normal file
View File

@@ -0,0 +1,784 @@
/*************************************************************
*
* MathJax/extensions/MathML/mml3.js
*
* This file implements an XSLT transform to convert some MathML 3
* constructs to constructs MathJax can render. The transform is
* performed in a pre-filter for the MathML input jax, so that the
* Show Math As menu will still show the Original MathML correctly,
* but the transformed MathML can be obtained from the regular MathML menu.
*
* To load it, include
*
* MathML: {
* extensions: ["mml3.js"]
* }
*
* in your configuration.
*
* A portion of this file is taken from mml3mj.xsl which is
* Copyright (c) David Carlisle 2008-2015
* and is used by permission of David Carlisle, who has agreed to allow us
* to release it under the Apache2 license (see below). That portion is
* indicated via comments.
*
* The remainder falls under the copyright that follows.
* ---------------------------------------------------------------------
*
* Copyright (c) 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.Extension["MathML/mml3"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("MathML Jax Ready",function () {
var MATHML = MathJax.InputJax.MathML,
PARSE = MATHML.Parse.prototype;
MATHML.prefilterHooks.Add(function (data) {
if (!MATHML.mml3XSLT) return;
// Parse the <math> but use MATHML.Parse's preProcessMath to apply the normal preprocessing.
if (!MATHML.ParseXML) {MATHML.ParseXML = MATHML.createParser()}
var doc = MATHML.ParseXML(PARSE.preProcessMath(data.math));
// Now transform the <math> using the mml3 stylesheet.
var newdoc = MATHML.mml3XSLT.transformToDocument(doc);
if ((typeof newdoc) === "string") {
// Internet Explorer returns a string, so just use it.
data.math = newdoc;
} else if (window.XMLSerializer) {
// Serialize the <math> again. We could directly provide the DOM content
// but other prefilterHooks may assume data.math is still a string.
var serializer = new XMLSerializer();
data.math = serializer.serializeToString(newdoc.documentElement, doc);
}
});
/*
* The following is derived from mml3mj.xsl
* (https://github.com/davidcarlisle/web-xslt/blob/master/ctop/mml3mj.xsl)
* which is Copyright (c) David Carlisle 2008-2015.
* It is used by permission of David Carlisle, who has agreed to allow it to
* be released under the Apache License, Version 2.0.
*/
var BROWSER = MathJax.Hub.Browser;
var exslt = '';
if (BROWSER.isEdge || BROWSER.isMSIE) {
exslt = 'urn:schemas-microsoft-com:xslt'
} else {
exslt = 'http://exslt.org/common';
}
var mml3Stylesheet =
'<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ' +
' xmlns:m="http://www.w3.org/1998/Math/MathML"' +
' xmlns:c="' + exslt + '"' +
' exclude-result-prefixes="m c">' +
'<xsl:output indent="yes" omit-xml-declaration="yes"/>' +
'<xsl:output indent="yes" omit-xml-declaration="yes"/><xsl:template match="*">' +
' <xsl:copy>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:apply-templates/>' +
' </xsl:copy>' +
'</xsl:template><xsl:template match="m:*[@dir=\'rtl\']" priority="10">' +
' <xsl:apply-templates mode="rtl" select="."/>' +
'</xsl:template><xsl:template match="@*" mode="rtl">' +
' <xsl:copy-of select="."/>' +
' <xsl:attribute name="dir">ltr</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="*" mode="rtl">' +
' <xsl:copy>' +
' <xsl:apply-templates select="@*" mode="rtl"/>' +
' <xsl:for-each select="node()">' +
' <xsl:sort data-type="number" order="descending" select="position()"/>' +
' <xsl:text> </xsl:text>' +
' <xsl:apply-templates mode="rtl" select="."/>' +
' </xsl:for-each>' +
' </xsl:copy>' +
'</xsl:template><xsl:template match="@open" mode="rtl">' +
' <xsl:attribute name="close"><xsl:value-of select="."/></xsl:attribute>' +
'</xsl:template><xsl:template match="@open[.=\'(\']" mode="rtl">' +
' <xsl:attribute name="close">)</xsl:attribute>' +
'</xsl:template><xsl:template match="@open[.=\')\']" mode="rtl">' +
' <xsl:attribute name="close">(</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@open[.=\'[\']" mode="rtl">' +
' <xsl:attribute name="close">]</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@open[.=\']\']" mode="rtl">' +
' <xsl:attribute name="close">[</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@open[.=\'{\']" mode="rtl">' +
' <xsl:attribute name="close">}</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@open[.=\'}\']" mode="rtl">' +
' <xsl:attribute name="close">{</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@close" mode="rtl">' +
' <xsl:attribute name="open"><xsl:value-of select="."/></xsl:attribute>' +
'</xsl:template><xsl:template match="@close[.=\'(\']" mode="rtl">' +
' <xsl:attribute name="open">)</xsl:attribute>' +
'</xsl:template><xsl:template match="@close[.=\')\']" mode="rtl">' +
' <xsl:attribute name="open">(</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@close[.=\'[\']" mode="rtl">' +
' <xsl:attribute name="open">]</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@close[.=\']\']" mode="rtl">' +
' <xsl:attribute name="open">[</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@close[.=\'{\']" mode="rtl">' +
' <xsl:attribute name="open">}</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="@close[.=\'}\']" mode="rtl">' +
' <xsl:attribute name="open">{</xsl:attribute>' +
'</xsl:template><xsl:template match="m:mfrac[@bevelled=\'true\']" mode="rtl">' +
' <m:mrow>' +
' <m:msub><m:mi></m:mi><xsl:apply-templates select="*[2]" mode="rtl"/></m:msub>' +
' <m:mo>&#x5c;</m:mo>' +
' <m:msup><m:mi></m:mi><xsl:apply-templates select="*[1]" mode="rtl"/></m:msup>' +
' </m:mrow>' +
'</xsl:template><xsl:template match="m:mfrac" mode="rtl">' +
' <xsl:copy>' +
' <xsl:apply-templates mode="rtl" select="@*|*"/>' +
' </xsl:copy>' +
'</xsl:template><xsl:template match="m:mroot" mode="rtl">' +
' <m:msup>' +
' <m:menclose notation="top right">' +
' <xsl:apply-templates mode="rtl" select="@*|*[1]"/>' +
' </m:menclose>' +
' <xsl:apply-templates mode="rtl" select="*[2]"/>' +
' </m:msup>' +
'</xsl:template>' +
'<xsl:template match="m:msqrt" mode="rtl">' +
' <m:menclose notation="top right">' +
' <xsl:apply-templates mode="rtl" select="@*|*[1]"/>' +
' </m:menclose>' +
'</xsl:template><xsl:template match="m:mtable|m:munder|m:mover|m:munderover" mode="rtl" priority="2">' +
' <xsl:copy>' +
' <xsl:apply-templates select="@*" mode="rtl"/>' +
' <xsl:apply-templates mode="rtl">' +
' </xsl:apply-templates>' +
' </xsl:copy>' +
'</xsl:template>' +
'<xsl:template match="m:msup" mode="rtl" priority="2">' +
' <m:mmultiscripts>' +
' <xsl:apply-templates select="*[1]" mode="rtl"/>' +
' <m:mprescripts/>' +
' <m:none/>' +
' <xsl:apply-templates select="*[2]" mode="rtl"/>' +
' </m:mmultiscripts>' +
'</xsl:template>' +
'<xsl:template match="m:msub" mode="rtl" priority="2">' +
' <m:mmultiscripts>' +
' <xsl:apply-templates select="*[1]" mode="rtl"/>' +
' <m:mprescripts/>' +
' <xsl:apply-templates select="*[2]" mode="rtl"/>' +
' <m:none/>' +
' </m:mmultiscripts>' +
'</xsl:template>' +
'<xsl:template match="m:msubsup" mode="rtl" priority="2">' +
' <m:mmultiscripts>' +
' <xsl:apply-templates select="*[1]" mode="rtl"/>' +
' <m:mprescripts/>' +
' <xsl:apply-templates select="*[2]" mode="rtl"/>' +
' <xsl:apply-templates select="*[3]" mode="rtl"/>' +
' </m:mmultiscripts>' +
'</xsl:template>' +
'<xsl:template match="m:mmultiscripts" mode="rtl" priority="2">' +
' <m:mmultiscripts>' +
' <xsl:apply-templates select="*[1]" mode="rtl"/>' +
' <xsl:for-each select="m:mprescripts/following-sibling::*[position() mod 2 = 1]">' +
' <xsl:sort data-type="number" order="descending" select="position()"/>' +
' <xsl:apply-templates select="." mode="rtl"/>' +
' <xsl:apply-templates select="following-sibling::*[1]" mode="rtl"/>' +
' </xsl:for-each>' +
' <m:mprescripts/>' +
' <xsl:for-each select="m:mprescripts/preceding-sibling::*[position()!=last()][position() mod 2 = 0]">' +
' <xsl:sort data-type="number" order="descending" select="position()"/>' +
' <xsl:apply-templates select="." mode="rtl"/>' +
' <xsl:apply-templates select="following-sibling::*[1]" mode="rtl"/>' +
' </xsl:for-each>' +
' </m:mmultiscripts>' +
'</xsl:template>' +
'<xsl:template match="m:mmultiscripts[not(m:mprescripts)]" mode="rtl" priority="3">' +
' <m:mmultiscripts>' +
' <xsl:apply-templates select="*[1]" mode="rtl"/>' +
' <m:mprescripts/>' +
' <xsl:for-each select="*[position() mod 2 = 0]">' +
' <xsl:sort data-type="number" order="descending" select="position()"/>' +
' <xsl:apply-templates select="." mode="rtl"/>' +
' <xsl:apply-templates select="following-sibling::*[1]" mode="rtl"/>' +
' </xsl:for-each>' +
' </m:mmultiscripts>' +
'</xsl:template>' +
'<xsl:template match="text()[.=\'(\']" mode="rtl">)</xsl:template>' +
'<xsl:template match="text()[.=\')\']" mode="rtl">(</xsl:template>' +
'<xsl:template match="text()[.=\'{\']" mode="rtl">}</xsl:template>' +
'<xsl:template match="text()[.=\'}\']" mode="rtl">{</xsl:template>' +
'<xsl:template match="text()[.=\'&lt;\']" mode="rtl">&gt;</xsl:template>' +
'<xsl:template match="text()[.=\'&gt;\']" mode="rtl">&lt;</xsl:template>' +
'<xsl:template match="text()[.=\'&#x2208;\']" mode="rtl">&#x220b;</xsl:template>' +
'<xsl:template match="text()[.=\'&#x220b;\']" mode="rtl">&#x2208;</xsl:template>' +
'<xsl:template match="@notation[.=\'radical\']" mode="rtl">' +
' <xsl:attribute name="notation">top right</xsl:attribute>' +
'</xsl:template>' +
'<xsl:template match="m:mlongdiv|m:mstack" mode="rtl">' +
' <m:mrow dir="ltr">' +
' <xsl:apply-templates select="."/>' +
' </m:mrow>' +
'</xsl:template>' +
'<xsl:template match="m:mstack" priority="11">' +
' <xsl:variable name="m">' +
' <m:mtable columnspacing="0em">' +
' <xsl:copy-of select="@align"/>' +
' <xsl:variable name="t">' +
' <xsl:apply-templates select="*" mode="mstack1">' +
' <xsl:with-param name="p" select="0"/>' +
' </xsl:apply-templates>' +
' </xsl:variable>' +
' <xsl:variable name="maxl">' +
' <xsl:for-each select="c:node-set($t)/*/@l">' +
' <xsl:sort data-type="number" order="descending"/>' +
' <xsl:if test="position()=1">' +
' <xsl:value-of select="."/>' +
' </xsl:if>' +
' </xsl:for-each>' +
' </xsl:variable>' +
' <xsl:for-each select="c:node-set($t)/*[not(@class=\'mscarries\') or following-sibling::*[1]/@class=\'mscarries\']">' +
'<xsl:variable name="c" select="preceding-sibling::*[1][@class=\'mscarries\']"/>' +
' <xsl:text>&#10;</xsl:text>' +
' <m:mtr>' +
' <xsl:copy-of select="@class[.=\'msline\']"/>' +
' <xsl:variable name="offset" select="$maxl - @l"/>' +
' <xsl:choose>' +
' <xsl:when test="@class=\'msline\' and @l=\'*\'">' +
' <xsl:variable name="msl" select="*[1]"/>' +
' <xsl:for-each select="(//node())[position()&lt;=$maxl]">' +
' <xsl:copy-of select="$msl"/>' +
' </xsl:for-each>' +
' </xsl:when>' +
' <xsl:when test="$c">' +
' <xsl:variable name="ldiff" select="$c/@l - @l"/>' +
' <xsl:variable name="loffset" select="$maxl - $c/@l"/>' +
' <xsl:for-each select="(//*)[position()&lt;= $offset]">' +
' <xsl:variable name="pn" select="position()"/>' +
' <xsl:variable name="cy" select="$c/*[position()=$pn - $loffset]"/>' +
' <m:mtd>' +
' <xsl:if test="$cy/*">' +
' <m:mover><m:mphantom><m:mn>0</m:mn></m:mphantom><m:mpadded width="0em" lspace="-0.5width">' +
' <xsl:copy-of select="$cy/*"/></m:mpadded></m:mover>' +
' </xsl:if>' +
' </m:mtd>' +
' </xsl:for-each>' +
' <xsl:for-each select="*">' +
' <xsl:variable name="pn" select="position()"/>' +
' <xsl:variable name="cy" select="$c/*[position()=$pn + $ldiff]"/>' +
' <xsl:copy>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:variable name="b">' +
' <xsl:choose>' +
' <xsl:when test="not(string($cy/@crossout) or $cy/@crossout=\'none\')"><xsl:copy-of select="*"/></xsl:when>' +
' <xsl:otherwise>' +
' <m:menclose notation="{$cy/@crossout}"><xsl:copy-of select="*"/></m:menclose>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <xsl:choose>' +
' <xsl:when test="$cy/m:none or not($cy/*)"><xsl:copy-of select="$b"/></xsl:when>' +
' <xsl:when test="not(string($cy/@location)) or $cy/@location=\'n\'">' +
' <m:mover>' +
' <xsl:copy-of select="$b"/><m:mpadded width="0em" lspace="-0.5width">' +
' <xsl:copy-of select="$cy/*"/>' +
' </m:mpadded>' +
' </m:mover>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'nw\'">' +
' <m:mmultiscripts><xsl:copy-of select="$b"/><m:mprescripts/><m:none/><m:mpadded lspace="-1width" width="0em"><xsl:copy-of select="$cy/*"/></m:mpadded></m:mmultiscripts>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'s\'">' +
' <m:munder><xsl:copy-of select="$b"/><m:mpadded width="0em" lspace="-0.5width"><xsl:copy-of select="$cy/*"/></m:mpadded></m:munder>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'sw\'">' +
' <m:mmultiscripts><xsl:copy-of select="$b"/><m:mprescripts/><m:mpadded lspace="-1width" width="0em"><xsl:copy-of select="$cy/*"/></m:mpadded><m:none/></m:mmultiscripts>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'ne\'">' +
' <m:msup><xsl:copy-of select="$b"/><m:mpadded width="0em"><xsl:copy-of select="$cy/*"/></m:mpadded></m:msup>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'se\'">' +
' <m:msub><xsl:copy-of select="$b"/><m:mpadded width="0em"><xsl:copy-of select="$cy/*"/></m:mpadded></m:msub>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'w\'">' +
' <m:msup><m:mrow/><m:mpadded lspace="-1width" width="0em"><xsl:copy-of select="$cy/*"/></m:mpadded></m:msup>' +
' <xsl:copy-of select="$b"/>' +
' </xsl:when>' +
' <xsl:when test="$cy/@location=\'e\'">' +
' <xsl:copy-of select="$b"/>' +
' <m:msup><m:mrow/><m:mpadded width="0em"><xsl:copy-of select="$cy/*"/></m:mpadded></m:msup>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:copy-of select="$b"/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:copy>' +
' </xsl:for-each>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:for-each select="(//*)[position()&lt;= $offset]"><m:mtd/></xsl:for-each>' +
' <xsl:copy-of select="*"/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </m:mtr>' +
' </xsl:for-each>' +
' </m:mtable>' +
'</xsl:variable>' +
'<xsl:apply-templates mode="ml" select="c:node-set($m)"/>' +
'</xsl:template>' +
'<xsl:template match="*" mode="ml">' +
' <xsl:copy>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:apply-templates mode="ml"/>' +
' </xsl:copy>' +
'</xsl:template>' +
'<xsl:template mode="ml" match="m:mtr[following-sibling::*[1][@class=\'msline\']]">' +
' <m:mtr>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:variable name="m" select="following-sibling::*[1]/m:mtd"/>' +
' <xsl:for-each select="m:mtd">' +
' <xsl:variable name="p" select="position()"/>' +
' <m:mtd>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:choose>' +
' <xsl:when test="$m[$p]/m:mpadded">' +
' <m:menclose notation="bottom">' +
' <m:mpadded depth=".1em" height="1em" width=".4em">' +
' <xsl:copy-of select="*"/>' +
' </m:mpadded>' +
' </m:menclose>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:copy-of select="*"/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </m:mtd>' +
' </xsl:for-each>' +
' </m:mtr>' +
'</xsl:template><xsl:template mode="ml" match="m:mtr[not(preceding-sibling::*)][@class=\'msline\']" priority="3">' +
' <m:mtr>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:for-each select="m:mtd">' +
' <m:mtd>' +
' <xsl:copy-of select="@*"/>' +
' <xsl:if test="m:mpadded">' +
' <m:menclose notation="bottom">' +
' <m:mpadded depth=".1em" height="1em" width=".4em">' +
' <m:mspace width=".2em"/>' +
' </m:mpadded>' +
' </m:menclose>' +
' </xsl:if>' +
' </m:mtd>' +
' </xsl:for-each>' +
' </m:mtr>' +
'</xsl:template><xsl:template mode="ml" match="m:mtr[@class=\'msline\']" priority="2"/>' +
'<xsl:template mode="mstack1" match="*">' +
' <xsl:param name="p"/>' +
' <xsl:param name="maxl" select="0"/>' +
' <m:mtr l="{1 + $p}">' +
' <xsl:if test="ancestor::mstack[1]/@stackalign=\'left\'">' +
' <xsl:attribute name="l"><xsl:value-of select="$p"/></xsl:attribute>' +
' </xsl:if>' +
' <m:mtd><xsl:apply-templates select="."/></m:mtd>' +
' </m:mtr>' +
'</xsl:template>' +
'<xsl:template mode="mstack1" match="m:msrow">' +
' <xsl:param name="p"/>' +
' <xsl:param name="maxl" select="0"/>' +
' <xsl:variable name="align1" select="ancestor::m:mstack[1]/@stackalign"/>' +
' <xsl:variable name="align">' +
' <xsl:choose>' +
' <xsl:when test="string($align1)=\'\'">decimalpoint</xsl:when>' +
' <xsl:otherwise><xsl:value-of select="$align1"/></xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <xsl:variable name="row">' +
' <xsl:apply-templates mode="mstack1" select="*">' +
' <xsl:with-param name="p" select="0"/>' +
' </xsl:apply-templates>' +
' </xsl:variable>' +
' <xsl:text>&#10;</xsl:text>' +
' <xsl:variable name="l1">' +
' <xsl:choose>' +
' <xsl:when test="$align=\'decimalpoint\' and m:mn">' +
' <xsl:for-each select="c:node-set($row)/m:mtr[m:mtd/m:mn][1]">' +
' <xsl:value-of select="number(sum(@l))+count(preceding-sibling::*/@l)"/>' +
' </xsl:for-each>' +
' </xsl:when>' +
' <xsl:when test="$align=\'right\' or $align=\'decimalpoint\'">' +
' <xsl:value-of select="count(c:node-set($row)/m:mtr/m:mtd)"/>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:value-of select="0"/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <m:mtr class="msrow" l="{number($l1) + number(sum(@position)) +$p}">' +
' <xsl:copy-of select="c:node-set($row)/m:mtr/*"/>' +
' </m:mtr>' +
'</xsl:template><xsl:template mode="mstack1" match="m:mn">' +
' <xsl:param name="p"/>' +
' <xsl:variable name="align1" select="ancestor::m:mstack[1]/@stackalign"/>' +
' <xsl:variable name="dp1" select="ancestor::*[@decimalpoint][1]/@decimalpoint"/>' +
' <xsl:variable name="align">' +
' <xsl:choose>' +
' <xsl:when test="string($align1)=\'\'">decimalpoint</xsl:when>' +
' <xsl:otherwise><xsl:value-of select="$align1"/></xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <xsl:variable name="dp">' +
' <xsl:choose>' +
' <xsl:when test="string($dp1)=\'\'">.</xsl:when>' +
' <xsl:otherwise><xsl:value-of select="$dp1"/></xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <m:mtr l="$p">' +
' <xsl:variable name="mn" select="normalize-space(.)"/>' +
' <xsl:variable name="len" select="string-length($mn)"/>' +
' <xsl:choose>' +
' <xsl:when test="$align=\'right\' or ($align=\'decimalpoint\' and not(contains($mn,$dp)))">' +
' <xsl:attribute name="l"><xsl:value-of select="$p + $len"/></xsl:attribute>' +
' </xsl:when>' +
' <xsl:when test="$align=\'center\'">' +
' <xsl:attribute name="l"><xsl:value-of select="round(($p + $len) div 2)"/></xsl:attribute>' +
' </xsl:when>' +
' <xsl:when test="$align=\'decimalpoint\'">' +
' <xsl:attribute name="l"><xsl:value-of select="$p + string-length(substring-before($mn,$dp))"/></xsl:attribute>' +
' </xsl:when>' +
' </xsl:choose> <xsl:for-each select="(//node())[position() &lt;=$len]">' +
' <xsl:variable name="pos" select="position()"/>' +
' <m:mtd><m:mn><xsl:value-of select="substring($mn,$pos,1)"/></m:mn></m:mtd>' +
' </xsl:for-each>' +
' </m:mtr>' +
'</xsl:template>' +
'<xsl:template match="m:msgroup" mode="mstack1">' +
' <xsl:param name="p"/>' +
' <xsl:variable name="s" select="number(sum(@shift))"/>' +
' <xsl:variable name="thisp" select="number(sum(@position))"/>' +
' <xsl:for-each select="*">' +
' <xsl:apply-templates mode="mstack1" select=".">' +
' <xsl:with-param name="p" select="number($p)+$thisp+(position()-1)*$s"/>' +
' </xsl:apply-templates>' +
' </xsl:for-each>' +
'</xsl:template>' +
'<xsl:template match="m:msline" mode="mstack1">' +
' <xsl:param name="p"/>' +
' <xsl:variable name="align1" select="ancestor::m:mstack[1]/@stackalign"/>' +
' <xsl:variable name="align">' +
' <xsl:choose>' +
' <xsl:when test="string($align1)=\'\'">decimalpoint</xsl:when>' +
' <xsl:otherwise><xsl:value-of select="$align1"/></xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <m:mtr class="msline">' +
' <xsl:attribute name="l">' +
' <xsl:choose>' +
' <xsl:when test="not(string(@length)) or @length=0">*</xsl:when>' +
' <xsl:when test="string($align)=\'right\' or string($align)=\'decimalpoint\' "><xsl:value-of select="$p+ @length"/></xsl:when>' +
' <xsl:otherwise><xsl:value-of select="$p"/></xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:attribute>' +
' <xsl:variable name="w">' +
' <xsl:choose>' +
' <xsl:when test="@mslinethickness=\'thin\'">0.1em</xsl:when>' +
' <xsl:when test="@mslinethickness=\'medium\'">0.15em</xsl:when>' +
' <xsl:when test="@mslinethickness=\'thick\'">0.2em</xsl:when>' +
' <xsl:when test="@mslinethickness"><xsl:value-of select="@mslinethickness"/></xsl:when>' +
' <xsl:otherwise>0.15em</xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <xsl:choose>' +
' <xsl:when test="not(string(@length)) or @length=0">' +
' <m:mtd class="mslinemax">' +
' <m:mpadded lspace="-0.2em" width="0em" height="0em">' +
' <m:mfrac linethickness="{$w}">' +
' <m:mspace width=".4em"/>' +
' <m:mrow/>' +
' </m:mfrac>' +
' </m:mpadded>' +
' </m:mtd>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:variable name="l" select="@length"/>' +
' <xsl:for-each select="(//node())[position()&lt;=$l]">' +
' <m:mtd class="msline">' +
' <m:mpadded lspace="-0.2em" width="0em" height="0em">' +
' <m:mfrac linethickness="{$w}">' +
' <m:mspace width=".4em"/>' +
' <m:mrow/>' +
' </m:mfrac>' +
' </m:mpadded>' +
' </m:mtd>' +
' </xsl:for-each>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </m:mtr>' +
'</xsl:template>' +
'<xsl:template match="m:mscarries" mode="mstack1">' +
' <xsl:param name="p"/>' +
' <xsl:variable name="align1" select="ancestor::m:mstack[1]/@stackalign"/>' +
' <xsl:variable name="l1">' +
' <xsl:choose>' +
' <xsl:when test="string($align1)=\'left\'">0</xsl:when>' +
' <xsl:otherwise><xsl:value-of select="count(*)"/></xsl:otherwise>' +
' </xsl:choose>' +
' </xsl:variable>' +
' <m:mtr class="mscarries" l="{$p + $l1 + sum(@position)}">' +
' <xsl:apply-templates select="*" mode="msc"/>' +
' </m:mtr>' +
'</xsl:template><xsl:template match="*" mode="msc">' +
' <m:mtd>' +
' <xsl:copy-of select="../@location|../@crossout"/>' +
' <xsl:choose>' +
' <xsl:when test="../@scriptsizemultiplier">' +
' <m:mstyle mathsize="{round(../@scriptsizemultiplier div .007)}%">' +
' <xsl:apply-templates select="."/>' +
' </m:mstyle>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:apply-templates select="."/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </m:mtd>' +
'</xsl:template><xsl:template match="m:mscarry" mode="msc">' +
' <m:mtd>' +
' <xsl:copy-of select="@location|@crossout"/>' +
' <xsl:choose>' +
' <xsl:when test="../@scriptsizemultiplier">' +
' <m:mstyle mathsize="{round(../@scriptsizemultiplier div .007)}%">' +
' <xsl:apply-templates/>' +
' </m:mstyle>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:apply-templates/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' </m:mtd>' +
'</xsl:template>' +
'<xsl:template match="m:mlongdiv" priority="11">' +
' <xsl:variable name="ms">' +
' <m:mstack>' +
' <xsl:copy-of select="(ancestor-or-self::*/@decimalpoint)[last()]"/>' +
' <xsl:choose>' +
' <xsl:when test="@longdivstyle=\'left)(right\'">' +
' <m:msrow>' +
' <m:mrow><xsl:copy-of select="*[1]"/></m:mrow>' +
' <m:mo>)</m:mo>' +
' <xsl:copy-of select="*[3]"/>' +
' <m:mo>(</m:mo>' +
' <xsl:copy-of select="*[2]"/>' +
' </m:msrow>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'left/\right\'">' +
' <m:msrow>' +
' <m:mrow><xsl:copy-of select="*[1]"/></m:mrow>' +
' <m:mo>/</m:mo>' +
' <xsl:copy-of select="*[3]"/>' +
' <m:mo>\</m:mo>' +
' <xsl:copy-of select="*[2]"/>' +
' </m:msrow>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\':right=right\'">' +
' <m:msrow>' +
' <xsl:copy-of select="*[3]"/>' +
' <m:mo>:</m:mo>' +
' <xsl:copy-of select="*[1]"/>' +
' <m:mo>=</m:mo>' +
' <xsl:copy-of select="*[2]"/>' +
' </m:msrow>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'stackedrightright\'' +
' or @longdivstyle=\'mediumstackedrightright\'' +
' or @longdivstyle=\'shortstackedrightright\'' +
' or @longdivstyle=\'stackedleftleft\'' +
' ">' +
' <xsl:attribute name="align">top</xsl:attribute>' +
' <xsl:copy-of select="*[3]"/>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'stackedleftlinetop\'">' +
' <xsl:copy-of select="*[2]"/>' +
' <m:msline length="{string-length(*[3])-1}"/>' +
' <m:msrow>' +
' <m:mrow>' +
' <m:menclose notation="bottom right">' +
' <xsl:copy-of select="*[1]"/>' +
' </m:menclose>' +
' </m:mrow>' +
' <xsl:copy-of select="*[3]"/>' +
' </m:msrow>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'righttop\'">' +
' <xsl:copy-of select="*[2]"/>' +
' <m:msline length="{string-length(*[3])}"/>' +
' <m:msrow>' +
' <xsl:copy-of select="*[3]"/>' +
' <m:menclose notation="top left bottom">' +
' <xsl:copy-of select="*[1]"/></m:menclose>' +
' </m:msrow>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:copy-of select="*[2]"/>' +
' <m:msline length="{string-length(*[3])}"/>' +
' <m:msrow>' +
' <m:mrow><xsl:copy-of select="*[1]"/></m:mrow>' +
' <m:mo>)</m:mo>' +
' <xsl:copy-of select="*[3]"/>' +
' </m:msrow>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
' <xsl:copy-of select="*[position()&gt;3]"/>' +
' </m:mstack>' +
' </xsl:variable>' +
' <xsl:choose>' +
' <xsl:when test="@longdivstyle=\'stackedrightright\'">' +
' <m:menclose notation="right">' +
' <xsl:apply-templates select="c:node-set($ms)"/>' +
' </m:menclose>' +
' <m:mtable align="top">' +
' <m:mtr>' +
' <m:menclose notation="bottom">' +
' <xsl:copy-of select="*[1]"/>' +
' </m:menclose>' +
' </m:mtr>' +
' <m:mtr>' +
' <mtd><xsl:copy-of select="*[2]"/></mtd>' +
' </m:mtr>' +
' </m:mtable>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'mediumstackedrightright\'">' +
' <xsl:apply-templates select="c:node-set($ms)"/>' +
' <m:menclose notation="left">' +
' <m:mtable align="top">' +
' <m:mtr>' +
' <m:menclose notation="bottom">' +
' <xsl:copy-of select="*[1]"/>' +
' </m:menclose>' +
' </m:mtr>' +
' <m:mtr>' +
' <mtd><xsl:copy-of select="*[2]"/></mtd>' +
' </m:mtr>' +
' </m:mtable>' +
' </m:menclose>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'shortstackedrightright\'">' +
' <xsl:apply-templates select="c:node-set($ms)"/>' +
' <m:mtable align="top">' +
' <m:mtr>' +
' <m:menclose notation="left bottom">' +
' <xsl:copy-of select="*[1]"/>' +
' </m:menclose>' +
' </m:mtr>' +
' <m:mtr>' +
' <mtd><xsl:copy-of select="*[2]"/></mtd>' +
' </m:mtr>' +
' </m:mtable>' +
' </xsl:when>' +
' <xsl:when test="@longdivstyle=\'stackedleftleft\'">' +
' <m:mtable align="top">' +
' <m:mtr>' +
' <m:menclose notation="bottom">' +
' <xsl:copy-of select="*[1]"/>' +
' </m:menclose>' +
' </m:mtr>' +
' <m:mtr>' +
' <mtd><xsl:copy-of select="*[2]"/></mtd>' +
' </m:mtr>' +
' </m:mtable>' +
' <m:menclose notation="left">' +
' <xsl:apply-templates select="c:node-set($ms)"/>' +
' </m:menclose>' +
' </xsl:when>' +
' <xsl:otherwise>' +
' <xsl:apply-templates select="c:node-set($ms)"/>' +
' </xsl:otherwise>' +
' </xsl:choose>' +
'</xsl:template>' +
'<xsl:template match="m:menclose[@notation=\'madruwb\']" mode="rtl">' +
' <m:menclose notation="bottom right">' +
' <xsl:apply-templates mode="rtl"/>' +
' </m:menclose>' +
'</xsl:template></xsl:stylesheet>';
/*
* End of mml3mj.xsl material.
*/
var mml3;
if (window.XSLTProcessor) {
// standard method: just use an XSLTProcessor and parse the stylesheet
if (!MATHML.ParseXML) {MATHML.ParseXML = MATHML.createParser()}
MATHML.mml3XSLT = new XSLTProcessor();
MATHML.mml3XSLT.importStylesheet(MATHML.ParseXML(mml3Stylesheet));
} else if (MathJax.Hub.Browser.isMSIE) {
// nonstandard methods for Internet Explorer
if (MathJax.Hub.Browser.versionAtLeast("9.0") || (document.documentMode||0) >= 9) {
// For Internet Explorer >= 9, use createProcessor
mml3 = new ActiveXObject("Msxml2.FreeThreadedDOMDocument");
mml3.loadXML(mml3Stylesheet);
var xslt = new ActiveXObject("Msxml2.XSLTemplate");
xslt.stylesheet = mml3;
MATHML.mml3XSLT = {
mml3: xslt.createProcessor(),
transformToDocument: function(doc) {
this.mml3.input = doc;
this.mml3.transform();
return this.mml3.output;
}
}
} else {
// For Internet Explorer <= 8, use transformNode
mml3 = MATHML.createMSParser();
mml3.async = false;
mml3.loadXML(mml3Stylesheet);
MATHML.mml3XSLT = {
mml3: mml3,
transformToDocument: function(doc) {
return doc.documentElement.transformNode(this.mml3);
}
}
}
} else {
// No XSLT support. Do not change the <math> content.
MATHML.mml3XSLT = null;
}
// Tweak CSS to avoid some browsers rearranging HTML output
MathJax.Ajax.Styles({
".MathJax .mi, .MathJax .mo, .MathJax .mn, .MathJax .mtext": {
direction: "ltr",
display: "inline-block"
},
".MathJax .ms, .MathJax .mspace, .MathJax .mglyph": {
direction: "ltr",
display: "inline-block"
}
});
MathJax.Hub.Startup.signal.Post("MathML mml3.js Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/MathML/mml3.js");

1664
web/assets/MathJax/unpacked/extensions/MathMenu.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

366
web/assets/MathJax/unpacked/extensions/MathZoom.js vendored Normal file
View File

@@ -0,0 +1,366 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/MathZoom.js
*
* Implements the zoom feature for enlarging math expressions. It is
* loaded automatically when the Zoom menu selection changes from "None".
*
* ---------------------------------------------------------------------
*
* 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 (HUB,HTML,AJAX,HTMLCSS,nMML) {
var VERSION = "2.7.8";
var CONFIG = HUB.CombineConfig("MathZoom",{
styles: {
//
// The styles for the MathZoom display box
//
"#MathJax_Zoom": {
position:"absolute", "background-color":"#F0F0F0", overflow:"auto",
display:"block", "z-index":301, padding:".5em", border:"1px solid black", margin:0,
"font-weight":"normal", "font-style":"normal",
"text-align":"left", "text-indent":0, "text-transform":"none",
"line-height":"normal", "letter-spacing":"normal", "word-spacing":"normal",
"word-wrap":"normal", "white-space":"nowrap", "float":"none",
"-webkit-box-sizing":"content-box", // Android ≤ 2.3, iOS ≤ 4
"-moz-box-sizing":"content-box", // Firefox ≤ 28
"box-sizing":"content-box", // Chrome, Firefox 29+, IE 8+, Opera, Safari 5.1
"box-shadow":"5px 5px 15px #AAAAAA", // Opera 10.5 and IE9
"-webkit-box-shadow":"5px 5px 15px #AAAAAA", // Safari 3 and Chrome
"-moz-box-shadow":"5px 5px 15px #AAAAAA", // Forefox 3.5
"-khtml-box-shadow":"5px 5px 15px #AAAAAA", // Konqueror
filter: "progid:DXImageTransform.Microsoft.dropshadow(OffX=2, OffY=2, Color='gray', Positive='true')" // IE
},
//
// The styles for the hidden overlay (should not need to be adjusted by the page author)
//
"#MathJax_ZoomOverlay": {
position:"absolute", left:0, top:0, "z-index":300, display:"inline-block",
width:"100%", height:"100%", border:0, padding:0, margin:0,
"background-color":"white", opacity:0, filter:"alpha(opacity=0)"
},
"#MathJax_ZoomFrame": {
position:"relative", display:"inline-block",
height:0, width:0
},
"#MathJax_ZoomEventTrap": {
position:"absolute", left:0, top:0, "z-index":302,
display:"inline-block", border:0, padding:0, margin:0,
"background-color":"white", opacity:0, filter:"alpha(opacity=0)"
}
}
});
var FALSE, HOVER, EVENT;
MathJax.Hub.Register.StartupHook("MathEvents Ready",function () {
EVENT = MathJax.Extension.MathEvents.Event;
FALSE = MathJax.Extension.MathEvents.Event.False;
HOVER = MathJax.Extension.MathEvents.Hover;
});
/*************************************************************/
var ZOOM = MathJax.Extension.MathZoom = {
version: VERSION,
settings: HUB.config.menuSettings,
scrollSize: 18, // width of scrool bars
//
// Process events passed from output jax
//
HandleEvent: function (event,type,math) {
if (ZOOM.settings.CTRL && !event.ctrlKey) return true;
if (ZOOM.settings.ALT && !event.altKey) return true;
if (ZOOM.settings.CMD && !event.metaKey) return true;
if (ZOOM.settings.Shift && !event.shiftKey) return true;
if (!ZOOM[type]) return true;
return ZOOM[type](event,math);
},
//
// Zoom on click
//
Click: function (event,math) {
if (this.settings.zoom === "Click") {return this.Zoom(event,math)}
},
//
// Zoom on double click
//
DblClick: function (event,math) {
if (this.settings.zoom === "Double-Click" || this.settings.zoom === "DoubleClick") {return this.Zoom(event,math)}
},
//
// Zoom on hover (called by MathEvents.Hover)
//
Hover: function (event,math) {
if (this.settings.zoom === "Hover") {this.Zoom(event,math); return true}
return false;
},
//
// Handle the actual zooming
//
Zoom: function (event,math) {
//
// Remove any other zoom and clear timers
//
this.Remove(); HOVER.ClearHoverTimer(); EVENT.ClearSelection();
//
// Find the jax
//
var JAX = MathJax.OutputJax[math.jaxID];
var jax = JAX.getJaxFromMath(math);
if (jax.hover) {HOVER.UnHover(jax)}
//
// Create the DOM elements for the zoom box
//
var container = this.findContainer(math);
var Mw = Math.floor(.85*container.clientWidth),
Mh = Math.max(document.body.clientHeight,document.documentElement.clientHeight);
if (this.getOverflow(container) !== "visible") {Mh = Math.min(container.clientHeight,Mh)}
Mh = Math.floor(.85*Mh);
var div = HTML.Element(
"span",{id:"MathJax_ZoomFrame"},[
["span",{id:"MathJax_ZoomOverlay", onmousedown:this.Remove}],
["span",{
id:"MathJax_Zoom", onclick:this.Remove,
style:{visibility:"hidden", fontSize:this.settings.zscale}
},[["span",{style:{display:"inline-block", "white-space":"nowrap"}}]]
]]
);
var zoom = div.lastChild, span = zoom.firstChild, overlay = div.firstChild;
math.parentNode.insertBefore(div,math); math.parentNode.insertBefore(math,div); // put div after math
if (span.addEventListener) {span.addEventListener("mousedown",this.Remove,true)}
var eW = zoom.offsetWidth || zoom.clientWidth; Mw -= eW; Mh -= eW;
zoom.style.maxWidth = Mw+"px"; zoom.style.maxHeight = Mh+"px";
if (this.msieTrapEventBug) {
var trap = HTML.Element("span",{id:"MathJax_ZoomEventTrap", onmousedown:this.Remove});
div.insertBefore(trap,zoom);
}
//
// Display the zoomed math
//
if (this.msieZIndexBug) {
// MSIE doesn't do z-index properly, so move the div to the document.body,
// and use an image as a tracker for the usual position
var tracker = HTML.addElement(document.body,"img",{
src:"about:blank", id:"MathJax_ZoomTracker", width:0, height:0,
style:{width:0, height:0, position:"relative"}
});
div.style.position = "relative";
div.style.zIndex = CONFIG.styles["#MathJax_ZoomOverlay"]["z-index"];
div = tracker;
}
var bbox = JAX.Zoom(jax,span,math,Mw,Mh);
//
// Fix up size and position for browsers with bugs (IE)
//
if (this.msiePositionBug) {
if (this.msieSizeBug)
{zoom.style.height = bbox.zH+"px"; zoom.style.width = bbox.zW+"px"} // IE8 gets the dimensions completely wrong
if (zoom.offsetHeight > Mh) {zoom.style.height = Mh+"px"; zoom.style.width = (bbox.zW+this.scrollSize)+"px"} // IE doesn't do max-height?
if (zoom.offsetWidth > Mw) {zoom.style.width = Mw+"px"; zoom.style.height = (bbox.zH+this.scrollSize)+"px"}
}
if (this.operaPositionBug) {zoom.style.width = Math.min(Mw,bbox.zW)+"px"} // Opera gets width as 0?
if (zoom.offsetWidth > eW && zoom.offsetWidth-eW < Mw && zoom.offsetHeight-eW < Mh)
{zoom.style.overflow = "visible"} // don't show scroll bars if we don't need to
this.Position(zoom,bbox);
if (this.msieTrapEventBug) {
trap.style.height = zoom.clientHeight+"px"; trap.style.width = zoom.clientWidth+"px";
trap.style.left = (parseFloat(zoom.style.left)+zoom.clientLeft)+"px";
trap.style.top = (parseFloat(zoom.style.top)+zoom.clientTop)+"px";
}
zoom.style.visibility = "";
//
// Add event handlers
//
if (this.settings.zoom === "Hover") {overlay.onmouseover = this.Remove}
if (window.addEventListener) {addEventListener("resize",this.Resize,false)}
else if (window.attachEvent) {attachEvent("onresize",this.Resize)}
else {this.onresize = window.onresize; window.onresize = this.Resize}
//
// Let others know about the zoomed math
//
HUB.signal.Post(["math zoomed",jax]);
//
// Canel further actions
//
return FALSE(event);
},
//
// Set the position of the zoom box and overlay
//
Position: function (zoom,bbox) {
zoom.style.display = "none"; // avoids getting excessive width in Resize()
var XY = this.Resize(), x = XY.x, y = XY.y, W = bbox.mW;
zoom.style.display = "";
var dx = -W-Math.floor((zoom.offsetWidth-W)/2), dy = bbox.Y;
zoom.style.left = Math.max(dx,10-x)+"px"; zoom.style.top = Math.max(dy,10-y)+"px";
if (!ZOOM.msiePositionBug) {ZOOM.SetWH()} // refigure overlay width/height
},
//
// Handle resizing of overlay while zoom is displayed
//
Resize: function (event) {
if (ZOOM.onresize) {ZOOM.onresize(event)}
var div = document.getElementById("MathJax_ZoomFrame"),
overlay = document.getElementById("MathJax_ZoomOverlay");
var xy = ZOOM.getXY(div), obj = ZOOM.findContainer(div);
if (ZOOM.getOverflow(obj) !== "visible") {
overlay.scroll_parent = obj; // Save this for future reference.
var XY = ZOOM.getXY(obj); // Remove container position
xy.x -= XY.x; xy.y -= XY.y;
XY = ZOOM.getBorder(obj); // Remove container border
xy.x -= XY.x; xy.y -= XY.y;
}
overlay.style.left = (-xy.x)+"px"; overlay.style.top = (-xy.y)+"px";
if (ZOOM.msiePositionBug) {setTimeout(ZOOM.SetWH,0)} else {ZOOM.SetWH()}
return xy;
},
SetWH: function () {
var overlay = document.getElementById("MathJax_ZoomOverlay");
if (!overlay) return;
overlay.style.display = "none"; // so scrollWidth/Height will be right below
var doc = overlay.scroll_parent || document.documentElement || document.body;
overlay.style.width = doc.scrollWidth + "px";
overlay.style.height = Math.max(doc.clientHeight,doc.scrollHeight) + "px";
overlay.style.display = "";
},
findContainer: function (obj) {
obj = obj.parentNode;
while (obj.parentNode && obj !== document.body && ZOOM.getOverflow(obj) === "visible")
{obj = obj.parentNode}
return obj;
},
//
// Look up CSS properties (use getComputeStyle if available, or currentStyle if not)
//
getOverflow: (window.getComputedStyle ?
function (obj) {return getComputedStyle(obj).overflow} :
function (obj) {return (obj.currentStyle||{overflow:"visible"}).overflow}),
getBorder: function (obj) {
var size = {thin: 1, medium: 2, thick: 3};
var style = (window.getComputedStyle ? getComputedStyle(obj) :
(obj.currentStyle || {borderLeftWidth:0,borderTopWidth:0}));
var x = style.borderLeftWidth, y = style.borderTopWidth;
if (size[x]) {x = size[x]} else {x = parseInt(x)}
if (size[y]) {y = size[y]} else {y = parseInt(y)}
return {x:x, y:y};
},
//
// Get the position of an element on the page
//
getXY: function (div) {
var x = 0, y = 0, obj;
obj = div; while (obj.offsetParent) {x += obj.offsetLeft; obj = obj.offsetParent}
if (ZOOM.operaPositionBug) {div.style.border = "1px solid"} // to get vertical position right
obj = div; while (obj.offsetParent) {y += obj.offsetTop; obj = obj.offsetParent}
if (ZOOM.operaPositionBug) {div.style.border = ""}
return {x:x, y:y};
},
//
// Remove zoom display and event handlers
//
Remove: function (event) {
var div = document.getElementById("MathJax_ZoomFrame");
if (div) {
var JAX = MathJax.OutputJax[div.previousSibling.jaxID];
var jax = JAX.getJaxFromMath(div.previousSibling);
HUB.signal.Post(["math unzoomed",jax]);
div.parentNode.removeChild(div);
div = document.getElementById("MathJax_ZoomTracker");
if (div) {div.parentNode.removeChild(div)}
if (ZOOM.operaRefreshBug) {
// force a redisplay of the page
// (Opera doesn't refresh properly after the zoom is removed)
var overlay = HTML.addElement(document.body,"div",{
style:{position:"fixed", left:0, top:0, width:"100%", height:"100%",
backgroundColor:"white", opacity:0},
id: "MathJax_OperaDiv"
});
document.body.removeChild(overlay);
}
if (window.removeEventListener) {removeEventListener("resize",ZOOM.Resize,false)}
else if (window.detachEvent) {detachEvent("onresize",ZOOM.Resize)}
else {window.onresize = ZOOM.onresize; delete ZOOM.onresize}
}
return FALSE(event);
}
};
/*************************************************************/
HUB.Browser.Select({
MSIE: function (browser) {
var mode = (document.documentMode || 0);
var isIE9 = (mode >= 9);
ZOOM.msiePositionBug = !isIE9;
ZOOM.msieSizeBug = browser.versionAtLeast("7.0") &&
(!document.documentMode || mode === 7 || mode === 8);
ZOOM.msieZIndexBug = (mode <= 7);
ZOOM.msieInlineBlockAlignBug = (mode <= 7);
ZOOM.msieTrapEventBug = !window.addEventListener;
if (document.compatMode === "BackCompat") {ZOOM.scrollSize = 52} // don't know why this is so far off
if (isIE9) {delete CONFIG.styles["#MathJax_Zoom"].filter}
},
Opera: function (browser) {
ZOOM.operaPositionBug = true;
ZOOM.operaRefreshBug = true;
}
});
ZOOM.topImg = (ZOOM.msieInlineBlockAlignBug ?
HTML.Element("img",{style:{width:0,height:0,position:"relative"},src:"about:blank"}) :
HTML.Element("span",{style:{width:0,height:0,display:"inline-block"}})
);
if (ZOOM.operaPositionBug || ZOOM.msieTopBug) {ZOOM.topImg.style.border="1px solid"}
/*************************************************************/
MathJax.Callback.Queue(
["StartupHook",MathJax.Hub.Register,"Begin Styles",{}],
["Styles",AJAX,CONFIG.styles],
["Post",HUB.Startup.signal,"MathZoom Ready"],
["loadComplete",AJAX,"[MathJax]/extensions/MathZoom.js"]
);
})(MathJax.Hub,MathJax.HTML,MathJax.Ajax,MathJax.OutputJax["HTML-CSS"],MathJax.OutputJax.NativeMML);

428
web/assets/MathJax/unpacked/extensions/Safe.js vendored Normal file
View File

@@ -0,0 +1,428 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/Safe.js
*
* Implements a "Safe" mode that disables features that could be
* misused in a shared environment (such as href's to javascript URL's).
* See the CONFIG variable below for configuration options.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2013-2020 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function (HUB,AJAX) {
var VERSION = "2.7.8";
var CONFIG = MathJax.Hub.CombineConfig("Safe",{
allow: {
//
// Values can be "all", "safe", or "none"
//
URLs: "safe", // safe are in safeProtocols below
classes: "safe", // safe start with MJX-
cssIDs: "safe", // safe start with MJX-
styles: "safe", // safe are in safeStyles below
fontsize: "all", // safe are between sizeMin and sizeMax em's
require: "safe" // safe are in safeRequire below
},
sizeMin: .7, // \scriptsize
sizeMax: 1.44, // \large
lengthMax: 3, // largest padding/border/margin, etc. in em's
safeProtocols: {
http: true,
https: true,
file: true,
javascript: false
},
safeStyles: {
color: true,
backgroundColor: true,
border: true,
cursor: true,
margin: true,
padding: true,
textShadow: true,
fontFamily: true,
fontSize: true,
fontStyle: true,
fontWeight: true,
opacity: true,
outline: true
},
safeRequire: {
action: true,
amscd: true,
amsmath: true,
amssymbols: true,
autobold: false,
"autoload-all": false,
bbox: true,
begingroup: true,
boldsymbol: true,
cancel: true,
color: true,
enclose: true,
extpfeil: true,
HTML: true,
mathchoice: true,
mhchem: true,
newcommand: true,
noErrors: false,
noUndefined: false,
unicode: true,
verb: true
},
//
// CSS styles that have Top/Right/Bottom/Left versions
//
styleParts: {
border: true,
padding: true,
margin: true,
outline: true
},
//
// CSS styles that are lengths needing max/min testing
// A string value means test that style value;
// An array gives [min,max] in em's
// Otherwise use [-lengthMax,lengthMax] from above
//
styleLengths: {
borderTop: "borderTopWidth",
borderRight: "borderRightWidth",
borderBottom: "borderBottomWidth",
borderLeft: "borderLeftWidth",
paddingTop: true,
paddingRight: true,
paddingBottom: true,
paddingLeft: true,
marginTop: true,
marginRight: true,
marginBottom: true,
marginLeft: true,
outlineTop: true,
outlineRight: true,
outlineBottom: true,
outlineLeft: true,
fontSize: [.7,1.44]
}
});
var ALLOW = CONFIG.allow;
if (ALLOW.fontsize !== "all") {CONFIG.safeStyles.fontSize = false}
var SAFE = MathJax.Extension.Safe = {
version: VERSION,
config: CONFIG,
div1: document.createElement("div"), // for CSS processing
div2: document.createElement("div"),
//
// Methods called for MathML attribute processing
//
filter: {
href: "filterURL",
src: "filterURL",
altimg: "filterURL",
"class": "filterClass",
style: "filterStyles",
id: "filterID",
fontsize: "filterFontSize",
mathsize: "filterFontSize",
scriptminsize: "filterFontSize",
scriptsizemultiplier: "filterSizeMultiplier",
scriptlevel: "filterScriptLevel"
},
//
// Filter HREF URL's
//
filterURL: function (url) {
var protocol = (url.match(/^\s*([a-z]+):/i)||[null,""])[1].toLowerCase();
if (ALLOW.URLs === "none" ||
(ALLOW.URLs !== "all" && !CONFIG.safeProtocols[protocol])) {url = null}
return url;
},
//
// Filter class names and css ID's
//
filterClass: function (CLASS) {
if (ALLOW.classes === "none" ||
(ALLOW.classes !== "all" && !CLASS.match(/^MJX-[-a-zA-Z0-9_.]+$/))) {CLASS = null}
return CLASS;
},
filterID: function (id) {
if (ALLOW.cssIDs === "none" ||
(ALLOW.cssIDs !== "all" && !id.match(/^MJX-[-a-zA-Z0-9_.]+$/))) {id = null}
return id;
},
//
// Filter style strings
//
filterStyles: function (styles) {
if (ALLOW.styles === "all") {return styles}
if (ALLOW.styles === "none") {return null}
try {
//
// Set the div1 styles to the given styles, and clear div2
//
var STYLE1 = this.div1.style, STYLE2 = this.div2.style, value;
STYLE1.cssText = styles; STYLE2.cssText = "";
//
// Check each allowed style and transfer OK ones to div2
// If the style has Top/Right/Bottom/Left, look at all four separately
//
for (var name in CONFIG.safeStyles) {if (CONFIG.safeStyles.hasOwnProperty(name)) {
if (CONFIG.styleParts[name]) {
for (var i = 0; i < 4; i++) {
var NAME = name+["Top","Right","Bottom","Left"][i]
value = this.filterStyle(NAME,STYLE1);
if (value) {STYLE2[NAME] = value}
}
} else {
value = this.filterStyle(name,STYLE1);
if (value) {STYLE2[name] = value}
}
}}
//
// Return the div2 style string
//
styles = STYLE2.cssText;
} catch (e) {styles = null}
return styles;
},
//
// Filter an individual name:value style pair
//
filterStyle: function (name,styles) {
var value = styles[name];
if (typeof value !== "string" || value === "") {return null}
if (value.match(/^\s*expression/)) {return null}
if (value.match(/javascript:/)) {return null}
var NAME = name.replace(/Top|Right|Left|Bottom/,"");
if (!CONFIG.safeStyles[name] && !CONFIG.safeStyles[NAME]) {return null}
if (!CONFIG.styleLengths[name]) {return value}
return (this.filterStyleLength(name,value,styles) ? value : null);
},
filterStyleLength: function (name,value,styles) {
if (typeof CONFIG.styleLengths[name] === "string") value = styles[CONFIG.styleLengths[name]];
value = this.length2em(value);
if (value == null) return false;
var mM = [-CONFIG.lengthMax,CONFIG.lengthMax];
if (MathJax.Object.isArray(CONFIG.styleLengths[name])) mM = CONFIG.styleLengths[name];
return (value >= mM[0] && value <= mM[1]);
},
//
// Conversion of units to em's
//
unit2em: {
em: 1,
ex: .5, // assume 1ex = .5em
ch: .5, // assume 1ch = .5em
rem: 1, // assume 1rem = 1em
px: 1/16, // assume 1em = 16px
mm: 96/25.4/16, // 25.4mm = 96px
cm: 96/2.54/16, // 2.54cm = 96px
'in': 96/16, // 1in = 96px
pt: 96/72/16, // 72pt = 1in
pc: 96/6/16 // 1pc = 12pt
},
length2em: function (value) {
var match = value.match(/(.+)(em|ex|ch|rem|px|mm|cm|in|pt|pc)/);
if (!match) return null;
return parseFloat(match[1])*this.unit2em[match[2]];
},
//
// Filter TeX font size values (in em's)
//
filterSize: function (size) {
if (ALLOW.fontsize === "none") {return null}
if (ALLOW.fontsize !== "all")
{size = Math.min(Math.max(size,CONFIG.sizeMin),CONFIG.sizeMax)}
return size;
},
filterFontSize: function (size) {
return (ALLOW.fontsize === "all" ? size: null);
},
//
// Filter scriptsizemultiplier
//
filterSizeMultiplier: function (size) {
if (ALLOW.fontsize === "none") {size = null}
else if (ALLOW.fontsize !== "all") {size = Math.min(1,Math.max(.6,size)).toString()}
return size;
},
//
// Filter scriptLevel
//
filterScriptLevel: function (level) {
if (ALLOW.fontsize === "none") {level = null}
else if (ALLOW.fontsize !== "all") {level = Math.max(0,level).toString()}
return level;
},
//
// Filter TeX extension names
//
filterRequire: function (name) {
if (ALLOW.require === "none" ||
(ALLOW.require !== "all" && !CONFIG.safeRequire[name.toLowerCase()]))
{name = null}
return name;
}
};
HUB.Register.StartupHook("TeX HTML Ready",function () {
var TEX = MathJax.InputJax.TeX;
TEX.Parse.Augment({
//
// Implements \href{url}{math} with URL filter
//
HREF_attribute: function (name) {
var url = SAFE.filterURL(this.GetArgument(name)),
arg = this.GetArgumentMML(name);
if (url) {arg.With({href:url})}
this.Push(arg);
},
//
// Implements \class{name}{math} with class-name filter
//
CLASS_attribute: function (name) {
var CLASS = SAFE.filterClass(this.GetArgument(name)),
arg = this.GetArgumentMML(name);
if (CLASS) {
if (arg["class"] != null) {CLASS = arg["class"] + " " + CLASS}
arg.With({"class":CLASS});
}
this.Push(arg);
},
//
// Implements \style{style-string}{math} with style filter
//
STYLE_attribute: function (name) {
var style = SAFE.filterStyles(this.GetArgument(name)),
arg = this.GetArgumentMML(name);
if (style) {
if (arg.style != null) {
if (style.charAt(style.length-1) !== ";") {style += ";"}
style = arg.style + " " + style;
}
arg.With({style: style});
}
this.Push(arg);
},
//
// Implements \cssId{id}{math} with ID filter
//
ID_attribute: function (name) {
var ID = SAFE.filterID(this.GetArgument(name)),
arg = this.GetArgumentMML(name);
if (ID) {arg.With({id:ID})}
this.Push(arg);
}
});
});
HUB.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
PARSE = TEX.Parse, METHOD = SAFE.filter;
PARSE.Augment({
//
// Implements \require{name} with filtering
//
Require: function (name) {
var file = this.GetArgument(name).replace(/.*\//,"").replace(/[^a-z0-9_.-]/ig,"");
file = SAFE.filterRequire(file);
if (file) {this.Extension(null,file)}
},
//
// Controls \mmlToken attributes
//
MmlFilterAttribute: function (name,value) {
if (METHOD[name]) {value = SAFE[METHOD[name]](value)}
return value;
},
//
// Handles font size macros with filtering
//
SetSize: function (name,size) {
size = SAFE.filterSize(size);
if (size) {
this.stack.env.size = size;
this.Push(TEX.Stack.Item.style().With({styles: {mathsize: size+"em"}}));
}
}
});
});
HUB.Register.StartupHook("TeX bbox Ready",function () {
var TEX = MathJax.InputJax.TeX;
//
// Filter the styles for \bbox
//
TEX.Parse.Augment({
BBoxStyle: function (styles) {return SAFE.filterStyles(styles)},
BBoxPadding: function (pad) {
var styles = SAFE.filterStyles("padding: "+pad);
return (styles ? pad : 0);
}
});
});
HUB.Register.StartupHook("MathML Jax Ready",function () {
var PARSE = MathJax.InputJax.MathML.Parse,
METHOD = SAFE.filter;
//
// Filter MathML attributes
//
PARSE.Augment({
filterAttribute: function (name,value) {
if (METHOD[name]) {value = SAFE[METHOD[name]](value)}
return value;
}
});
});
// MathML input (href, style, fontsize, class, id)
HUB.Startup.signal.Post("Safe Extension Ready");
AJAX.loadComplete("[MathJax]/extensions/Safe.js");
})(MathJax.Hub,MathJax.Ajax);

158
web/assets/MathJax/unpacked/extensions/TeX/AMScd.js vendored Normal file
View File

@@ -0,0 +1,158 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/AMScd.js
*
* Implements the CD environment for commutative diagrams.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/AMScd"] = {
version: "2.7.8",
config: MathJax.Hub.CombineConfig("TeX.CD",{
colspace: "5pt",
rowspace: "5pt",
harrowsize: "2.75em",
varrowsize: "1.75em",
hideHorizontalLabels: false
})
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var MML = MathJax.ElementJax.mml,
TEX = MathJax.InputJax.TeX,
STACKITEM = TEX.Stack.Item,
TEXDEF = TEX.Definitions,
CONFIG = MathJax.Extension["TeX/AMScd"].config;
TEXDEF.environment.CD = "CD_env";
TEXDEF.special["@"] = "CD_arrow";
TEXDEF.macros.minCDarrowwidth = "CD_minwidth";
TEXDEF.macros.minCDarrowheight = "CD_minheight";
TEX.Parse.Augment({
//
// Implements \begin{CD}...\end{CD}
//
CD_env: function (begin) {
this.Push(begin);
return STACKITEM.array().With({
arraydef: {
columnalign: "center",
columnspacing: CONFIG.colspace,
rowspacing: CONFIG.rowspace,
displaystyle: true
},
minw: this.stack.env.CD_minw || CONFIG.harrowsize,
minh: this.stack.env.CD_minh || CONFIG.varrowsize
});
},
CD_arrow: function (name) {
var c = this.string.charAt(this.i);
if (!c.match(/[><VA.|=]/)) {return this.Other(name)} else {this.i++}
var top = this.stack.Top();
if (!top.isa(STACKITEM.array) || top.data.length) {
this.CD_cell(name);
top = this.stack.Top();
}
//
// Add enough cells to place the arrow correctly
//
var arrowRow = ((top.table.length % 2) === 1);
var n = (top.row.length + (arrowRow ? 0 : 1)) % 2;
while (n) {this.CD_cell(name); n--}
var mml;
var hdef = {minsize: top.minw, stretchy:true},
vdef = {minsize: top.minh, stretchy:true, symmetric:true, lspace:0, rspace:0};
if (c === ".") {}
else if (c === "|") {mml = this.mmlToken(MML.mo("\u2225").With(vdef))}
else if (c === "=") {mml = this.mmlToken(MML.mo("=").With(hdef))}
else {
//
// for @>>> @<<< @VVV and @AAA, get the arrow and labels
//
var arrow = {">":"\u2192", "<":"\u2190", V:"\u2193", A:"\u2191"}[c];
var a = this.GetUpTo(name+c,c),
b = this.GetUpTo(name+c,c);
if (c === ">" || c === "<") {
//
// Lay out horizontal arrows with munderover if it has labels
//
mml = MML.mo(arrow).With(hdef);
if (!a) {a = "\\kern "+top.minw} // minsize needs work
if (a || b) {
var pad = {width:"+11mu", lspace:"6mu"};
mml = MML.munderover(this.mmlToken(mml));
if (a) {
a = TEX.Parse(a,this.stack.env).mml();
mml.SetData(mml.over,MML.mpadded(a).With(pad).With({voffset:".1em"}));
}
if (b) {
b = TEX.Parse(b,this.stack.env).mml();
mml.SetData(mml.under,MML.mpadded(b).With(pad));
}
if (CONFIG.hideHorizontalLabels)
{mml = MML.mpadded(mml).With({depth:0, height:".67em"})}
}
} else {
//
// Lay out vertical arrows with mrow if there are labels
//
mml = arrow = this.mmlToken(MML.mo(arrow).With(vdef));
if (a || b) {
mml = MML.mrow();
if (a) {mml.Append(TEX.Parse("\\scriptstyle\\llap{"+a+"}",this.stack.env).mml())}
mml.Append(arrow.With({texClass: MML.TEXCLASS.ORD}));
if (b) {mml.Append(TEX.Parse("\\scriptstyle\\rlap{"+b+"}",this.stack.env).mml())}
}
}
}
if (mml) {this.Push(mml)};
this.CD_cell(name);
},
CD_cell: function (name) {
var top = this.stack.Top();
if ((top.table||[]).length % 2 === 0 && (top.row||[]).length === 0) {
//
// Add a strut to the first cell in even rows to get
// better spacing of arrow rows.
//
this.Push(MML.mpadded().With({height:"8.5pt",depth:"2pt"}));
}
this.Push(STACKITEM.cell().With({isEntry:true, name:name}));
},
CD_minwidth: function (name) {
this.stack.env.CD_minw = this.GetDimen(name);
},
CD_minheight: function (name) {
this.stack.env.CD_minh = this.GetDimen(name);
}
});
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMScd.js");

663
web/assets/MathJax/unpacked/extensions/TeX/AMSmath.js vendored Normal file
View File

@@ -0,0 +1,663 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/AMSmath.js
*
* Implements AMS math environments and macros.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/AMSmath"] = {
version: "2.7.8",
number: 0, // current equation number
startNumber: 0, // current starting equation number (for when equation is restarted)
IDs: {}, // IDs used in previous equations
eqIDs: {}, // IDs used in this equation
labels: {}, // the set of labels
eqlabels: {}, // labels in the current equation
refs: [] // array of jax with unresolved references
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var MML = MathJax.ElementJax.mml,
TEX = MathJax.InputJax.TeX,
AMS = MathJax.Extension["TeX/AMSmath"];
var TEXDEF = TEX.Definitions,
STACKITEM = TEX.Stack.Item,
CONFIG = TEX.config.equationNumbers;
var COLS = function (W) {
var WW = [];
for (var i = 0, m = W.length; i < m; i++)
{WW[i] = TEX.Parse.prototype.Em(W[i])}
return WW.join(" ");
};
//
// Get the URL of the page (for use with formatURL) when there
// is a <base> element on the page.
//
var baseURL = (document.getElementsByTagName("base").length === 0) ? "" :
String(document.location).replace(/#.*$/,"");
/******************************************************************************/
TEXDEF.Add({
mathchar0mo: {
iiiint: ['2A0C',{texClass: MML.TEXCLASS.OP}]
},
macros: {
mathring: ['Accent','2DA'], // or 0x30A
nobreakspace: 'Tilde',
negmedspace: ['Spacer',MML.LENGTH.NEGATIVEMEDIUMMATHSPACE],
negthickspace: ['Spacer',MML.LENGTH.NEGATIVETHICKMATHSPACE],
// intI: ['Macro','\\mathchoice{\\!}{}{}{}\\!\\!\\int'],
// iint: ['MultiIntegral','\\int\\intI'], // now in core TeX input jax
// iiint: ['MultiIntegral','\\int\\intI\\intI'], // now in core TeX input jax
// iiiint: ['MultiIntegral','\\int\\intI\\intI\\intI'], // now in mathchar0mo above
idotsint: ['MultiIntegral','\\int\\cdots\\int'],
// dddot: ['Macro','\\mathop{#1}\\limits^{\\textstyle \\mathord{.}\\mathord{.}\\mathord{.}}',1],
// ddddot: ['Macro','\\mathop{#1}\\limits^{\\textstyle \\mathord{.}\\mathord{.}\\mathord{.}\\mathord{.}}',1],
dddot: ['Accent','20DB'],
ddddot: ['Accent','20DC'],
sideset: ['Macro','\\mathop{\\mathop{\\rlap{\\phantom{#3}}}\\nolimits#1\\!\\mathop{#3}\\nolimits#2}',3],
boxed: ['Macro','\\fbox{$\\displaystyle{#1}$}',1],
tag: 'HandleTag',
notag: 'HandleNoTag',
label: 'HandleLabel',
ref: 'HandleRef',
eqref: ['HandleRef',true],
substack: ['Macro','\\begin{subarray}{c}#1\\end{subarray}',1],
injlim: ['NamedOp','inj&thinsp;lim'],
projlim: ['NamedOp','proj&thinsp;lim'],
varliminf: ['Macro','\\mathop{\\underline{\\mmlToken{mi}{lim}}}'],
varlimsup: ['Macro','\\mathop{\\overline{\\mmlToken{mi}{lim}}}'],
varinjlim: ['Macro','\\mathop{\\underrightarrow{\\mmlToken{mi}{lim}}}'],
varprojlim: ['Macro','\\mathop{\\underleftarrow{\\mmlToken{mi}{lim}}}'],
DeclareMathOperator: 'HandleDeclareOp',
operatorname: 'HandleOperatorName',
SkipLimits: 'SkipLimits',
genfrac: 'Genfrac',
frac: ['Genfrac',"","","",""],
tfrac: ['Genfrac',"","","",1],
dfrac: ['Genfrac',"","","",0],
binom: ['Genfrac',"(",")","0",""],
tbinom: ['Genfrac',"(",")","0",1],
dbinom: ['Genfrac',"(",")","0",0],
cfrac: 'CFrac',
shoveleft: ['HandleShove',MML.ALIGN.LEFT],
shoveright: ['HandleShove',MML.ALIGN.RIGHT],
xrightarrow: ['xArrow',0x2192,5,6],
xleftarrow: ['xArrow',0x2190,7,3]
},
environment: {
align: ['AMSarray',null,true,true, 'rlrlrlrlrlrl',COLS([0,2,0,2,0,2,0,2,0,2,0])],
'align*': ['AMSarray',null,false,true, 'rlrlrlrlrlrl',COLS([0,2,0,2,0,2,0,2,0,2,0])],
multline: ['Multline',null,true],
'multline*': ['Multline',null,false],
split: ['AMSarray',null,false,false,'rl',COLS([0])],
gather: ['AMSarray',null,true,true, 'c'],
'gather*': ['AMSarray',null,false,true, 'c'],
alignat: ['AlignAt',null,true,true],
'alignat*': ['AlignAt',null,false,true],
alignedat: ['AlignAt',null,false,false],
aligned: ['AlignedAMSArray',null,null,null,'rlrlrlrlrlrl',COLS([0,2,0,2,0,2,0,2,0,2,0]),".5em",'D'],
gathered: ['AlignedAMSArray',null,null,null,'c',null,".5em",'D'],
subarray: ['Array',null,null,null,null,COLS([0]),"0.1em",'S',1],
smallmatrix: ['Array',null,null,null,'c',COLS([1/3]),".2em",'S',1],
'equation': ['EquationBegin','Equation',true],
'equation*': ['EquationBegin','EquationStar',false],
eqnarray: ['AMSarray',null,true,true, 'rcl',"0 "+MML.LENGTH.THICKMATHSPACE,".5em"],
'eqnarray*': ['AMSarray',null,false,true,'rcl',"0 "+MML.LENGTH.THICKMATHSPACE,".5em"]
},
delimiter: {
'\\lvert': ['007C',{texClass:MML.TEXCLASS.OPEN}],
'\\rvert': ['007C',{texClass:MML.TEXCLASS.CLOSE}],
'\\lVert': ['2016',{texClass:MML.TEXCLASS.OPEN}],
'\\rVert': ['2016',{texClass:MML.TEXCLASS.CLOSE}]
}
},null,true);
/******************************************************************************/
TEX.Parse.Augment({
/*
* Add the tag to the environment (to be added to the table row later)
*/
HandleTag: function (name) {
var star = this.GetStar();
var arg = this.trimSpaces(this.GetArgument(name)), tag = arg;
if (!star) {arg = CONFIG.formatTag(arg)}
var global = this.stack.global; global.tagID = tag;
if (global.notags) {
TEX.Error(["CommandNotAllowedInEnv",
"%1 not allowed in %2 environment",
name,global.notags]
);
}
if (global.tag) {TEX.Error(["MultipleCommand","Multiple %1",name])}
global.tag = MML.mtd.apply(MML,this.InternalMath(arg)).With({id:CONFIG.formatID(tag)});
},
HandleNoTag: function (name) {
if (this.stack.global.tag) {delete this.stack.global.tag}
this.stack.global.notag = true; // prevent auto-tagging
},
/*
* Record a label name for a tag
*/
HandleLabel: function (name) {
var global = this.stack.global, label = this.GetArgument(name);
if (label === "") return;
if (!AMS.refUpdate) {
if (global.label) {TEX.Error(["MultipleCommand","Multiple %1",name])}
global.label = label;
if (AMS.labels[label] || AMS.eqlabels[label])
{TEX.Error(["MultipleLabel","Label '%1' multiply defined",label])}
AMS.eqlabels[label] = {tag:"???", id:""}; // will be replaced by tag value later
}
},
/*
* Handle a label reference
*/
HandleRef: function (name,eqref) {
var label = this.GetArgument(name);
var ref = AMS.labels[label] || AMS.eqlabels[label];
if (!ref) {ref = {tag:"???",id:""}; AMS.badref = !AMS.refUpdate}
var tag = ref.tag; if (eqref) {tag = CONFIG.formatTag(tag)}
this.Push(MML.mrow.apply(MML,this.InternalMath(tag)).With({
href:CONFIG.formatURL(ref.id,baseURL), "class":"MathJax_ref"
}));
},
/*
* Handle \DeclareMathOperator
*/
HandleDeclareOp: function (name) {
var limits = (this.GetStar() ? "" : "\\nolimits\\SkipLimits");
var cs = this.trimSpaces(this.GetArgument(name));
if (cs.charAt(0) == "\\") {cs = cs.substr(1)}
var op = this.GetArgument(name);
if (!op.match(/\\text/)) op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
this.setDef(cs, ['Macro', '\\mathop{\\rm '+op+'}'+limits]);
},
HandleOperatorName: function (name) {
var limits = (this.GetStar() ? "" : "\\nolimits\\SkipLimits");
var op = this.trimSpaces(this.GetArgument(name));
if (!op.match(/\\text/)) op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
this.string = '\\mathop{\\rm '+op+'}'+limits+" "+this.string.slice(this.i);
this.i = 0;
},
SkipLimits: function (name) {
var c = this.GetNext(), i = this.i;
if (c === "\\" && ++this.i && this.GetCS() !== "limits") this.i = i;
},
/*
* Record presence of \shoveleft and \shoveright
*/
HandleShove: function (name,shove) {
var top = this.stack.Top();
if (top.type !== "multline") {
TEX.Error(["CommandInMultline",
"%1 can only appear within the multline environment",name]);
}
if (top.data.length) {
TEX.Error(["CommandAtTheBeginingOfLine",
"%1 must come at the beginning of the line",name]);
}
top.data.shove = shove;
},
/*
* Handle \cfrac
*/
CFrac: function (name) {
var lr = this.trimSpaces(this.GetBrackets(name,"")),
num = this.GetArgument(name),
den = this.GetArgument(name);
var frac = MML.mfrac(TEX.Parse('\\strut\\textstyle{'+num+'}',this.stack.env).mml(),
TEX.Parse('\\strut\\textstyle{'+den+'}',this.stack.env).mml());
lr = ({l:MML.ALIGN.LEFT, r:MML.ALIGN.RIGHT,"":""})[lr];
if (lr == null)
{TEX.Error(["IllegalAlign","Illegal alignment specified in %1",name])}
if (lr) {frac.numalign = frac.denomalign = lr}
this.Push(frac);
},
/*
* Implement AMS generalized fraction
*/
Genfrac: function (name,left,right,thick,style) {
if (left == null) {left = this.GetDelimiterArg(name)}
if (right == null) {right = this.GetDelimiterArg(name)}
if (thick == null) {thick = this.GetArgument(name)}
if (style == null) {style = this.trimSpaces(this.GetArgument(name))}
var num = this.ParseArg(name);
var den = this.ParseArg(name);
var frac = MML.mfrac(num,den);
if (thick !== "") {frac.linethickness = thick}
if (left || right) {frac = TEX.fixedFence(left,frac.With({texWithDelims:true}),right)}
if (style !== "") {
var STYLE = (["D","T","S","SS"])[style];
if (STYLE == null)
{TEX.Error(["BadMathStyleFor","Bad math style for %1",name])}
frac = MML.mstyle(frac);
if (STYLE === "D") {frac.displaystyle = true; frac.scriptlevel = 0}
else {frac.displaystyle = false; frac.scriptlevel = style - 1}
}
this.Push(frac);
},
/*
* Implements multline environment (mostly handled through STACKITEM below)
*/
Multline: function (begin,numbered) {
this.Push(begin); this.checkEqnEnv();
return STACKITEM.multline(numbered,this.stack).With({
arraydef: {
displaystyle: true,
rowspacing: ".5em",
width: TEX.config.MultLineWidth, columnwidth:"100%",
side: TEX.config.TagSide,
minlabelspacing: TEX.config.TagIndent
}
});
},
/*
* Handle AMS aligned environments
*/
AMSarray: function (begin,numbered,taggable,align,spacing) {
this.Push(begin); if (taggable) {this.checkEqnEnv()}
align = align.replace(/[^clr]/g,'').split('').join(' ');
align = align.replace(/l/g,'left').replace(/r/g,'right').replace(/c/g,'center');
return STACKITEM.AMSarray(begin.name,numbered,taggable,this.stack).With({
arraydef: {
displaystyle: true,
rowspacing: ".5em",
columnalign: align,
columnspacing: (spacing||"1em"),
rowspacing: "3pt",
side: TEX.config.TagSide,
minlabelspacing: TEX.config.TagIndent
}
});
},
AlignedAMSArray: function (begin) {
var align = this.GetBrackets("\\begin{"+begin.name+"}");
return this.setArrayAlign(this.AMSarray.apply(this,arguments),align);
},
/*
* Handle alignat environments
*/
AlignAt: function (begin,numbered,taggable) {
var n, valign, align = "", spacing = [];
if (!taggable) {valign = this.GetBrackets("\\begin{"+begin.name+"}")}
n = this.GetArgument("\\begin{"+begin.name+"}");
if (n.match(/[^0-9]/)) {
TEX.Error(["PositiveIntegerArg","Argument to %1 must me a positive integer",
"\\begin{"+begin.name+"}"]);
}
while (n > 0) {align += "rl"; spacing.push("0em 0em"); n--}
spacing = spacing.join(" ");
if (taggable) {return this.AMSarray(begin,numbered,taggable,align,spacing)}
var array = this.AMSarray(begin,numbered,taggable,align,spacing);
return this.setArrayAlign(array,valign);
},
/*
* Handle equation environment
*/
EquationBegin: function (begin,force) {
this.checkEqnEnv();
this.stack.global.forcetag = (force && CONFIG.autoNumber !== "none");
return begin;
},
EquationStar: function (begin,row) {
this.stack.global.tagged = true; // prevent automatic tagging
return row;
},
/*
* Check for bad nesting of equation environments
*/
checkEqnEnv: function () {
if (this.stack.global.eqnenv)
{TEX.Error(["ErroneousNestingEq","Erroneous nesting of equation structures"])}
this.stack.global.eqnenv = true;
},
/*
* Handle multiple integrals (make a mathop if followed by limits)
*/
MultiIntegral: function (name,integral) {
var next = this.GetNext();
if (next === "\\") {
var i = this.i; next = this.GetArgument(name); this.i = i;
if (next === "\\limits") {
if (name === "\\idotsint") {integral = "\\!\\!\\mathop{\\,\\,"+integral+"}"}
else {integral = "\\!\\!\\!\\mathop{\\,\\,\\,"+integral+"}"}
}
}
this.string = integral + " " + this.string.slice(this.i);
this.i = 0;
},
/*
* Handle stretchable arrows
*/
xArrow: function (name,chr,l,r) {
var def = {width: "+"+(l+r)+"mu", lspace: l+"mu"};
var bot = this.GetBrackets(name),
top = this.ParseArg(name);
var arrow = MML.mo(MML.chars(String.fromCharCode(chr))).With({
stretchy: true, texClass: MML.TEXCLASS.REL
});
var mml = MML.munderover(arrow);
mml.SetData(mml.over,MML.mpadded(top).With(def).With({voffset:".15em"}));
if (bot) {
bot = TEX.Parse(bot,this.stack.env).mml()
mml.SetData(mml.under,MML.mpadded(bot).With(def).With({voffset:"-.24em"}));
}
this.Push(mml.With({subsupOK:true}));
},
/*
* Get a delimiter or empty argument
*/
GetDelimiterArg: function (name) {
var c = this.trimSpaces(this.GetArgument(name));
if (c == "") return null;
if (c in TEXDEF.delimiter) return c;
TEX.Error(["MissingOrUnrecognizedDelim","Missing or unrecognized delimiter for %1",name]);
},
/*
* Get a star following a control sequence name, if any
*/
GetStar: function () {
var star = (this.GetNext() === "*");
if (star) {this.i++}
return star;
}
});
/******************************************************************************/
STACKITEM.Augment({
/*
* Increment equation number and form tag mtd element
*/
autoTag: function () {
var global = this.global;
if (!global.notag) {
AMS.number++; global.tagID = CONFIG.formatNumber(AMS.number.toString());
var mml = TEX.Parse("\\text{"+CONFIG.formatTag(global.tagID)+"}",{}).mml();
global.tag = MML.mtd(mml).With({id:CONFIG.formatID(global.tagID)});
}
},
/*
* Get the tag and record the label, if any
*/
getTag: function () {
var global = this.global, tag = global.tag; global.tagged = true;
if (global.label) {
if (CONFIG.useLabelIds) {tag.id = CONFIG.formatID(global.label)}
AMS.eqlabels[global.label] = {tag:global.tagID, id:tag.id};
}
//
// Check for repeated ID's (either in the document or as
// a previous tag) and find a unique related one. (#240)
//
if (document.getElementById(tag.id) || AMS.IDs[tag.id] || AMS.eqIDs[tag.id]) {
var i = 0, ID;
do {i++; ID = tag.id+"_"+i}
while (document.getElementById(ID) || AMS.IDs[ID] || AMS.eqIDs[ID]);
tag.id = ID; if (global.label) {AMS.eqlabels[global.label].id = ID}
}
AMS.eqIDs[tag.id] = 1;
this.clearTag();
return tag;
},
clearTag: function () {
var global = this.global;
delete global.tag; delete global.tagID; delete global.label;
},
/*
* If the initial child, skipping any initial space or
* empty braces (TeXAtom with child being an empty inferred row),
* is an <mo>, precede it by an empty <mi> to force the <mo> to
* be infix.
*/
fixInitialMO: function (data) {
for (var i = 0, m = data.length; i < m; i++) {
if (data[i] && (data[i].type !== "mspace" &&
(data[i].type !== "texatom" || (data[i].data[0] && data[i].data[0].data.length)))) {
if (data[i].isEmbellished() ||
(data[i].type === "texatom" && data[i].texClass === MML.TEXCLASS.REL)) data.unshift(MML.mi());
break;
}
}
}
});
/*
* Implement multline environment via a STACKITEM
*/
STACKITEM.multline = STACKITEM.array.Subclass({
type: "multline",
Init: function (numbered,stack) {
this.SUPER(arguments).Init.apply(this);
this.numbered = (numbered && CONFIG.autoNumber !== "none");
this.save = {notag: stack.global.notag};
stack.global.tagged = !numbered && !stack.global.forcetag; // prevent automatic tagging in starred environments
},
EndEntry: function () {
if (this.table.length) {this.fixInitialMO(this.data)}
var mtd = MML.mtd.apply(MML,this.data);
if (this.data.shove) {mtd.columnalign = this.data.shove}
this.row.push(mtd);
this.data = [];
},
EndRow: function () {
if (this.row.length != 1) {
TEX.Error(["MultlineRowsOneCol",
"The rows within the %1 environment must have exactly one column",
"multline"]);
}
this.table.push(this.row); this.row = [];
},
EndTable: function () {
this.SUPER(arguments).EndTable.call(this);
if (this.table.length) {
var m = this.table.length-1, i, label = -1;
if (!this.table[0][0].columnalign) {this.table[0][0].columnalign = MML.ALIGN.LEFT}
if (!this.table[m][0].columnalign) {this.table[m][0].columnalign = MML.ALIGN.RIGHT}
if (!this.global.tag && this.numbered) {this.autoTag()}
if (this.global.tag && !this.global.notags) {
label = (this.arraydef.side === "left" ? 0 : this.table.length - 1);
this.table[label] = [this.getTag()].concat(this.table[label]);
}
for (i = 0, m = this.table.length; i < m; i++) {
var mtr = (i === label ? MML.mlabeledtr : MML.mtr);
this.table[i] = mtr.apply(MML,this.table[i]);
}
}
this.global.notag = this.save.notag;
}
});
/*
* Save data about numbering and taging equations, and add
* tags at the ends of rows.
*/
STACKITEM.AMSarray = STACKITEM.array.Subclass({
type: "AMSarray",
Init: function (name,numbered,taggable,stack) {
this.SUPER(arguments).Init.apply(this);
this.numbered = (numbered && CONFIG.autoNumber !== "none");
this.save = {notags: stack.global.notags, notag: stack.global.notag};
stack.global.notags = (taggable ? null : name);
stack.global.tagged = !numbered && taggable && !stack.global.forcetag; // prevent automatic tagging in starred environments
},
EndEntry: function () {
if (this.row.length % 2 === 1) {this.fixInitialMO(this.data)}
this.row.push(MML.mtd.apply(MML,this.data));
this.data = [];
},
EndRow: function () {
var mtr = MML.mtr;
if (!this.global.tag && this.numbered) {this.autoTag()}
if (!this.global.notags) {
if (this.global.tag) {
this.row = [this.getTag()].concat(this.row);
mtr = MML.mlabeledtr;
} else {
this.clearTag();
}
}
if (this.numbered) {delete this.global.notag}
this.table.push(mtr.apply(MML,this.row)); this.row = [];
},
EndTable: function () {
this.SUPER(arguments).EndTable.call(this);
this.global.notags = this.save.notags;
this.global.notag = this.save.notag;
}
});
//
// Look for \tag on a formula and make an mtable to include it
//
STACKITEM.start.Augment({
oldCheckItem: STACKITEM.start.prototype.checkItem,
checkItem: function (item) {
if (item.type === "stop") {
var mml = this.mmlData(), global = this.global;
if (AMS.display && !global.tag && !global.tagged && !global.isInner &&
(CONFIG.autoNumber === "all" || global.forcetag)) {this.autoTag()}
if (global.tag) {
var row = [this.getTag(),MML.mtd(mml)];
var def = {
side: TEX.config.TagSide,
minlabelspacing: TEX.config.TagIndent,
displaystyle: "inherit" // replaced by TeX input jax Translate() function with actual value
};
mml = MML.mtable(MML.mlabeledtr.apply(MML,row)).With(def);
}
return STACKITEM.mml(mml);
}
return this.oldCheckItem.call(this,item);
}
});
/******************************************************************************/
/*
* Add pre- and post-filters to handle the equation number maintenance.
*/
TEX.prefilterHooks.Add(function (data) {
AMS.display = data.display;
AMS.number = AMS.startNumber; // reset equation numbers (in case the equation restarted)
AMS.eqlabels = {};
AMS.eqIDs = {};
AMS.badref = false;
if (AMS.refUpdate) {AMS.number = data.script.MathJax.startNumber}
});
TEX.postfilterHooks.Add(function (data) {
data.script.MathJax.startNumber = AMS.startNumber;
AMS.startNumber = AMS.number; // equation numbers for next equation
MathJax.Hub.Insert(AMS.IDs,AMS.eqIDs); // save IDs from this equation
MathJax.Hub.Insert(AMS.labels,AMS.eqlabels); // save labels from this equation
if (AMS.badref && !data.math.texError) {AMS.refs.push(data.script)} // reprocess later
},100);
MathJax.Hub.Register.MessageHook("Begin Math Input",function () {
AMS.refs = []; // array of jax with bad references
AMS.refUpdate = false;
});
MathJax.Hub.Register.MessageHook("End Math Input",function (message) {
if (AMS.refs.length) {
AMS.refUpdate = true;
for (var i = 0, m = AMS.refs.length; i < m; i++)
{AMS.refs[i].MathJax.state = MathJax.ElementJax.STATE.UPDATE}
return MathJax.Hub.processInput({
scripts:AMS.refs,
start: new Date().getTime(),
i:0, j:0, jax:{}, jaxIDs:[]
});
}
return null;
});
//
// Clear the equation numbers and labels
//
TEX.resetEquationNumbers = function (n,keepLabels) {
AMS.startNumber = (n || 0);
if (!keepLabels) {
AMS.labels = {};
AMS.IDs = {};
}
}
/******************************************************************************/
MathJax.Hub.Startup.signal.Post("TeX AMSmath Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSmath.js");

349
web/assets/MathJax/unpacked/extensions/TeX/AMSsymbols.js vendored Normal file
View File

@@ -0,0 +1,349 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/AMSsymbols.js
*
* Implements macros for accessing the AMS symbol fonts.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/AMSsymbols"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var MML = MathJax.ElementJax.mml,
TEXDEF = MathJax.InputJax.TeX.Definitions;
TEXDEF.Add({
mathchar0mi: {
// Lowercase Greek letters
digamma: '03DD',
varkappa: '03F0',
// Uppercase Greek letters
varGamma: ['0393',{mathvariant: MML.VARIANT.ITALIC}],
varDelta: ['0394',{mathvariant: MML.VARIANT.ITALIC}],
varTheta: ['0398',{mathvariant: MML.VARIANT.ITALIC}],
varLambda: ['039B',{mathvariant: MML.VARIANT.ITALIC}],
varXi: ['039E',{mathvariant: MML.VARIANT.ITALIC}],
varPi: ['03A0',{mathvariant: MML.VARIANT.ITALIC}],
varSigma: ['03A3',{mathvariant: MML.VARIANT.ITALIC}],
varUpsilon: ['03A5',{mathvariant: MML.VARIANT.ITALIC}],
varPhi: ['03A6',{mathvariant: MML.VARIANT.ITALIC}],
varPsi: ['03A8',{mathvariant: MML.VARIANT.ITALIC}],
varOmega: ['03A9',{mathvariant: MML.VARIANT.ITALIC}],
// Hebrew letters
beth: '2136',
gimel: '2137',
daleth: '2138',
// Miscellaneous symbols
// hbar: '0127', // in TeX/jax.js
backprime: ['2035',{variantForm: true}],
hslash: '210F',
varnothing: ['2205',{variantForm: true}],
blacktriangle: '25B4',
triangledown: ['25BD',{variantForm: true}],
blacktriangledown: '25BE',
square: '25FB',
Box: '25FB',
blacksquare: '25FC',
lozenge: '25CA',
Diamond: '25CA',
blacklozenge: '29EB',
circledS: ['24C8',{mathvariant: MML.VARIANT.NORMAL}],
bigstar: '2605',
// angle: '2220', // in TeX/jax.js
sphericalangle: '2222',
measuredangle: '2221',
nexists: '2204',
complement: '2201',
mho: '2127',
eth: ['00F0',{mathvariant: MML.VARIANT.NORMAL}],
Finv: '2132',
diagup: '2571',
Game: '2141',
diagdown: '2572',
Bbbk: ['006B',{mathvariant: MML.VARIANT.DOUBLESTRUCK}],
yen: '00A5',
circledR: '00AE',
checkmark: '2713',
maltese: '2720'
},
mathchar0mo: {
// Binary operators
dotplus: '2214',
ltimes: '22C9',
smallsetminus: '2216',
rtimes: '22CA',
Cap: '22D2',
doublecap: '22D2',
leftthreetimes: '22CB',
Cup: '22D3',
doublecup: '22D3',
rightthreetimes: '22CC',
barwedge: '22BC',
curlywedge: '22CF',
veebar: '22BB',
curlyvee: '22CE',
doublebarwedge: '2A5E',
boxminus: '229F',
circleddash: '229D',
boxtimes: '22A0',
circledast: '229B',
boxdot: '22A1',
circledcirc: '229A',
boxplus: '229E',
centerdot: ['22C5',{variantForm: true}],
divideontimes: '22C7',
intercal: '22BA',
// Binary relations
leqq: '2266',
geqq: '2267',
leqslant: '2A7D',
geqslant: '2A7E',
eqslantless: '2A95',
eqslantgtr: '2A96',
lesssim: '2272',
gtrsim: '2273',
lessapprox: '2A85',
gtrapprox: '2A86',
approxeq: '224A',
lessdot: '22D6',
gtrdot: '22D7',
lll: '22D8',
llless: '22D8',
ggg: '22D9',
gggtr: '22D9',
lessgtr: '2276',
gtrless: '2277',
lesseqgtr: '22DA',
gtreqless: '22DB',
lesseqqgtr: '2A8B',
gtreqqless: '2A8C',
doteqdot: '2251',
Doteq: '2251',
eqcirc: '2256',
risingdotseq: '2253',
circeq: '2257',
fallingdotseq: '2252',
triangleq: '225C',
backsim: '223D',
thicksim: ['223C',{variantForm: true}],
backsimeq: '22CD',
thickapprox: ['2248',{variantForm: true}],
subseteqq: '2AC5',
supseteqq: '2AC6',
Subset: '22D0',
Supset: '22D1',
sqsubset: '228F',
sqsupset: '2290',
preccurlyeq: '227C',
succcurlyeq: '227D',
curlyeqprec: '22DE',
curlyeqsucc: '22DF',
precsim: '227E',
succsim: '227F',
precapprox: '2AB7',
succapprox: '2AB8',
vartriangleleft: '22B2',
lhd: '22B2',
vartriangleright: '22B3',
rhd: '22B3',
trianglelefteq: '22B4',
unlhd: '22B4',
trianglerighteq: '22B5',
unrhd: '22B5',
vDash: '22A8',
Vdash: '22A9',
Vvdash: '22AA',
smallsmile: ['2323',{variantForm: true}],
shortmid: ['2223',{variantForm: true}],
smallfrown: ['2322',{variantForm: true}],
shortparallel: ['2225',{variantForm: true}],
bumpeq: '224F',
between: '226C',
Bumpeq: '224E',
pitchfork: '22D4',
varpropto: '221D',
backepsilon: '220D',
blacktriangleleft: '25C2',
blacktriangleright: '25B8',
therefore: '2234',
because: '2235',
eqsim: '2242',
vartriangle: ['25B3',{variantForm: true}],
Join: '22C8',
// Negated relations
nless: '226E',
ngtr: '226F',
nleq: '2270',
ngeq: '2271',
nleqslant: ['2A87',{variantForm: true}],
ngeqslant: ['2A88',{variantForm: true}],
nleqq: ['2270',{variantForm: true}],
ngeqq: ['2271',{variantForm: true}],
lneq: '2A87',
gneq: '2A88',
lneqq: '2268',
gneqq: '2269',
lvertneqq: ['2268',{variantForm: true}],
gvertneqq: ['2269',{variantForm: true}],
lnsim: '22E6',
gnsim: '22E7',
lnapprox: '2A89',
gnapprox: '2A8A',
nprec: '2280',
nsucc: '2281',
npreceq: ['22E0',{variantForm: true}],
nsucceq: ['22E1',{variantForm: true}],
precneqq: '2AB5',
succneqq: '2AB6',
precnsim: '22E8',
succnsim: '22E9',
precnapprox: '2AB9',
succnapprox: '2ABA',
nsim: '2241',
ncong: '2246',
nshortmid: ['2224',{variantForm: true}],
nshortparallel: ['2226',{variantForm: true}],
nmid: '2224',
nparallel: '2226',
nvdash: '22AC',
nvDash: '22AD',
nVdash: '22AE',
nVDash: '22AF',
ntriangleleft: '22EA',
ntriangleright: '22EB',
ntrianglelefteq: '22EC',
ntrianglerighteq: '22ED',
nsubseteq: '2288',
nsupseteq: '2289',
nsubseteqq: ['2288',{variantForm: true}],
nsupseteqq: ['2289',{variantForm: true}],
subsetneq: '228A',
supsetneq: '228B',
varsubsetneq: ['228A',{variantForm: true}],
varsupsetneq: ['228B',{variantForm: true}],
subsetneqq: '2ACB',
supsetneqq: '2ACC',
varsubsetneqq: ['2ACB',{variantForm: true}],
varsupsetneqq: ['2ACC',{variantForm: true}],
// Arrows
leftleftarrows: '21C7',
rightrightarrows: '21C9',
leftrightarrows: '21C6',
rightleftarrows: '21C4',
Lleftarrow: '21DA',
Rrightarrow: '21DB',
twoheadleftarrow: '219E',
twoheadrightarrow: '21A0',
leftarrowtail: '21A2',
rightarrowtail: '21A3',
looparrowleft: '21AB',
looparrowright: '21AC',
leftrightharpoons: '21CB',
rightleftharpoons: ['21CC',{variantForm: true}],
curvearrowleft: '21B6',
curvearrowright: '21B7',
circlearrowleft: '21BA',
circlearrowright: '21BB',
Lsh: '21B0',
Rsh: '21B1',
upuparrows: '21C8',
downdownarrows: '21CA',
upharpoonleft: '21BF',
upharpoonright: '21BE',
downharpoonleft: '21C3',
restriction: '21BE',
multimap: '22B8',
downharpoonright: '21C2',
leftrightsquigarrow: '21AD',
rightsquigarrow: '21DD',
leadsto: '21DD',
dashrightarrow: '21E2',
dashleftarrow: '21E0',
// Negated arrows
nleftarrow: '219A',
nrightarrow: '219B',
nLeftarrow: '21CD',
nRightarrow: '21CF',
nleftrightarrow: '21AE',
nLeftrightarrow: '21CE'
},
delimiter: {
// corners
"\\ulcorner": '231C',
"\\urcorner": '231D',
"\\llcorner": '231E',
"\\lrcorner": '231F'
},
macros: {
implies: ['Macro','\\;\\Longrightarrow\\;'],
impliedby: ['Macro','\\;\\Longleftarrow\\;']
}
},null,true);
var REL = MML.mo.OPTYPES.REL;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u2322': REL, // smallfrown
'\u2323': REL, // smallsmile
'\u25B3': REL, // vartriangle
'\uE006': REL, // nshortmid
'\uE007': REL, // nshortparallel
'\uE00C': REL, // lvertneqq
'\uE00D': REL, // gvertneqq
'\uE00E': REL, // ngeqq
'\uE00F': REL, // ngeqslant
'\uE010': REL, // nleqslant
'\uE011': REL, // nleqq
'\uE016': REL, // nsubseteqq
'\uE017': REL, // varsubsetneqq
'\uE018': REL, // nsupseteqq
'\uE019': REL, // varsupsetneqq
'\uE01A': REL, // varsubsetneq
'\uE01B': REL, // varsupsetneq
'\uE04B': REL, // npreceq
'\uE04F': REL // nsucceq
}
}
});
MathJax.Hub.Startup.signal.Post("TeX AMSsymbols Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSsymbols.js");

106
web/assets/MathJax/unpacked/extensions/TeX/HTML.js vendored Normal file
View File

@@ -0,0 +1,106 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/HTML.js
*
* Implements the \href, \class, \style, \cssId macros.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/HTML"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEXDEF.Add({
macros: {
href: 'HREF_attribute',
"class": 'CLASS_attribute',
style: 'STYLE_attribute',
cssId: 'ID_attribute'
}
},null,true);
TEX.Parse.Augment({
//
// Implements \href{url}{math}
//
HREF_attribute: function (name) {
var url = this.GetArgument(name),
arg = this.GetArgumentMML(name);
this.Push(arg.With({href:url}));
},
//
// Implements \class{name}{math}
//
CLASS_attribute: function (name) {
var CLASS = this.GetArgument(name),
arg = this.GetArgumentMML(name);
if (arg["class"] != null) {CLASS = arg["class"] + " " + CLASS}
this.Push(arg.With({"class":CLASS}));
},
//
// Implements \style{style-string}{math}
//
STYLE_attribute: function (name) {
var style = this.GetArgument(name),
arg = this.GetArgumentMML(name);
// check that it looks like a style string
if (arg.style != null) {
if (style.charAt(style.length-1) !== ";") {style += ";"}
style = arg.style + " " + style;
}
this.Push(arg.With({style: style}));
},
//
// Implements \cssId{id}{math}
//
ID_attribute: function (name) {
var ID = this.GetArgument(name),
arg = this.GetArgumentMML(name);
this.Push(arg.With({id:ID}));
},
//
// returns an argument that is a single MathML element
// (in an mrow if necessary)
//
GetArgumentMML: function (name) {
var arg = this.ParseArg(name);
if (arg.inferred && arg.data.length == 1)
{arg = arg.data[0]} else {delete arg.inferred}
return arg;
}
});
MathJax.Hub.Startup.signal.Post("TeX HTML Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/HTML.js");

83
web/assets/MathJax/unpacked/extensions/TeX/action.js vendored Normal file
View File

@@ -0,0 +1,83 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/action.js
*
* Implements the \mathtip, \texttip, and \toggle macros, which give
* access from TeX to the <maction> tag in the MathML that underlies
* MathJax's internal format.
*
* Usage:
*
* \mathtip{math}{tip} % use "tip" (in math mode) as tooltip for "math"
* \texttip{math}{tip} % use "tip" (in text mode) as tooltip for "math"
* \toggle{math1}{math2}...\endtoggle
* % show math1, and when clicked, show math2, and so on.
* % When the last one is clicked, go back to math1.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/action"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml;
//
// Set up control sequenecs
//
TEX.Definitions.Add({
macros: {
toggle: 'Toggle',
mathtip: 'Mathtip',
texttip: ['Macro','\\mathtip{#1}{\\text{#2}}',2]
}
},null,true);
TEX.Parse.Augment({
//
// Implement \toggle {math1} {math2} ... \endtoggle
// (as an <maction actiontype="toggle">)
//
Toggle: function (name) {
var data = [], arg;
while ((arg = this.GetArgument(name)) !== "\\endtoggle")
{data.push(TEX.Parse(arg,this.stack.env).mml())}
this.Push(MML.maction.apply(MML,data).With({actiontype: MML.ACTIONTYPE.TOGGLE}));
},
//
// Implement \mathtip{math}{tip}
// (an an <maction actiontype="tooltip">)
//
Mathtip: function(name) {
var arg = this.ParseArg(name), tip = this.ParseArg(name);
this.Push(MML.maction(arg,tip).With({actiontype: MML.ACTIONTYPE.TOOLTIP}));
}
});
MathJax.Hub.Startup.signal.Post("TeX action Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/action.js");

50
web/assets/MathJax/unpacked/extensions/TeX/autobold.js vendored Normal file
View File

@@ -0,0 +1,50 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/autobold.js
*
* Adds \boldsymbol around mathematics that appears in a section
* of an HTML page that is in bold.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/autobold"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX;
TEX.prefilterHooks.Add(function (data) {
var span = data.script.parentNode.insertBefore(document.createElement("span"),data.script);
span.visibility = "hidden";
span.style.fontFamily = "Times, serif";
span.appendChild(document.createTextNode("ABCXYZabcxyz"));
var W = span.offsetWidth;
span.style.fontWeight = "bold";
if (W && span.offsetWidth === W) {data.math = "\\boldsymbol{"+data.math+"}"}
span.parentNode.removeChild(span);
});
MathJax.Hub.Startup.signal.Post("TeX autobold Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/autobold.js");

83
web/assets/MathJax/unpacked/extensions/TeX/autoload-all.js vendored Normal file
View File

@@ -0,0 +1,83 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/autoload-all.js
*
* Provides pre-defined macros to autoload all the extensions
* so that all macros that MathJax knows about are available.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/autoload-all"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var EXTENSIONS = {
action: ["mathtip","texttip","toggle"],
AMSmath: ["mathring","nobreakspace","negmedspace","negthickspace","intI",
"iiiint","idotsint","dddot","ddddot","sideset","boxed",
"substack","injlim","projlim","varliminf","varlimsup",
"varinjlim","varprojlim","DeclareMathOperator","operatorname",
"genfrac","tfrac","dfrac","binom","tbinom","dbinom","cfrac",
"shoveleft","shoveright","xrightarrow","xleftarrow"],
begingroup: ["begingroup","endgroup","gdef","global"],
cancel: ["cancel","bcancel","xcancel","cancelto"],
color: ["color","textcolor","colorbox","fcolorbox","definecolor"],
enclose: ["enclose"],
extpfeil: ["Newextarrow","xlongequal","xmapsto","xtofrom",
"xtwoheadleftarrow","xtwoheadrightarrow"],
mhchem: ["ce","cee","cf"]
};
var ENVIRONMENTS = {
AMSmath: ["subarray","smallmatrix","equation","equation*"],
AMScd: ["CD"]
};
var name, i, m, defs = {macros:{}, environment:{}};
for (name in EXTENSIONS) {if (EXTENSIONS.hasOwnProperty(name)) {
if (!MathJax.Extension["TeX/"+name]) {
var macros = EXTENSIONS[name];
for (i = 0, m = macros.length; i < m; i++)
{defs.macros[macros[i]] = ["Extension",name]}
}
}}
for (name in ENVIRONMENTS) {if (ENVIRONMENTS.hasOwnProperty(name)) {
if (!MathJax.Extension["TeX/"+name]) {
var envs = ENVIRONMENTS[name];
for (i = 0, m = envs.length; i < m; i++)
{defs.environment[envs[i]] = ["ExtensionEnv",null,name]}
}
}}
MathJax.InputJax.TeX.Definitions.Add(defs);
MathJax.Hub.Startup.signal.Post("TeX autoload-all Ready");
});
MathJax.Callback.Queue(
["Require",MathJax.Ajax,"[MathJax]/extensions/TeX/AMSsymbols.js"],
["loadComplete",MathJax.Ajax,"[MathJax]/extensions/TeX/autoload-all.js"]
);

102
web/assets/MathJax/unpacked/extensions/TeX/bbox.js vendored Normal file
View File

@@ -0,0 +1,102 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/bbox.js
*
* This file implements the \bbox macro, which creates an box that
* can be styled (for background colors, and so on). You can include
* an optional dimension that tells how much extra padding to include
* around the bounding box for the mathematics, or a color specification
* for the background color to use, or both. E.g.,
*
* \bbox[2pt]{x+y} % an invisible box around x+y with 2pt of extra space
* \bbox[green]{x+y} % a green box around x+y
* \bbox[green,2pt]{x+y} % a green box with 2pt of extra space
*
* You can also specify style attributes, for example
*
* \bbox[red,border:3px solid blue,5px]{x+y}
*
* would give a red background with a 3px solid blue border that has 5px
* of padding between the border and the mathematics. Note that not all
* output formats support the style specifications. In particular, the
* NativeMML output depends on the browser to render the attributes, and
* not all MathML renderers will honor them (e.g., MathPlayer2 doesn't
* render border styles).
*
* This file will be loaded automatically when \bbox is first used.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/bbox"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml;
TEX.Definitions.Add({macros: {bbox: "BBox"}},null,true);
TEX.Parse.Augment({
BBox: function (name) {
var bbox = this.GetBrackets(name,""),
math = this.ParseArg(name);
var parts = bbox.split(/,/), def, background, style;
for (var i = 0, m = parts.length; i < m; i++) {
var part = parts[i].replace(/^\s+/,'').replace(/\s+$/,'');
var match = part.match(/^(\.\d+|\d+(\.\d*)?)(pt|em|ex|mu|px|in|cm|mm)$/);
if (match) {
if (def)
{TEX.Error(["MultipleBBoxProperty","%1 specified twice in %2","Padding",name])}
var pad = this.BBoxPadding(match[1]+match[3]);
if (pad) def = {height:"+"+pad, depth:"+"+pad, lspace:pad, width:"+"+(2*match[1])+match[3]};
} else if (part.match(/^([a-z0-9]+|\#[0-9a-f]{6}|\#[0-9a-f]{3})$/i)) {
if (background)
{TEX.Error(["MultipleBBoxProperty","%1 specified twice in %2","Background",name])}
background = part;
} else if (part.match(/^[-a-z]+:/i)) {
if (style)
{TEX.Error(["MultipleBBoxProperty","%1 specified twice in %2", "Style",name])}
style = this.BBoxStyle(part);
} else if (part !== "") {
TEX.Error(
["InvalidBBoxProperty",
"'%1' doesn't look like a color, a padding dimension, or a style",
part]
);
}
}
if (def) {math = MML.mpadded(math).With(def)}
if (background || style) {
math = MML.mstyle(math).With({mathbackground:background, style:style});
}
this.Push(math);
},
BBoxStyle: function (styles) {return styles},
BBoxPadding: function (pad) {return pad}
});
MathJax.Hub.Startup.signal.Post("TeX bbox Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/bbox.js");

292
web/assets/MathJax/unpacked/extensions/TeX/begingroup.js vendored Normal file
View File

@@ -0,0 +1,292 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/begingroup.js
*
* Implements \begingroup and \endgroup commands that make local
* definitions possible and are removed when the \endgroup occurs.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/begingroup"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
TEXDEF = TEX.Definitions;
/****************************************************/
//
// A namespace for localizing macros and environments
// (\begingroup and \endgroup create and destroy these)
//
var NSFRAME = MathJax.Object.Subclass({
macros: null, // the local macro definitions
environments: null, // the local environments
Init: function (macros,environments) {
this.macros = (macros || {});
this.environments = (environments || {});
},
//
// Find a macro or environment by name
//
Find: function (name,type) {if (this[type].hasOwnProperty(name)) {return this[type][name]}},
//
// Define or remove a macro or environment
//
Def: function (name,value,type) {this[type][name] = value},
Undef: function (name,type) {delete this[type][name]},
//
// Merge two namespaces (used when the equation namespace is combined with the root one)
//
Merge: function (frame) {
MathJax.Hub.Insert(this.macros,frame.macros);
MathJax.Hub.Insert(this.environments,frame.environments);
},
//
// Move global macros to the stack (globally) and remove from the frame
//
MergeGlobals: function (stack) {
var macros = this.macros;
for (var cs in macros) {if (macros.hasOwnProperty(cs) && macros[cs].global) {
stack.Def(cs,macros[cs],"macros",true);
delete macros[cs].global; delete macros[cs];
}}
},
//
// Clear the macro and environment lists
// (but not global macros unless "all" is true)
//
Clear: function (all) {
this.environments = {};
if (all) {this.macros = {}} else {
var macros = this.macros;
for (var cs in macros) {
if (macros.hasOwnProperty(cs) && !macros[cs].global) {delete macros[cs]}
}
}
return this;
}
});
/****************************************************/
//
// A Stack of namespace frames
//
var NSSTACK = TEX.nsStack = MathJax.Object.Subclass({
stack: null, // the namespace frames
top: 0, // the current top one (we don't pop for real until the equation completes)
isEqn: false, // true if this is the equation stack (not the global one)
//
// Set up the initial stack frame
//
Init: function (eqn) {
this.isEqn = eqn; this.stack = [];
if (!eqn) {this.Push(NSFRAME(TEXDEF.macros,TEXDEF.environment))}
else {this.Push(NSFRAME())}
},
//
// Define a macro or environment in the top frame
//
Def: function (name,value,type,global) {
var n = this.top-1;
if (global) {
//
// Define global macros in the base frame and remove that cs
// from all other frames. Mark the global ones in equations
// so they can be made global when merged with the root stack.
//
while (n > 0) {this.stack[n].Undef(name,type); n--}
if (!MathJax.Object.isArray(value)) {value = [value]}
if (this.isEqn) {value.global = true}
}
this.stack[n].Def(name,value,type);
},
//
// Push a new namespace frame on the stack
//
Push: function (frame) {
this.stack.push(frame);
this.top = this.stack.length;
},
//
// Pop the top stack frame
// (if it is the root, just keep track of the pop so we can
// reset it if the equation is reprocessed)
//
Pop: function () {
var top;
if (this.top > 1) {
top = this.stack[--this.top];
if (this.isEqn) {this.stack.pop()}
} else if (this.isEqn) {
this.Clear();
}
return top;
},
//
// Search the stack from top to bottom for the first
// definition of the given control sequence in the given type
//
Find: function (name,type) {
for (var i = this.top-1; i >= 0; i--) {
var def = this.stack[i].Find(name,type);
if (def) {return def}
}
return null;
},
//
// Combine the equation stack with the global one
// (The bottom frame of the equation goes with the top frame of the global one,
// and the remainder are pushed on the global stack, truncated to the
// position where items were poped from it.)
//
Merge: function (stack) {
stack.stack[0].MergeGlobals(this);
this.stack[this.top-1].Merge(stack.stack[0]);
var data = [this.top,this.stack.length-this.top].concat(stack.stack.slice(1));
this.stack.splice.apply(this.stack,data);
this.top = this.stack.length;
},
//
// Put back the temporarily poped items
//
Reset: function () {this.top = this.stack.length},
//
// Clear the stack and start with a blank frame
//
Clear: function (all) {
this.stack = [this.stack[0].Clear()];
this.top = this.stack.length;
}
},{
nsFrame: NSFRAME
});
/****************************************************/
//
// Define the new macros
//
TEXDEF.Add({
macros: {
begingroup: "BeginGroup",
endgroup: "EndGroup",
global: "Global",
gdef: ["Macro","\\global\\def"]
}
},null,true);
TEX.Parse.Augment({
//
// Implement \begingroup
//
BeginGroup: function (name) {
TEX.eqnStack.Push(NSFRAME());
},
//
// Implements \endgroup
//
EndGroup: function (name) {
//
// If the equation has pushed frames, pop one,
// Otherwise clear the equation stack and pop the top global one
//
if (TEX.eqnStack.top > 1) {
TEX.eqnStack.Pop();
} else if (TEX.rootStack.top === 1) {
TEX.Error(["ExtraEndMissingBegin","Extra %1 or missing \\begingroup",name]);
} else {
TEX.eqnStack.Clear();
TEX.rootStack.Pop();
}
},
//
// Replace the original routines with ones that looks through the
// equation and root stacks for the given name
//
csFindMacro: function (name) {
return (TEX.eqnStack.Find(name,"macros") || TEX.rootStack.Find(name,"macros"));
},
envFindName: function (name) {
return (TEX.eqnStack.Find(name,"environments") || TEX.rootStack.Find(name,"environments"));
},
//
// Modify the way macros and environments are defined
// to make them go into the equation namespace stack
//
setDef: function (name,value) {
value.isUser = true;
TEX.eqnStack.Def(name,value,"macros",this.stack.env.isGlobal);
delete this.stack.env.isGlobal;
},
setEnv: function (name,value) {
value.isUser = true;
TEX.eqnStack.Def(name,value,"environments")
},
//
// Implement \global (for \global\let, \global\def and \global\newcommand)
//
Global: function (name) {
var i = this.i; var cs = this.GetCSname(name); this.i = i;
if (cs !== "let" && cs !== "def" && cs !== "newcommand" &&
cs !== "DeclareMathOperator" && cs !== "Newextarrow") {
TEX.Error(["GlobalNotFollowedBy",
"%1 not followed by \\let, \\def, or \\newcommand",name]);
}
this.stack.env.isGlobal = true;
}
});
/****************************************************/
TEX.rootStack = NSSTACK(); // the global namespace stack
TEX.eqnStack = NSSTACK(true); // the equation stack
//
// Reset the global stack and clear the equation stack
// (this gets us back to the initial stack state as it was
// before the equation was first processed, in case the equation
// get restarted due to an autoloaded file)
//
TEX.prefilterHooks.Add(function () {TEX.rootStack.Reset(); TEX.eqnStack.Clear(true)});
//
// We only get here if there were no errors and the equation is fully
// processed (all restarts are complete). So we merge the equation
// stack into the global stack, thus making the changes from this
// equation permanent.
//
TEX.postfilterHooks.Add(function () {TEX.rootStack.Merge(TEX.eqnStack)});
/*********************************************************/
MathJax.Hub.Startup.signal.Post("TeX begingroup Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/begingroup.js");

75
web/assets/MathJax/unpacked/extensions/TeX/boldsymbol.js vendored Normal file
View File

@@ -0,0 +1,75 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/boldsymbol.js
*
* Implements the \boldsymbol{...} command to make bold
* versions of all math characters (not just variables).
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/boldsymbol"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
var BOLDVARIANT = {};
BOLDVARIANT[MML.VARIANT.NORMAL] = MML.VARIANT.BOLD;
BOLDVARIANT[MML.VARIANT.ITALIC] = MML.VARIANT.BOLDITALIC;
BOLDVARIANT[MML.VARIANT.FRAKTUR] = MML.VARIANT.BOLDFRAKTUR;
BOLDVARIANT[MML.VARIANT.SCRIPT] = MML.VARIANT.BOLDSCRIPT;
BOLDVARIANT[MML.VARIANT.SANSSERIF] = MML.VARIANT.BOLDSANSSERIF;
BOLDVARIANT["-tex-caligraphic"] = "-tex-caligraphic-bold";
BOLDVARIANT["-tex-oldstyle"] = "-tex-oldstyle-bold";
TEXDEF.Add({macros: {boldsymbol: 'Boldsymbol'}},null,true);
TEX.Parse.Augment({
mmlToken: function (token) {
if (this.stack.env.boldsymbol) {
var variant = token.Get("mathvariant");
if (variant == null) {token.mathvariant = MML.VARIANT.BOLD}
else {token.mathvariant = (BOLDVARIANT[variant]||variant)}
}
return token;
},
Boldsymbol: function (name) {
var boldsymbol = this.stack.env.boldsymbol,
font = this.stack.env.font;
this.stack.env.boldsymbol = true;
this.stack.env.font = null;
var mml = this.ParseArg(name);
this.stack.env.font = font;
this.stack.env.boldsymbol = boldsymbol;
this.Push(mml);
}
});
MathJax.Hub.Startup.signal.Post("TeX boldsymbol Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/boldsymbol.js");

110
web/assets/MathJax/unpacked/extensions/TeX/cancel.js vendored Normal file
View File

@@ -0,0 +1,110 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/cancel.js
*
* Implements the \cancel, \bcancel, \xcancel, and \cancelto macros.
*
* Usage:
*
* \cancel{math} % strikeout math from lower left to upper right
* \bcancel{math} % strikeout from upper left to lower right
* \xcancel{math} % strikeout with an X
* \cancelto{value}{math} % strikeout with arrow going to value
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/cancel"] = {
version: "2.7.8",
//
// The attributes allowed in \enclose{notation}[attributes]{math}
//
ALLOWED: {
color: 1, mathcolor: 1,
background: 1, mathbackground: 1,
padding: 1,
thickness: 1
}
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml,
CANCEL = MathJax.Extension["TeX/cancel"];
CANCEL.setAttributes = function (def,attr) {
if (attr !== "") {
attr = attr.replace(/ /g,"").split(/,/);
for (var i = 0, m = attr.length; i < m; i++) {
var keyvalue = attr[i].split(/[:=]/);
if (CANCEL.ALLOWED[keyvalue[0]]) {
if (keyvalue[1] === "true") {keyvalue[1] = true}
if (keyvalue[1] === "false") {keyvalue[1] = false}
def[keyvalue[0]] = keyvalue[1];
}
}
}
return def;
};
//
// Set up macros
//
TEX.Definitions.Add({
macros: {
cancel: ['Cancel',MML.NOTATION.UPDIAGONALSTRIKE],
bcancel: ['Cancel',MML.NOTATION.DOWNDIAGONALSTRIKE],
xcancel: ['Cancel',MML.NOTATION.UPDIAGONALSTRIKE+" "+MML.NOTATION.DOWNDIAGONALSTRIKE],
cancelto: 'CancelTo'
}
},null,true);
TEX.Parse.Augment({
//
// Implement \cancel[attributes]{math},
// \bcancel[attributes]{math}, and
// \xcancel[attributes]{math}
//
Cancel: function(name,notation) {
var attr = this.GetBrackets(name,""), math = this.ParseArg(name);
var def = CANCEL.setAttributes({notation: notation},attr);
this.Push(MML.menclose(math).With(def));
},
//
// Implement \cancelto{value}[attributes]{math}
//
CancelTo: function(name,notation) {
var value = this.ParseArg(name),
attr = this.GetBrackets(name,""),
math = this.ParseArg(name);
var def = CANCEL.setAttributes({notation: MML.NOTATION.UPDIAGONALSTRIKE+" "+MML.NOTATION.UPDIAGONALARROW},attr);
value = MML.mpadded(value).With({depth:"-.1em",height:"+.1em",voffset:".1em"});
this.Push(MML.msup(MML.menclose(math).With(def),value));
}
});
MathJax.Hub.Startup.signal.Post("TeX cancel Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/cancel.js");

281
web/assets/MathJax/unpacked/extensions/TeX/color.js vendored Normal file
View File

@@ -0,0 +1,281 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/color.js
*
* Implements LaTeX-compatible \color macro rather than MathJax's original
* (non-standard) version. It includes the rgb, RGB, gray, and named color
* models, and the \textcolor, \definecolor, \colorbox, and \fcolorbox
* macros.
*
* ---------------------------------------------------------------------
*
* 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.
*/
//
// The configuration defaults, augmented by the user settings
//
MathJax.Extension["TeX/color"] = {
version: "2.7.8",
config: MathJax.Hub.CombineConfig("TeX.color",{
padding: "5px",
border: "2px"
}),
colors: {
Apricot: "#FBB982",
Aquamarine: "#00B5BE",
Bittersweet: "#C04F17",
Black: "#221E1F",
Blue: "#2D2F92",
BlueGreen: "#00B3B8",
BlueViolet: "#473992",
BrickRed: "#B6321C",
Brown: "#792500",
BurntOrange: "#F7921D",
CadetBlue: "#74729A",
CarnationPink: "#F282B4",
Cerulean: "#00A2E3",
CornflowerBlue: "#41B0E4",
Cyan: "#00AEEF",
Dandelion: "#FDBC42",
DarkOrchid: "#A4538A",
Emerald: "#00A99D",
ForestGreen: "#009B55",
Fuchsia: "#8C368C",
Goldenrod: "#FFDF42",
Gray: "#949698",
Green: "#00A64F",
GreenYellow: "#DFE674",
JungleGreen: "#00A99A",
Lavender: "#F49EC4",
LimeGreen: "#8DC73E",
Magenta: "#EC008C",
Mahogany: "#A9341F",
Maroon: "#AF3235",
Melon: "#F89E7B",
MidnightBlue: "#006795",
Mulberry: "#A93C93",
NavyBlue: "#006EB8",
OliveGreen: "#3C8031",
Orange: "#F58137",
OrangeRed: "#ED135A",
Orchid: "#AF72B0",
Peach: "#F7965A",
Periwinkle: "#7977B8",
PineGreen: "#008B72",
Plum: "#92268F",
ProcessBlue: "#00B0F0",
Purple: "#99479B",
RawSienna: "#974006",
Red: "#ED1B23",
RedOrange: "#F26035",
RedViolet: "#A1246B",
Rhodamine: "#EF559F",
RoyalBlue: "#0071BC",
RoyalPurple: "#613F99",
RubineRed: "#ED017D",
Salmon: "#F69289",
SeaGreen: "#3FBC9D",
Sepia: "#671800",
SkyBlue: "#46C5DD",
SpringGreen: "#C6DC67",
Tan: "#DA9D76",
TealBlue: "#00AEB3",
Thistle: "#D883B7",
Turquoise: "#00B4CE",
Violet: "#58429B",
VioletRed: "#EF58A0",
White: "#FFFFFF",
WildStrawberry: "#EE2967",
Yellow: "#FFF200",
YellowGreen: "#98CC70",
YellowOrange: "#FAA21A"
},
/*
* Look up a color based on its model and definition
*/
getColor: function (model,def) {
if (!model) {model = "named"}
var fn = this["get_"+model];
if (!fn) {this.TEX.Error(["UndefinedColorModel","Color model '%1' not defined",model])}
return fn.call(this,def);
},
/*
* Get an rgb color
*/
get_rgb: function (rgb) {
rgb = rgb.replace(/^\s+/,"").replace(/\s+$/,"").split(/\s*,\s*/); var RGB = "#";
if (rgb.length !== 3)
{this.TEX.Error(["ModelArg1","Color values for the %1 model require 3 numbers","rgb"])}
for (var i = 0; i < 3; i++) {
if (!rgb[i].match(/^(\d+(\.\d*)?|\.\d+)$/))
{this.TEX.Error(["InvalidDecimalNumber","Invalid decimal number"])}
var n = parseFloat(rgb[i]);
if (n < 0 || n > 1) {
this.TEX.Error(["ModelArg2",
"Color values for the %1 model must be between %2 and %3",
"rgb",0,1]);
}
n = Math.floor(n*255).toString(16); if (n.length < 2) {n = "0"+n}
RGB += n;
}
return RGB;
},
/*
* Get an RGB color
*/
get_RGB: function (rgb) {
rgb = rgb.replace(/^\s+/,"").replace(/\s+$/,"").split(/\s*,\s*/); var RGB = "#";
if (rgb.length !== 3)
{this.TEX.Error(["ModelArg1","Color values for the %1 model require 3 numbers","RGB"])}
for (var i = 0; i < 3; i++) {
if (!rgb[i].match(/^\d+$/))
{this.TEX.Error(["InvalidNumber","Invalid number"])}
var n = parseInt(rgb[i]);
if (n > 255) {
this.TEX.Error(["ModelArg2",
"Color values for the %1 model must be between %2 and %3",
"RGB",0,255]);
}
n = n.toString(16); if (n.length < 2) {n = "0"+n}
RGB += n;
}
return RGB;
},
/*
* Get a gray-scale value
*/
get_gray: function (gray) {
if (!gray.match(/^\s*(\d+(\.\d*)?|\.\d+)\s*$/))
{this.TEX.Error(["InvalidDecimalNumber","Invalid decimal number"])}
var n = parseFloat(gray);
if (n < 0 || n > 1) {
this.TEX.Error(["ModelArg2",
"Color values for the %1 model must be between %2 and %3",
"gray",0,1]);
}
n = Math.floor(n*255).toString(16); if (n.length < 2) {n = "0"+n}
return "#"+n+n+n;
},
/*
* Get a named value
*/
get_named: function (name) {
if (this.colors.hasOwnProperty(name)) {return this.colors[name]}
return name;
},
padding: function () {
var pad = "+"+this.config.padding;
var unit = this.config.padding.replace(/^.*?([a-z]*)$/,"$1");
var pad2 = "+"+(2*parseFloat(pad))+unit;
return {width:pad2, height:pad, depth:pad, lspace:this.config.padding};
}
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml;
var STACKITEM = TEX.Stack.Item;
var COLOR = MathJax.Extension["TeX/color"];
COLOR.TEX = TEX; // for reference in getColor above
TEX.Definitions.Add({
macros: {
color: "Color",
textcolor: "TextColor",
definecolor: "DefineColor",
colorbox: "ColorBox",
fcolorbox: "fColorBox"
}
},null,true);
TEX.Parse.Augment({
//
// Override \color macro definition
//
Color: function (name) {
var model = this.GetBrackets(name),
color = this.GetArgument(name);
color = COLOR.getColor(model,color);
var mml = STACKITEM.style().With({styles:{mathcolor:color}});
this.stack.env.color = color;
this.Push(mml);
},
TextColor: function (name) {
var model = this.GetBrackets(name),
color = this.GetArgument(name);
color = COLOR.getColor(model,color);
var old = this.stack.env.color; this.stack.env.color = color;
var math = this.ParseArg(name);
if (old) {this.stack.env.color} else {delete this.stack.env.color}
this.Push(MML.mstyle(math).With({mathcolor: color}));
},
//
// Define the \definecolor macro
//
DefineColor: function (name) {
var cname = this.GetArgument(name),
model = this.GetArgument(name),
def = this.GetArgument(name);
COLOR.colors[cname] = COLOR.getColor(model,def);
},
//
// Produce a text box with a colored background
//
ColorBox: function (name) {
var cname = this.GetArgument(name),
arg = this.InternalMath(this.GetArgument(name));
this.Push(MML.mpadded.apply(MML,arg).With({
mathbackground:COLOR.getColor("named",cname)
}).With(COLOR.padding()));
},
//
// Procude a framed text box with a colored background
//
fColorBox: function (name) {
var fname = this.GetArgument(name),
cname = this.GetArgument(name),
arg = this.InternalMath(this.GetArgument(name));
this.Push(MML.mpadded.apply(MML,arg).With({
mathbackground: COLOR.getColor("named",cname),
style: "border: "+COLOR.config.border+" solid "+COLOR.getColor("named",fname)
}).With(COLOR.padding()));
}
});
MathJax.Hub.Startup.signal.Post("TeX color Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/color.js");

91
web/assets/MathJax/unpacked/extensions/TeX/enclose.js vendored Normal file
View File

@@ -0,0 +1,91 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/enclose.js
*
* Implements the \enclose macros, which give access from TeX to the
* <menclose> tag in the MathML that underlies MathJax's internal format.
*
* Usage:
*
* \enclose{notation}{math} % enclose math using given notation
* \enclose{notation,notation,...}{math} % enclose with several notations
* \enclose{notation}[attributes]{math} % enclose with attributes
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/enclose"] = {
version: "2.7.8",
//
// The attributes allowed in \enclose{notation}[attributes]{math}
//
ALLOWED: {
arrow: 1,
color: 1, mathcolor: 1,
background: 1, mathbackground: 1,
padding: 1,
thickness: 1
}
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml,
ALLOW = MathJax.Extension["TeX/enclose"].ALLOWED;
//
// Set up macro
//
TEX.Definitions.Add({macros: {enclose: 'Enclose'}},null,true);
TEX.Parse.Augment({
//
// Implement \enclose{notation}[attr]{math}
// (create <menclose notation="notation">math</menclose>)
//
Enclose: function(name) {
var notation = this.GetArgument(name),
attr = this.GetBrackets(name),
math = this.ParseArg(name);
var def = {notation: notation.replace(/,/g," ")};
if (attr) {
attr = attr.replace(/ /g,"").split(/,/);
for (var i = 0, m = attr.length; i < m; i++) {
var keyvalue = attr[i].split(/[:=]/);
if (ALLOW[keyvalue[0]]) {
keyvalue[1] = keyvalue[1].replace(/^"(.*)"$/,"$1");
if (keyvalue[1] === "true") {keyvalue[1] = true}
if (keyvalue[1] === "false") {keyvalue[1] = false}
if (keyvalue[0] === "arrow" && keyvalue[1])
{def.notation = def.notation + " updiagonalarrow"} else
{def[keyvalue[0]] = keyvalue[1]}
}
}
}
this.Push(MML.menclose(math).With(def));
}
});
MathJax.Hub.Startup.signal.Post("TeX enclose Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/enclose.js");

102
web/assets/MathJax/unpacked/extensions/TeX/extpfeil.js vendored Normal file
View File

@@ -0,0 +1,102 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/extpfeil.js
*
* Implements additional stretchy arrow macros.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/extpfeil"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
TEXDEF = TEX.Definitions;
//
// Define the arrows to load the AMSmath extension
// (since they need its xArrow method)
//
TEXDEF.Add({
macros: {
xtwoheadrightarrow: ['Extension','AMSmath'],
xtwoheadleftarrow: ['Extension','AMSmath'],
xmapsto: ['Extension','AMSmath'],
xlongequal: ['Extension','AMSmath'],
xtofrom: ['Extension','AMSmath'],
Newextarrow: ['Extension','AMSmath']
}
},null,true);
//
// Redefine the macros when AMSmath is loaded
//
MathJax.Hub.Register.StartupHook("TeX AMSmath Ready",function () {
MathJax.Hub.Insert(TEXDEF,{
macros: {
xtwoheadrightarrow: ['xArrow',0x21A0,12,16],
xtwoheadleftarrow: ['xArrow',0x219E,17,13],
xmapsto: ['xArrow',0x21A6,6,7],
xlongequal: ['xArrow',0x003D,7,7],
xtofrom: ['xArrow',0x21C4,12,12],
Newextarrow: 'NewExtArrow'
}
});
});
//
// Implements \Newextarrow to define a new arrow (not compatible with \newextarrow, but
// the equivalent for MathJax)
//
TEX.Parse.Augment({
NewExtArrow: function (name) {
var cs = this.GetArgument(name),
space = this.GetArgument(name),
chr = this.GetArgument(name);
if (!cs.match(/^\\([a-z]+|.)$/i)) {
TEX.Error(["NewextarrowArg1",
"First argument to %1 must be a control sequence name",name]);
}
if (!space.match(/^(\d+),(\d+)$/)) {
TEX.Error(
["NewextarrowArg2",
"Second argument to %1 must be two integers separated by a comma",
name]
);
}
if (!chr.match(/^(\d+|0x[0-9A-F]+)$/i)) {
TEX.Error(
["NewextarrowArg3",
"Third argument to %1 must be a unicode character number",
name]
);
}
cs = cs.substr(1); space = space.split(","); chr = parseInt(chr);
this.setDef(cs, ['xArrow', chr, parseInt(space[0]), parseInt(space[1])]);
}
});
MathJax.Hub.Startup.signal.Post("TeX extpfeil Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/extpfeil.js");

107
web/assets/MathJax/unpacked/extensions/TeX/mathchoice.js vendored Normal file
View File

@@ -0,0 +1,107 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/mathchoice.js
*
* Implements the \mathchoice macro (rarely used)
*
* ---------------------------------------------------------------------
*
* 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.Hub.Register.StartupHook("TeX Jax Ready",function () {
var VERSION = "2.7.8";
var MML = MathJax.ElementJax.mml;
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEXDEF.Add({macros: {mathchoice: 'MathChoice'}},null,true);
TEX.Parse.Augment({
MathChoice: function (name) {
var D = this.ParseArg(name),
T = this.ParseArg(name),
S = this.ParseArg(name),
SS = this.ParseArg(name);
this.Push(MML.TeXmathchoice(D,T,S,SS));
}
});
MML.TeXmathchoice = MML.mbase.Subclass({
type: "TeXmathchoice", notParent: true,
choice: function () {
if (this.selection != null) return this.selection;
if (this.choosing) return 2; // prevent infinite loops: see issue #1151
this.choosing = true;
var selection = 0, values = this.getValues("displaystyle","scriptlevel");
if (values.scriptlevel > 0) {selection = Math.min(3,values.scriptlevel+1)}
else {selection = (values.displaystyle ? 0 : 1)}
// only cache the result if we are actually in place in a <math> tag.
var node = this.inherit; while (node && node.type !== "math") node = node.inherit;
if (node) this.selection = selection;
this.choosing = false;
return selection;
},
selected: function () {return this.data[this.choice()]},
setTeXclass: function (prev) {return this.selected().setTeXclass(prev)},
isSpacelike: function () {return this.selected().isSpacelike()},
isEmbellished: function () {return this.selected().isEmbellished()},
Core: function () {return this.selected()},
CoreMO: function () {return this.selected().CoreMO()},
toHTML: function (span) {
span = this.HTMLcreateSpan(span);
span.bbox = this.Core().toHTML(span).bbox;
// Firefox doesn't correctly handle a span with a negatively sized content,
// so move marginLeft to main span (this is a hack to get \iiiint to work).
// FIXME: This is a symptom of a more general problem with Firefox, and
// there probably needs to be a more general solution (e.g., modifying
// HTMLhandleSpace() to get the width and adjust the right margin to
// compensate for negative-width contents)
if (span.firstChild && span.firstChild.style.marginLeft) {
span.style.marginLeft = span.firstChild.style.marginLeft;
span.firstChild.style.marginLeft = "";
}
return span;
},
toSVG: function () {
var svg = this.Core().toSVG();
this.SVGsaveData(svg);
return svg;
},
toCommonHTML: function (node) {
node = this.CHTMLcreateNode(node);
this.CHTMLhandleStyle(node);
this.CHTMLhandleColor(node);
this.CHTMLaddChild(node,this.choice(),{});
return node;
},
toPreviewHTML: function(span) {
span = this.PHTMLcreateSpan(span);
this.PHTMLhandleStyle(span);
this.PHTMLhandleColor(span);
this.PHTMLaddChild(span,this.choice(),{});
return span;
}
});
MathJax.Hub.Startup.signal.Post("TeX mathchoice Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mathchoice.js");

136
web/assets/MathJax/unpacked/extensions/TeX/mediawiki-texvc.js vendored Normal file
View File

@@ -0,0 +1,136 @@
/*************************************************************
*
* MathJax/extensions/TeX/mediawiki-texvc.js
*
* Implements macros used by mediawiki with their texvc preprocessor.
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/mediawiki-texvc"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready", function () {
MathJax.InputJax.TeX.Definitions.Add({
macros: {
AA: ["Macro", "\u00c5"],
alef: ["Macro", "\\aleph"],
alefsym: ["Macro", "\\aleph"],
Alpha: ["Macro", "\\mathrm{A}"],
and: ["Macro", "\\land"],
ang: ["Macro", "\\angle"],
Bbb: ["Macro", "\\mathbb"],
Beta: ["Macro", "\\mathrm{B}"],
bold: ["Macro", "\\mathbf"],
bull: ["Macro", "\\bullet"],
C: ["Macro", "\\mathbb{C}"],
Chi: ["Macro", "\\mathrm{X}"],
clubs: ["Macro", "\\clubsuit"],
cnums: ["Macro", "\\mathbb{C}"],
Complex: ["Macro", "\\mathbb{C}"],
coppa: ["Macro", "\u03D9"],
Coppa: ["Macro", "\u03D8"],
Dagger: ["Macro", "\\ddagger"],
Digamma: ["Macro", "\u03DC"],
darr: ["Macro", "\\downarrow"],
dArr: ["Macro", "\\Downarrow"],
Darr: ["Macro", "\\Downarrow"],
dashint: ["Macro", "\\unicodeInt{x2A0D}"],
ddashint: ["Macro", "\\unicodeInt{x2A0E}"],
diamonds: ["Macro", "\\diamondsuit"],
empty: ["Macro", "\\emptyset"],
Epsilon: ["Macro", "\\mathrm{E}"],
Eta: ["Macro", "\\mathrm{H}"],
euro: ["Macro", "\u20AC"],
exist: ["Macro", "\\exists"],
geneuro: ["Macro", "\u20AC"],
geneuronarrow: ["Macro", "\u20AC"],
geneurowide: ["Macro", "\u20AC"],
H: ["Macro", "\\mathbb{H}"],
hAar: ["Macro", "\\Leftrightarrow"],
harr: ["Macro", "\\leftrightarrow"],
Harr: ["Macro", "\\Leftrightarrow"],
hearts: ["Macro", "\\heartsuit"],
image: ["Macro", "\\Im"],
infin: ["Macro", "\\infty"],
Iota: ["Macro", "\\mathrm{I}"],
isin: ["Macro", "\\in"],
Kappa: ["Macro", "\\mathrm{K}"],
koppa: ["Macro", "\u03DF"],
Koppa: ["Macro", "\u03DE"],
lang: ["Macro", "\\langle"],
larr: ["Macro", "\\leftarrow"],
Larr: ["Macro", "\\Leftarrow"],
lArr: ["Macro", "\\Leftarrow"],
lrarr: ["Macro", "\\leftrightarrow"],
Lrarr: ["Macro", "\\Leftrightarrow"],
lrArr: ["Macro", "\\Leftrightarrow"],
Mu: ["Macro", "\\mathrm{M}"],
N: ["Macro", "\\mathbb{N}"],
natnums: ["Macro", "\\mathbb{N}"],
Nu: ["Macro", "\\mathrm{N}"],
O: ["Macro", "\\emptyset"],
oiint: ["Macro", "\\unicodeInt{x222F}"],
oiiint: ["Macro", "\\unicodeInt{x2230}"],
ointctrclockwise: ["Macro", "\\unicodeInt{x2233}"],
officialeuro: ["Macro", "\u20AC"],
Omicron: ["Macro", "\\mathrm{O}"],
or: ["Macro", "\\lor"],
P: ["Macro", "\u00B6"],
pagecolor: ['Macro','',1], // ignore \pagecolor{}
part: ["Macro", "\\partial"],
plusmn: ["Macro", "\\pm"],
Q: ["Macro", "\\mathbb{Q}"],
R: ["Macro", "\\mathbb{R}"],
rang: ["Macro", "\\rangle"],
rarr: ["Macro", "\\rightarrow"],
Rarr: ["Macro", "\\Rightarrow"],
rArr: ["Macro", "\\Rightarrow"],
real: ["Macro", "\\Re"],
reals: ["Macro", "\\mathbb{R}"],
Reals: ["Macro", "\\mathbb{R}"],
Rho: ["Macro", "\\mathrm{P}"],
sdot: ["Macro", "\\cdot"],
sampi: ["Macro", "\u03E1"],
Sampi: ["Macro", "\u03E0"],
sect: ["Macro", "\\S"],
spades: ["Macro", "\\spadesuit"],
stigma: ["Macro", "\u03DB"],
Stigma: ["Macro", "\u03DA"],
sub: ["Macro", "\\subset"],
sube: ["Macro", "\\subseteq"],
supe: ["Macro", "\\supseteq"],
Tau: ["Macro", "\\mathrm{T}"],
textvisiblespace: ["Macro", "\u2423"],
thetasym: ["Macro", "\\vartheta"],
uarr: ["Macro", "\\uparrow"],
uArr: ["Macro", "\\Uparrow"],
Uarr: ["Macro", "\\Uparrow"],
unicodeInt: ["Macro", "\\mathop{\\vcenter{\\mathchoice{\\huge\\unicode{#1}\\,}{\\unicode{#1}}{\\unicode{#1}}{\\unicode{#1}}}\\,}\\nolimits", 1],
varcoppa: ["Macro", "\u03D9"],
varstigma: ["Macro", "\u03DB"],
varointclockwise: ["Macro", "\\unicodeInt{x2232}"],
vline: ['Macro','\\smash{\\large\\lvert}',0],
weierp: ["Macro", "\\wp"],
Z: ["Macro", "\\mathbb{Z}"],
Zeta: ["Macro", "\\mathrm{Z}"]
}
});
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mediawiki-texvc.js");

520
web/assets/MathJax/unpacked/extensions/TeX/mhchem.js vendored Normal file
View File

@@ -0,0 +1,520 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/mhchem.js
*
* Implements the \ce command for handling chemical formulas
* from the mhchem LaTeX package.
*
* ---------------------------------------------------------------------
*
* 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.
*/
//
// Don't replace [Contrib]/mhchem if it is already loaded
//
if (MathJax.Extension["TeX/mhchem"]) {
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mhchem.js");
} else {
MathJax.Extension["TeX/mhchem"] = {
version: "2.7.8",
config: MathJax.Hub.CombineConfig("TeX.mhchem",{
legacy: true
})
};
//
// Load [mhchem]/mhchem.js if not configured for legacy vesion
//
if (!MathJax.Extension["TeX/mhchem"].config.legacy) {
if (!MathJax.Ajax.config.path.mhchem) {
MathJax.Ajax.config.path.mhchem = MathJax.Hub.config.root + "/extensions/TeX/mhchem3";
}
MathJax.Callback.Queue(
["Require",MathJax.Ajax,"[mhchem]/mhchem.js"],
["loadComplete",MathJax.Ajax,"[MathJax]/extensions/TeX/mhchem.js"]
);
} else {
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX;
/*
* This is the main class for handing the \ce and related commands.
* Its main method is Parse() which takes the argument to \ce and
* returns the corresponding TeX string.
*/
var CE = MathJax.Object.Subclass({
string: "", // the \ce string being parsed
i: 0, // the current position in the string
tex: "", // the partially processed TeX result
TEX: "", // the full TeX result
atom: false, // last processed token is an atom
sup: "", // pending superscript
sub: "", // pending subscript
presup: "", // pending pre-superscript
presub: "", // pending pre-subscript
//
// Store the string when a CE object is created
//
Init: function (string) {this.string = string},
//
// These are the special characters and the methods that
// handle them. All others are passed through verbatim.
//
ParseTable: {
'-': "Minus",
'+': "Plus",
'(': "Open",
')': "Close",
'[': "Open",
']': "Close",
'<': "Less",
'^': "Superscript",
'_': "Subscript",
'*': "Dot",
'.': "Dot",
'=': "Equal",
'#': "Pound",
'$': "Math",
'\\': "Macro",
' ': "Space"
},
//
// Basic arrow names for reactions
//
Arrows: {
'->': "rightarrow",
'<-': "leftarrow",
'<->': "leftrightarrow",
'<=>': "rightleftharpoons",
'<=>>': "Rightleftharpoons",
'<<=>': "Leftrightharpoons",
'^': "uparrow",
'v': "downarrow"
},
//
// Implementations for the various bonds
// (the ~ ones are hacks that don't work well in NativeMML)
//
Bonds: {
'-': "-",
'=': "=",
'#': "\\equiv",
'~': "\\tripledash",
'~-': "\\begin{CEstack}{}\\tripledash\\\\-\\end{CEstack}",
'~=': "\\raise2mu{\\begin{CEstack}{}\\tripledash\\\\-\\\\-\\end{CEstack}}",
'~--': "\\raise2mu{\\begin{CEstack}{}\\tripledash\\\\-\\\\-\\end{CEstack}}",
'-~-': "\\raise2mu{\\begin{CEstack}{}-\\\\\\tripledash\\\\-\\end{CEstack}}",
'...': "{\\cdot}{\\cdot}{\\cdot}",
'....': "{\\cdot}{\\cdot}{\\cdot}{\\cdot}",
'->': "\\rightarrow",
'<-': "\\leftarrow",
'??': "\\text{??}" // unknown bond
},
//
// This converts the CE string to a TeX string.
// It loops through the string and calls the proper
// method depending on the ccurrent character.
//
Parse: function () {
this.tex = ""; this.atom = false;
while (this.i < this.string.length) {
var c = this.string.charAt(this.i);
if (c.match(/[a-z]/i)) {this.ParseLetter()}
else if (c.match(/[0-9]/)) {this.ParseNumber()}
else {this["Parse"+(this.ParseTable[c]||"Other")](c)}
}
this.FinishAtom(true);
return this.TEX;
},
//
// Make an atom name or a down arrow
//
ParseLetter: function () {
this.FinishAtom();
if (this.Match(/^v( |$)/)) {
this.tex += "{\\"+this.Arrows["v"]+"}";
} else {
this.tex += "\\text{"+this.Match(/^[a-z]+/i)+"}";
this.atom = true;
}
},
//
// Make a number or fraction preceding an atom,
// or a subscript for an atom.
//
ParseNumber: function () {
var n = this.Match(/^\d+/);
if (this.atom && !this.sub) {
this.sub = n;
} else {
this.FinishAtom();
var match = this.Match(/^\/\d+/);
if (match) {
var frac = "\\frac{"+n+"}{"+match.substr(1)+"}";
this.tex += "\\mathchoice{\\textstyle"+frac+"}{"+frac+"}{"+frac+"}{"+frac+"}";
} else {
this.tex += n;
if (this.i < this.string.length) {this.tex += "\\,"}
}
}
},
//
// Make a superscript minus, or an arrow, or a single bond.
//
ParseMinus: function (c) {
if (this.atom && (this.i === this.string.length-1 || this.string.charAt(this.i+1) === " ")) {
this.sup += c;
} else {
this.FinishAtom();
if (this.string.substr(this.i,2) === "->") {this.i += 2; this.AddArrow("->"); return}
else {this.tex += "{-}"}
}
this.i++;
},
//
// Make a superscript plus, or pass it through
//
ParsePlus: function (c) {
if (this.atom) {this.sup += c} else {this.FinishAtom(); this.tex += c}
this.i++;
},
//
// Handle dots and double or triple bonds
//
ParseDot: function (c) {this.FinishAtom(); this.tex += "\\cdot "; this.i++},
ParseEqual: function (c) {this.FinishAtom(); this.tex += "{=}"; this.i++},
ParsePound: function (c) {this.FinishAtom(); this.tex += "{\\equiv}"; this.i++},
//
// Look for (v) or (^), or pass it through
//
ParseOpen: function (c) {
this.FinishAtom();
var match = this.Match(/^\([v^]\)/);
if (match) {this.tex += "{\\"+this.Arrows[match.charAt(1)]+"}"}
else {this.tex += "{"+c; this.i++}
},
//
// Allow ) and ] to get super- and subscripts
//
ParseClose: function (c) {this.FinishAtom(); this.atom = true; this.tex += c+"}"; this.i++},
//
// Make the proper arrow
//
ParseLess: function (c) {
this.FinishAtom();
var arrow = this.Match(/^(<->?|<=>>?|<<=>)/);
if (!arrow) {this.tex += c; this.i++} else {this.AddArrow(arrow)}
},
//
// Look for a superscript, or an up arrow
//
ParseSuperscript: function (c) {
c = this.string.charAt(++this.i);
if (c === "{") {
this.i++; var m = this.Find("}");
if (m === "-.") {this.sup += "{-}{\\cdot}"}
else if (m) {this.sup += CE(m).Parse().replace(/^\{-\}/,"-")}
} else if (c === " " || c === "") {
this.tex += "{\\"+this.Arrows["^"]+"}"; this.i++;
} else {
var n = this.Match(/^(\d+|-\.)/);
if (n) {this.sup += n}
}
},
//
// Look for subscripts
//
ParseSubscript: function (c) {
if (this.string.charAt(++this.i) == "{") {
this.i++; this.sub += CE(this.Find("}")).Parse().replace(/^\{-\}/,"-");
} else {
var n = this.Match(/^\d+/);
if (n) {this.sub += n}
}
},
//
// Look for raw TeX code to include
//
ParseMath: function (c) {
this.FinishAtom();
this.i++; this.tex += this.Find(c);
},
//
// Look for specific macros for bonds
// and allow \} to have subscripts
//
ParseMacro: function (c) {
this.FinishAtom();
this.i++; var match = this.Match(/^([a-z]+|.)/i)||" ";
if (match === "sbond") {this.tex += "{-}"}
else if (match === "dbond") {this.tex += "{=}"}
else if (match === "tbond") {this.tex += "{\\equiv}"}
else if (match === "bond") {
var bond = (this.Match(/^\{.*?\}/)||"");
bond = bond.substr(1,bond.length-2);
this.tex += "{"+(this.Bonds[bond]||"\\text{??}")+"}";
}
else if (match === "{") {this.tex += "{\\{"}
else if (match === "}") {this.tex += "\\}}"; this.atom = true}
else {this.tex += c+match}
},
//
// Ignore spaces
//
ParseSpace: function (c) {this.FinishAtom(); this.i++},
//
// Pass anything else on verbatim
//
ParseOther: function (c) {this.FinishAtom(); this.tex += c; this.i++},
//
// Process an arrow (looking for brackets for above and below)
//
AddArrow: function (arrow) {
var c = this.Match(/^[CT]\[/);
if (c) {this.i--; c = c.charAt(0)}
var above = this.GetBracket(c), below = this.GetBracket(c);
arrow = this.Arrows[arrow];
if (above || below) {
if (below) {arrow += "["+below+"]"}
arrow += "{"+above+"}";
arrow = "\\mathrel{\\x"+arrow+"}";
} else {
arrow = "\\long"+arrow+" ";
}
this.tex += arrow;
},
//
// Handle the super and subscripts for an atom
//
FinishAtom: function (force) {
if (this.sup || this.sub || this.presup || this.presub) {
if (!force && !this.atom) {
if (this.tex === "" && !this.sup && !this.sub) return;
if (!this.presup && !this.presub &&
(this.tex === "" || this.tex === "{" ||
(this.tex === "}" && this.TEX.substr(-1) === "{"))) {
this.presup = this.sup, this.presub = this.sub; // save for later
this.sub = this.sup = "";
this.TEX += this.tex; this.tex = "";
return;
}
}
if (this.sub && !this.sup) {this.sup = "\\Space{0pt}{0pt}{.2em}"} // forces subscripts to align properly
if ((this.presup || this.presub) && this.tex !== "{") {
if (!this.presup && !this.sup) {this.presup = "\\Space{0pt}{0pt}{.2em}"}
this.tex = "\\CEprescripts{"+(this.presub||"\\CEnone")+"}{"+(this.presup||"\\CEnone")+"}"
+ "{"+(this.tex !== "}" ? this.tex : "")+"}"
+ "{"+(this.sub||"\\CEnone")+"}{"+(this.sup||"\\CEnone")+"}"
+ (this.tex === "}" ? "}" : "");
this.presub = this.presup = "";
} else {
if (this.sup) this.tex += "^{"+this.sup+"}";
if (this.sub) this.tex += "_{"+this.sub+"}";
}
this.sup = this.sub = "";
}
this.TEX += this.tex; this.tex = "";
this.atom = false;
},
//
// Find a bracket group and handle C and T prefixes
//
GetBracket: function (c) {
if (this.string.charAt(this.i) !== "[") {return ""}
this.i++; var bracket = this.Find("]");
if (c === "C") {bracket = "\\ce{"+bracket+"}"} else
if (c === "T") {
if (!bracket.match(/^\{.*\}$/)) {bracket = "{"+bracket+"}"}
bracket = "\\text"+bracket;
};
return bracket;
},
//
// Check if the string matches a regular expression
// and move past it if so, returning the match
//
Match: function (regex) {
var match = regex.exec(this.string.substr(this.i));
if (match) {match = match[0]; this.i += match.length}
return match;
},
//
// Find a particular character, skipping over braced groups
//
Find: function (c) {
var m = this.string.length, i = this.i, braces = 0;
while (this.i < m) {
var C = this.string.charAt(this.i++);
if (C === c && braces === 0) {return this.string.substr(i,this.i-i-1)}
if (C === "{") {braces++} else
if (C === "}") {
if (braces) {braces--}
else {
TEX.Error(["ExtraCloseMissingOpen","Extra close brace or missing open brace"])
}
}
}
if (braces) {TEX.Error(["MissingCloseBrace","Missing close brace"])}
TEX.Error(["NoClosingChar","Can't find closing %1",c]);
}
});
MathJax.Extension["TeX/mhchem"].CE = CE;
/***************************************************************************/
TEX.Definitions.Add({
macros: {
//
// Set up the macros for chemistry
//
ce: 'CE',
cf: 'CE',
cee: 'CE',
//
// Make these load AMSmath package (redefined below when loaded)
//
xleftrightarrow: ['Extension','AMSmath'],
xrightleftharpoons: ['Extension','AMSmath'],
xRightleftharpoons: ['Extension','AMSmath'],
xLeftrightharpoons: ['Extension','AMSmath'],
// FIXME: These don't work well in FF NativeMML mode
longrightleftharpoons: ["Macro","\\stackrel{\\textstyle{{-}\\!\\!{\\rightharpoonup}}}{\\smash{{\\leftharpoondown}\\!\\!{-}}}"],
longRightleftharpoons: ["Macro","\\stackrel{\\textstyle{-}\\!\\!{\\rightharpoonup}}{\\small\\smash\\leftharpoondown}"],
longLeftrightharpoons: ["Macro","\\stackrel{\\rightharpoonup}{{{\\leftharpoondown}\\!\\!\\textstyle{-}}}"],
//
// Add \hyphen used in some mhchem examples
//
hyphen: ["Macro","\\text{-}"],
//
// Handle prescripts and none
//
CEprescripts: "CEprescripts",
CEnone: "CEnone",
//
// Needed for \bond for the ~ forms
//
tripledash: ["Macro","\\raise3mu{\\tiny\\text{-}\\kern2mu\\text{-}\\kern2mu\\text{-}}"]
},
//
// Needed for \bond for the ~ forms
//
environment: {
CEstack: ['Array',null,null,null,'r',null,"0.001em",'T',1]
}
},null,true);
if (!MathJax.Extension["TeX/AMSmath"]) {
TEX.Definitions.Add({
macros: {
xrightarrow: ['Extension','AMSmath'],
xleftarrow: ['Extension','AMSmath']
}
},null,true);
}
//
// These arrows need to wait until AMSmath is loaded
//
MathJax.Hub.Register.StartupHook("TeX AMSmath Ready",function () {
TEX.Definitions.Add({
macros: {
//
// Some of these are hacks for now
//
xleftrightarrow: ['xArrow',0x2194,6,6],
xrightleftharpoons: ['xArrow',0x21CC,5,7], // FIXME: doesn't stretch in HTML-CSS output
xRightleftharpoons: ['xArrow',0x21CC,5,7], // FIXME: how should this be handled?
xLeftrightharpoons: ['xArrow',0x21CC,5,7]
}
},null,true);
});
TEX.Parse.Augment({
//
// Implements \ce and friends
//
CE: function (name) {
var arg = this.GetArgument(name);
var tex = CE(arg).Parse();
this.string = tex + this.string.substr(this.i); this.i = 0;
},
//
// Implements \CEprescripts{presub}{presup}{base}{sub}{sup}
//
CEprescripts: function (name) {
var presub = this.ParseArg(name),
presup = this.ParseArg(name),
base = this.ParseArg(name),
sub = this.ParseArg(name),
sup = this.ParseArg(name);
var MML = MathJax.ElementJax.mml;
this.Push(MML.mmultiscripts(base,sub,sup,MML.mprescripts(),presub,presup));
},
CEnone: function (name) {
this.Push(MathJax.ElementJax.mml.none());
}
});
//
// Indicate that the extension is ready
//
MathJax.Hub.Startup.signal.Post("TeX mhchem Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mhchem.js");
}}

1774
web/assets/MathJax/unpacked/extensions/TeX/mhchem3/mhchem.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

270
web/assets/MathJax/unpacked/extensions/TeX/newcommand.js vendored Normal file
View File

@@ -0,0 +1,270 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/newcommand.js
*
* Implements the \newcommand, \newenvironment and \def
* macros, and is loaded automatically 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.Extension["TeX/newcommand"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEXDEF.Add({
macros: {
newcommand: 'NewCommand',
renewcommand: 'NewCommand',
newenvironment: 'NewEnvironment',
renewenvironment: 'NewEnvironment',
def: 'MacroDef',
'let': 'Let'
}
},null,true);
TEX.Parse.Augment({
/*
* Implement \newcommand{\name}[n][default]{...}
*/
NewCommand: function (name) {
var cs = this.trimSpaces(this.GetArgument(name)),
n = this.GetBrackets(name),
opt = this.GetBrackets(name),
def = this.GetArgument(name);
if (cs.charAt(0) === "\\") {cs = cs.substr(1)}
if (!cs.match(/^(.|[a-z]+)$/i)) {
TEX.Error(["IllegalControlSequenceName",
"Illegal control sequence name for %1",name]);
}
if (n) {
n = this.trimSpaces(n);
if (!n.match(/^[0-9]+$/)) {
TEX.Error(["IllegalParamNumber",
"Illegal number of parameters specified in %1",name]);
}
}
this.setDef(cs,['Macro',def,n,opt]);
},
/*
* Implement \newenvironment{name}[n][default]{begincmd}{endcmd}
*/
NewEnvironment: function (name) {
var env = this.trimSpaces(this.GetArgument(name)),
n = this.GetBrackets(name),
opt = this.GetBrackets(name),
bdef = this.GetArgument(name),
edef = this.GetArgument(name);
if (n) {
n = this.trimSpaces(n);
if (!n.match(/^[0-9]+$/)) {
TEX.Error(["IllegalParamNumber",
"Illegal number of parameters specified in %1",name]);
}
}
this.setEnv(env,['BeginEnv',[null,'EndEnv'],bdef,edef,n,opt]);
},
/*
* Implement \def command
*/
MacroDef: function (name) {
var cs = this.GetCSname(name),
params = this.GetTemplate(name,"\\"+cs),
def = this.GetArgument(name);
if (!(params instanceof Array)) {this.setDef(cs,['Macro',def,params])}
else {this.setDef(cs,['MacroWithTemplate',def].concat(params))}
},
/*
* Implements the \let command
*/
Let: function (name) {
var cs = this.GetCSname(name), macro;
var c = this.GetNext(); if (c === "=") {this.i++; c = this.GetNext()}
//
// All \let commands create entries in the macros array, but we
// have to look in the various mathchar and delimiter arrays if
// the source isn't a macro already, and attach the data to a
// macro with the proper routine to process it.
//
// A command of the form \let\cs=char produces a macro equivalent
// to \def\cs{char}, which is as close as MathJax can get for this.
// So \let\bgroup={ is possible, but doesn't work as it does in TeX.
//
if (c === "\\") {
name = this.GetCSname(name);
macro = this.csFindMacro(name);
if (!macro) {
if (TEXDEF.mathchar0mi.hasOwnProperty(name)) {macro = ["csMathchar0mi",TEXDEF.mathchar0mi[name]]} else
if (TEXDEF.mathchar0mo.hasOwnProperty(name)) {macro = ["csMathchar0mo",TEXDEF.mathchar0mo[name]]} else
if (TEXDEF.mathchar7.hasOwnProperty(name)) {macro = ["csMathchar7",TEXDEF.mathchar7[name]]} else
if (TEXDEF.delimiter.hasOwnProperty("\\"+name)) {macro = ["csDelimiter",TEXDEF.delimiter["\\"+name]]} else
return;
}
} else {macro = ["Macro",c]; this.i++}
this.setDef(cs,macro);
},
/*
* Get a CS name or give an error
*/
GetCSname: function (cmd) {
var c = this.GetNext();
if (c !== "\\") {
TEX.Error(["MissingCS",
"%1 must be followed by a control sequence", cmd])
}
var cs = this.trimSpaces(this.GetArgument(cmd));
return cs.substr(1);
},
/*
* Get a \def parameter template
*/
GetTemplate: function (cmd,cs) {
var c, params = [], n = 0;
c = this.GetNext(); var i = this.i;
while (this.i < this.string.length) {
c = this.GetNext();
if (c === '#') {
if (i !== this.i) {params[n] = this.string.substr(i,this.i-i)}
c = this.string.charAt(++this.i);
if (!c.match(/^[1-9]$/)) {
TEX.Error(["CantUseHash2",
"Illegal use of # in template for %1",cs]);
}
if (parseInt(c) != ++n) {
TEX.Error(["SequentialParam",
"Parameters for %1 must be numbered sequentially",cs]);
}
i = this.i+1;
} else if (c === '{') {
if (i !== this.i) {params[n] = this.string.substr(i,this.i-i)}
if (params.length > 0) {return [n,params]} else {return n}
}
this.i++;
}
TEX.Error(["MissingReplacementString",
"Missing replacement string for definition of %1",cmd]);
},
/*
* Process a macro with a parameter template
*/
MacroWithTemplate: function (name,text,n,params) {
if (n) {
var args = []; this.GetNext();
if (params[0] && !this.MatchParam(params[0])) {
TEX.Error(["MismatchUseDef",
"Use of %1 doesn't match its definition",name]);
}
for (var i = 0; i < n; i++) {args.push(this.GetParameter(name,params[i+1]))}
text = this.SubstituteArgs(args,text);
}
this.string = this.AddArgs(text,this.string.slice(this.i));
this.i = 0;
if (++this.macroCount > TEX.config.MAXMACROS) {
TEX.Error(["MaxMacroSub1",
"MathJax maximum macro substitution count exceeded; " +
"is there a recursive macro call?"]);
}
},
/*
* Process a user-defined environment
*/
BeginEnv: function (begin,bdef,edef,n,def) {
if (n) {
var args = [];
if (def != null) {
var optional = this.GetBrackets("\\begin{"+name+"}");
args.push(optional == null ? def : optional);
}
for (var i = args.length; i < n; i++) {args.push(this.GetArgument("\\begin{"+name+"}"))}
bdef = this.SubstituteArgs(args,bdef);
edef = this.SubstituteArgs([],edef); // no args, but get errors for #n in edef
}
this.string = this.AddArgs(bdef,this.string.slice(this.i)); this.i = 0;
return begin;
},
EndEnv: function (begin,bdef,edef,n) {
var end = "\\end{\\end\\"+begin.name+"}"; // special version of \end for after edef
this.string = this.AddArgs(edef,end+this.string.slice(this.i)); this.i = 0;
return null;
},
/*
* Find a single parameter delimited by a trailing template
*/
GetParameter: function (name,param) {
if (param == null) {return this.GetArgument(name)}
var i = this.i, j = 0, hasBraces = 0;
while (this.i < this.string.length) {
var c = this.string.charAt(this.i);
if (c === '{') {
if (this.i === i) {hasBraces = 1}
this.GetArgument(name); j = this.i - i;
} else if (this.MatchParam(param)) {
if (hasBraces) {i++; j -= 2}
return this.string.substr(i,j);
} else if (c === "\\") {
this.i++; j++; hasBraces = 0;
var match = this.string.substr(this.i).match(/[a-z]+|./i);
if (match) {this.i += match[0].length; j = this.i - i}
} else {
this.i++; j++; hasBraces = 0;
}
}
TEX.Error(["RunawayArgument","Runaway argument for %1?",name]);
},
/*
* Check if a template is at the current location.
* (The match must be exact, with no spacing differences. TeX is
* a little more forgiving than this about spaces after macro names)
*/
MatchParam: function (param) {
if (this.string.substr(this.i,param.length) !== param) {return 0}
if (param.match(/\\[a-z]+$/i) &&
this.string.charAt(this.i+param.length).match(/[a-z]/i)) {return 0}
this.i += param.length;
return 1;
}
});
TEX.Environment = function (name) {
TEXDEF.environment[name] = ['BeginEnv',[null,'EndEnv']].concat([].slice.call(arguments,1));
TEXDEF.environment[name].isUser = true;
}
MathJax.Hub.Startup.signal.Post("TeX newcommand Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/newcommand.js");

405
web/assets/MathJax/unpacked/extensions/TeX/noErrors.js vendored Normal file
View File

@@ -0,0 +1,405 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/noErrors.js
*
* Prevents the TeX error messages from being displayed and shows the
* original TeX code instead. You can configure whether the dollar signs
* are shown or not for in-line math, and whether to put all the TeX on
* one line or use multiple-lines.
*
* To configure this extension, use
*
* MathJax.Hub.Config({
* TeX: {
* noErrors: {
* inlineDelimiters: ["",""], // or ["$","$"] or ["\\(","\\)"]
* multiLine: true, // false for TeX on all one line
* style: {
* "font-size": "90%",
* "text-align": "left",
* "color": "black",
* "padding": "1px 3px",
* "border": "1px solid"
* // add any additional CSS styles that you want
* // (be sure there is no extra comma at the end of the last item)
* }
* }
* }
* });
*
* Display-style math is always shown in multi-line format, and without
* delimiters, as it will already be set off in its own centered
* paragraph, like standard display mathematics.
*
* The default settings place the invalid TeX in a multi-line box with a
* black border. If you want it to look as though the TeX is just part of
* the paragraph, use
*
* MathJax.Hub.Config({
* TeX: {
* noErrors: {
* inlineDelimiters: ["$","$"], // or ["",""] or ["\\(","\\)"]
* multiLine: false,
* style: {
* "font-size": "normal",
* "border": ""
* }
* }
* }
* });
*
* You may also wish to set the font family, as the default is "serif"
*
* ---------------------------------------------------------------------
*
* 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 (HUB,HTML) {
var VERSION = "2.7.8";
var CONFIG = HUB.CombineConfig("TeX.noErrors",{
disabled: false, // set to true to return to original error messages
multiLine: true,
inlineDelimiters: ["",""], // or use ["$","$"] or ["\\(","\\)"]
style: {
"font-size": "90%",
"text-align": "left",
"color": "black",
"padding": "1px 3px",
"border": "1px solid"
}
});
var NBSP = "\u00A0";
//
// The configuration defaults, augmented by the user settings
//
MathJax.Extension["TeX/noErrors"] = {
version: VERSION,
config: CONFIG
};
HUB.Register.StartupHook("TeX Jax Ready",function () {
var FORMAT = MathJax.InputJax.TeX.formatError;
MathJax.InputJax.TeX.Augment({
//
// Make error messages be the original TeX code
// Mark them as errors and multi-line or not, and for
// multi-line TeX, make spaces non-breakable (to get formatting right)
//
formatError: function (err,math,displaystyle,script) {
if (CONFIG.disabled) {return FORMAT.apply(this,arguments)}
var message = err.message.replace(/\n.*/,"");
HUB.signal.Post(["TeX Jax - parse error",message,math,displaystyle,script]);
var delim = CONFIG.inlineDelimiters;
var multiLine = (displaystyle || CONFIG.multiLine);
if (!displaystyle) {math = delim[0] + math + delim[1]}
if (multiLine) {math = math.replace(/ /g,NBSP)} else {math = math.replace(/\n/g," ")}
return MathJax.ElementJax.mml.merror(math).With({isError:true, multiLine: multiLine});
}
});
});
/*******************************************************************
*
* Fix HTML-CSS output
*/
HUB.Register.StartupHook("HTML-CSS Jax Config",function () {
HUB.Config({
"HTML-CSS": {
styles: {
".MathJax .noError": HUB.Insert({
"vertical-align": (HUB.Browser.isMSIE && CONFIG.multiLine ? "-2px" : "")
},CONFIG.style)
}
}
});
});
HUB.Register.StartupHook("HTML-CSS Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
var MATH = MML.math.prototype.toHTML,
MERROR = MML.merror.prototype.toHTML;
//
// Override math toHTML routine so that error messages
// don't have the clipping and other unneeded overhead
//
MML.math.Augment({
toHTML: function (span,node) {
var data = this.data[0];
if (data && data.data[0] && data.data[0].isError) {
span.style.fontSize = "";
span = this.HTMLcreateSpan(span);
span.bbox = data.data[0].toHTML(span).bbox;
} else {
span = MATH.apply(this,arguments);
}
return span;
}
});
//
// Override merror toHTML routine so that it puts out the
// TeX code in an inline-block with line breaks as in the original
//
MML.merror.Augment({
toHTML: function (span) {
if (!this.isError) {return MERROR.apply(this,arguments)}
span = this.HTMLcreateSpan(span); span.className = "noError"
if (this.multiLine) {span.style.display = "inline-block"}
var text = this.data[0].data[0].data.join("").split(/\n/);
for (var i = 0, m = text.length; i < m; i++) {
HTMLCSS.addText(span,text[i]);
if (i !== m-1) {HTMLCSS.addElement(span,"br",{isMathJax:true})}
}
var HD = HTMLCSS.getHD(span.parentNode), W = HTMLCSS.getW(span.parentNode);
if (m > 1) {
var H = (HD.h + HD.d)/2, x = HTMLCSS.TeX.x_height/2;
span.parentNode.style.verticalAlign = HTMLCSS.Em(HD.d+(x-H));
HD.h = x + H; HD.d = H - x;
}
span.bbox = {h: HD.h, d: HD.d, w: W, lw: 0, rw: W};
return span;
}
});
});
/*******************************************************************
*
* Fix SVG output
*/
HUB.Register.StartupHook("SVG Jax Config",function () {
HUB.Config({
"SVG": {
styles: {
".MathJax_SVG .noError": HUB.Insert({
"vertical-align": (HUB.Browser.isMSIE && CONFIG.multiLine ? "-2px" : "")
},CONFIG.style)
}
}
});
});
HUB.Register.StartupHook("SVG Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var MATH = MML.math.prototype.toSVG,
MERROR = MML.merror.prototype.toSVG;
//
// Override math toSVG routine so that error messages
// don't have the clipping and other unneeded overhead
//
MML.math.Augment({
toSVG: function (span,node) {
var data = this.data[0];
if (data && data.data[0] && data.data[0].isError)
{span = data.data[0].toSVG(span)} else {span = MATH.apply(this,arguments)}
return span;
}
});
//
// Override merror toSVG routine so that it puts out the
// TeX code in an inline-block with line breaks as in the original
//
MML.merror.Augment({
toSVG: function (span) {
if (!this.isError || this.Parent().type !== "math") {return MERROR.apply(this,arguments)}
span = HTML.addElement(span,"span",{className: "noError", isMathJax:true});
if (this.multiLine) {span.style.display = "inline-block"}
var text = this.data[0].data[0].data.join("").split(/\n/);
for (var i = 0, m = text.length; i < m; i++) {
HTML.addText(span,text[i]);
if (i !== m-1) {HTML.addElement(span,"br",{isMathJax:true})}
}
if (m > 1) {
var H = span.offsetHeight/2;
span.style.verticalAlign = (-H+(H/m))+"px";
}
return span;
}
});
});
/*******************************************************************
*
* Fix NativeMML output
*/
HUB.Register.StartupHook("NativeMML Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var CONFIG = MathJax.Extension["TeX/noErrors"].config;
var MATH = MML.math.prototype.toNativeMML,
MERROR = MML.merror.prototype.toNativeMML;
//
// Override math toNativeMML routine so that error messages
// don't get placed inside math tags.
//
MML.math.Augment({
toNativeMML: function (span) {
var data = this.data[0];
if (data && data.data[0] && data.data[0].isError)
{span = data.data[0].toNativeMML(span)} else {span = MATH.apply(this,arguments)}
return span;
}
});
//
// Override merror toNativeMML routine so that it puts out the
// TeX code in an inline-block with line breaks as in the original
//
MML.merror.Augment({
toNativeMML: function (span) {
if (!this.isError) {return MERROR.apply(this,arguments)}
span = span.appendChild(document.createElement("span"));
var text = this.data[0].data[0].data.join("").split(/\n/);
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"))}
}
if (this.multiLine) {
span.style.display = "inline-block";
if (m > 1) {span.style.verticalAlign = "middle"}
}
for (var id in CONFIG.style) {if (CONFIG.style.hasOwnProperty(id)) {
var ID = id.replace(/-./g,function (c) {return c.charAt(1).toUpperCase()});
span.style[ID] = CONFIG.style[id];
}}
return span;
}
});
});
/*******************************************************************
*
* Fix PreviewHTML output
*/
HUB.Register.StartupHook("PreviewHTML Jax Config",function () {
HUB.Config({
PreviewHTML: {
styles: {
".MathJax_PHTML .noError": HUB.Insert({
"vertical-align": (HUB.Browser.isMSIE && CONFIG.multiLine ? "-2px" : "")
},CONFIG.style)
}
}
});
});
HUB.Register.StartupHook("PreviewHTML Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var HTML = MathJax.HTML;
var MERROR = MML.merror.prototype.toPreviewHTML;
//
// Override merror toPreviewHTML routine so that it puts out the
// TeX code in an inline-block with line breaks as in the original
//
MML.merror.Augment({
toPreviewHTML: function (span) {
if (!this.isError) return MERROR.apply(this,arguments);
span = this.PHTMLcreateSpan(span); span.className = "noError"
if (this.multiLine) span.style.display = "inline-block";
var text = this.data[0].data[0].data.join("").split(/\n/);
for (var i = 0, m = text.length; i < m; i++) {
HTML.addText(span,text[i]);
if (i !== m-1) {HTML.addElement(span,"br",{isMathJax:true})}
}
return span;
}
});
});
/*******************************************************************
*
* Fix CommonHTML output
*/
HUB.Register.StartupHook("CommonHTML Jax Config",function () {
HUB.Config({
CommonHTML: {
styles: {
".mjx-chtml .mjx-noError": HUB.Insert({
"line-height": 1.2,
"vertical-align": (HUB.Browser.isMSIE && CONFIG.multiLine ? "-2px" : "")
},CONFIG.style)
}
}
});
});
HUB.Register.StartupHook("CommonHTML Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var CHTML = MathJax.OutputJax.CommonHTML;
var HTML = MathJax.HTML;
var MERROR = MML.merror.prototype.toCommonHTML;
//
// Override merror toCommonHTML routine so that it puts out the
// TeX code in an inline-block with line breaks as in the original
//
MML.merror.Augment({
toCommonHTML: function (node) {
if (!this.isError) return MERROR.apply(this,arguments);
node = CHTML.addElement(node,"mjx-noError");
var text = this.data[0].data[0].data.join("").split(/\n/);
for (var i = 0, m = text.length; i < m; i++) {
HTML.addText(node,text[i]);
if (i !== m-1) {CHTML.addElement(node,"br",{isMathJax:true})}
}
var bbox = this.CHTML = CHTML.BBOX.zero();
bbox.w = (node.offsetWidth)/CHTML.em;
if (m > 1) {
var H2 = 1.2*m/2;
bbox.h = H2+.25; bbox.d = H2-.25;
node.style.verticalAlign = CHTML.Em(.45-H2);
} else {
bbox.h = 1; bbox.d = .2 + 2/CHTML.em;
}
return node;
}
});
});
/*******************************************************************/
HUB.Startup.signal.Post("TeX noErrors Ready");
})(MathJax.Hub,MathJax.HTML);
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/noErrors.js");

72
web/assets/MathJax/unpacked/extensions/TeX/noUndefined.js vendored Normal file
View File

@@ -0,0 +1,72 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/noUndefined.js
*
* This causes undefined control sequences to be shown as their macro
* names rather than producing an error message. So $X_{\xxx}$ would
* display as an X with a subscript consiting of the text "\xxx".
*
* To configure this extension, use for example
*
* MathJax.Hub.Config({
* TeX: {
* noUndefined: {
* attributes: {
* mathcolor: "red",
* mathbackground: "#FFEEEE",
* mathsize: "90%"
* }
* }
* }
* });
*
* ---------------------------------------------------------------------
*
* 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.
*/
//
// The configuration defaults, augmented by the user settings
//
MathJax.Extension["TeX/noUndefined"] = {
version: "2.7.8",
config: MathJax.Hub.CombineConfig("TeX.noUndefined",{
disabled: false, // set to true to return to original error messages
attributes: {
mathcolor: "red"
}
})
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var CONFIG = MathJax.Extension["TeX/noUndefined"].config;
var MML = MathJax.ElementJax.mml;
var UNDEFINED = MathJax.InputJax.TeX.Parse.prototype.csUndefined;
MathJax.InputJax.TeX.Parse.Augment({
csUndefined: function (name) {
if (CONFIG.disabled) {return UNDEFINED.apply(this,arguments)}
MathJax.Hub.signal.Post(["TeX Jax - undefined control sequence",name]);
this.Push(MML.mtext(name).With(CONFIG.attributes));
}
});
MathJax.Hub.Startup.signal.Post("TeX noUndefined Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/noUndefined.js");

487
web/assets/MathJax/unpacked/extensions/TeX/text-macros.js vendored Normal file
View File

@@ -0,0 +1,487 @@
/*************************************************************
*
* MathJax/extensions/TeX/text-macros.js
*
* Implements the processing of some text-mode macros inside
* \text{} and other text boxes.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2018-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.Extension["TeX/text-macros"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready", function () {
var MML = MathJax.ElementJax.mml;
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEX.Parse.Augment({
//
// Replace InternalMath with parser that handles some text macros
//
InternalMath: function(text,level) {
var mml = TextParser(text, {}).Parse();
if (level != null) {
mml = [MML.mstyle.apply(MML,mml).With({displaystyle:false, scriptlevel:level})];
} else if (mml.length > 1) {
mml = [MML.mrow.apply(MML,mml)];
}
return mml;
},
//
// Correctly skip newline as well as comment
//
Comment: function (c) {
while (this.i < this.string.length && this.string.charAt(this.i) != "\n") {this.i++}
this.i++;
},
//
// Correctly skip trailing space as well
//
GetCS: function () {
var CS = this.string.slice(this.i).match(/^([a-z]+|.) ?/i);
if (CS) {this.i += CS[0].length; return CS[1]} else {this.i++; return " "}
}
});
//
// The text parser is a subclass of the math parser, so we can use
// some of the existing methods (like GetArgument()), and some of the
// control sequence implementations (like Macro, Spacer, etc.)
//
var TextParser = TEX.TextParser = TEX.Parse.Subclass({
Init: function (text, env) {
this.env = MathJax.Hub.Insert({},env);
this.stack = {env: this.env};
this.string = text;
this.i = 0;
this.mml = []; // the accumulated MathML elements
this.text = ''; // the accumulated text so far
},
//
// These are the special characters in text mode
//
textSpecial: {
'\\': 'ControlSequence',
'$': 'Math',
'%': 'Comment',
'^': 'MathModeOnly',
'_': 'MathModeOnly',
'&': 'Misplaced',
'#': 'Misplaced',
'~': 'Tilde',
' ': 'Space',
'\t': 'Space',
'\r': 'Space',
'\n': 'Space',
'\u00A0': 'Tilde',
'{': 'OpenBrace',
'}': 'CloseBrace',
'`': 'OpenQuote',
"'": 'CloseQuote'
},
//
// These are text-mode macros we support
//
textMacros: {
'(': 'Math',
'$': 'SelfQuote',
'_': 'SelfQuote',
'%': 'SelfQuote',
'{': 'SelfQuote',
'}': 'SelfQuote',
' ': 'SelfQuote',
'&': 'SelfQuote',
'#': 'SelfQuote',
'\\': 'SelfQuote',
"'": ['Accent', '\u00B4'],
'`': ['Accent', '\u0060'],
'^': ['Accent', '^'],
'"': ['Accent', '\u00A8'],
'~': ['Accent', '~'],
'=': ['Accent', '\u00AF'],
'.': ['Accent', '\u02D9'],
'u': ['Accent', '\u02D8'],
'v': ['Accent', '\u02C7'],
emph: 'Emph',
rm: ['SetFont',MML.VARIANT.NORMAL],
mit: ['SetFont',MML.VARIANT.ITALIC],
oldstyle: ['SetFont',MML.VARIANT.OLDSTYLE],
cal: ['SetFont',MML.VARIANT.CALIGRAPHIC],
it: ['SetFont','-tex-mathit'], // needs special handling
bf: ['SetFont',MML.VARIANT.BOLD],
bbFont: ['SetFont',MML.VARIANT.DOUBLESTRUCK],
scr: ['SetFont',MML.VARIANT.SCRIPT],
frak: ['SetFont',MML.VARIANT.FRAKTUR],
sf: ['SetFont',MML.VARIANT.SANSSERIF],
tt: ['SetFont',MML.VARIANT.MONOSPACE],
tiny: ['SetSize',0.5],
Tiny: ['SetSize',0.6], // non-standard
scriptsize: ['SetSize',0.7],
small: ['SetSize',0.85],
normalsize: ['SetSize',1.0],
large: ['SetSize',1.2],
Large: ['SetSize',1.44],
LARGE: ['SetSize',1.73],
huge: ['SetSize',2.07],
Huge: ['SetSize',2.49],
mathcal: 'MathModeOnly',
mathscr: 'MathModeOnly',
mathrm: 'MathModeOnly',
mathbf: 'MathModeOnly',
mathbb: 'MathModeOnly',
mathit: 'MathModeOnly',
mathfrak: 'MathModeOnly',
mathsf: 'MathModeOnly',
mathtt: 'MathModeOnly',
Bbb: ['Macro','{\\bbFont #1}',1],
textrm: ['Macro','{\\rm #1}',1],
textit: ['Macro','{\\it #1}',1],
textbf: ['Macro','{\\bf #1}',1],
textsf: ['Macro','{\\sf #1}',1],
texttt: ['Macro','{\\tt #1}',1],
dagger: ['Insert', '\u2020'],
ddagger: ['Insert', '\u2021'],
S: ['Insert', '\u00A7']
},
//
// These are the original macros that are allowed in text mode
//
useMathMacros: {
',': true,
':': true,
'>': true,
';': true,
'!': true,
enspace: true,
quad: true,
qquad: true,
thinspace: true,
negthinspace: true,
hskip: true,
hspace: true,
kern: true,
mskip: true,
mspace: true,
mkern: true,
rule: true,
Rule: true,
Space: true,
color: true,
href: true,
unicode: true,
ref: true,
eqref: true
},
//
// Look through the text for special characters and process them.
// Save any accumulated text aat the end and return the MathML
// elements produced.
//
Parse: function () {
var c;
while ((c = this.string.charAt(this.i++))) {
if (this.textSpecial.hasOwnProperty(c)) {
this[this.textSpecial[c]](c);
} else {
this.text += c;
}
}
this.SaveText();
return this.mml;
},
//
// Handle a control sequence name
// If it is a text-mode macro, use it.
// Otherwise look for it in the math-mode lists
// Report an error if it is not there
// Otherwise check if it is a macro or one of the allowed control sequences
// Run the macro (with arguments if given)
//
ControlSequence: function (c) {
var cs = this.GetCS(), name = c + cs, cmd;
if (this.textMacros.hasOwnProperty(cs)) {
cmd = this.textMacros[cs];
} else {
cmd = this.LookupCS(cs);
if (!cmd) {
this.Error(["UndefinedControlSequence","Undefined control sequence %1",name]);
}
if ((!(cmd instanceof Array) || cmd[0] !== 'Macro') &&
!this.useMathMacros.hasOwnProperty(cs)) {
this.Error(["MathMacro","'%1' is only supported in math mode",name]);
}
}
if (cmd instanceof Array) {
if (!this.hasOwnProperty[cmd[0]]) this.SaveText();
this[cmd[0]].apply(this,[name].concat(cmd.slice(1)));
} else {
if (!this.hasOwnProperty[cmd]) this.SaveText();
this[cmd].call(this,name);
}
},
//
// Lookup the CS as a math-mode macro
//
LookupCS: function(cs) {
if (TEXDEF.macros.hasOwnProperty(cs)) return TEXDEF.macros[cs];
if (TEXDEF.mathchar0mi.hasOwnProperty(cs)) return TEXDEF.mathchar0mi[cs];
if (TEXDEF.mathchar0mo.hasOwnProperty(cs)) return TEXDEF.mathchar0mo[cs];
if (TEXDEF.mathchar7.hasOwnProperty(cs)) return TEXDEF.mathchar7[cs];
if (TEXDEF.delimiter.hasOwnProperty('\\'+cs)) return TEXDEF.delimiter['\\'+cs];
return null;
},
//
// Handle internal math mode
// Look for the close delimiter and process the contents
//
Math: function (open) {
this.SaveText();
var i = this.i, j;
var braces = 0, c;
while ((c = this.GetNext())) {
j = this.i++;
switch(c) {
case '\\':
var cs = this.GetCS();
if (cs === ')') c = '\\(';
case '$':
if (braces === 0 && open === c) {
this.Push(TEX.Parse(this.string.substr(i, j-i),this.env).mml());
return;
}
break;
case '{':
braces++;
break;
case '}':
if (braces == 0) {
this.Error(["ExtraCloseMissingOpen","Extra close brace or missing open brace"]);
}
braces--;
break;
}
}
this.Error(["MathNotTerminated","Math not terminated in text box"]);
},
//
// Character can only be used in math mode
//
MathModeOnly: function (c) {
this.Error(["MathModeOnly","'%1' allowed only in math mode",c]);
},
//
// Character is being used out of place
//
Misplaced: function (c) {
this.Error(["Misplaced","'%1' can not be used here",c]);
},
//
// Braces start new environments
//
OpenBrace: function (c) {
var env = this.env;
this.env = MathJax.Hub.Insert({}, env);
this.env.oldEnv = env;
},
CloseBrace: function (c) {
if (this.env.oldEnv) {
this.SaveText();
this.env = this.env.oldEnv;
} else {
this.Error(["ExtraCloseMissingOpen","Extra close brace or missing open brace"]);
}
},
//
// Handle open and close quotes
//
OpenQuote: function (c) {
if (this.string.charAt(this.i) === c) {
this.text += "\u201C";
this.i++;
} else {
this.text += "\u2018"
}
},
CloseQuote: function (c) {
if (this.string.charAt(this.i) === c) {
this.text += "\u201D";
this.i++;
} else {
this.text += "\u2019"
}
},
//
// Handle non-breaking and regular spaces
//
Tilde: function (c) {
this.text += '\u00A0';
},
Space: function (c) {
this.text += ' ';
while (this.GetNext().match(/\s/)) this.i++;
},
//
// Insert the escaped characer
//
SelfQuote: function (name) {
this.text += name.substr(1);
},
//
// Insert a given character
//
Insert: function (name, c) {
this.text += c;
},
//
// Create an accented character using mover
//
Accent: function (name, c) {
this.SaveText();
var base = this.ParseArg(name);
var accent = MML.mo(MML.chars(c));
if (this.env.mathvariant) accent.mathvariant = this.env.mathvariant;
this.Push(MML.mover(base,accent));
},
//
// Switch to/from italics
//
Emph: function (name) {
this.UseFont(name, this.env.mathvariant === '-tex-mathit' ? 'normal' : '-tex-mathit');
},
//
// Use a given font on its argument
//
UseFont: function (name, variant) {
this.SaveText();
this.Push(this.ParseTextArg(name,{mathvariant: variant}));
},
//
// Set a font for the rest of the text
//
SetFont: function (name, variant) {
this.SaveText();
this.env.mathvariant = variant;
},
//
// Set the size to use
//
SetSize: function (name, size) {
this.SaveText();
this.env.mathsize = size;
},
//
// Process the argument as text with the given environment settings
//
ParseTextArg: function (name, env) {
var text = this.GetArgument(name);
env = MathJax.Hub.Insert(MathJax.Hub.Insert({}, this.env), env);
delete env.oldEnv;
return TextParser(text, env).Parse();
},
//
// Process an argument as text (overrides the math-mode version)
//
ParseArg: function (name) {
var mml = TextParser(this.GetArgument(name), this.env).Parse();
if (mml.length === 0) return mml[0];
return MML.mrow.apply(MML.mrow, mml);
},
//
// Create an mtext element with the accumulated text, if any
// and set it variant
//
SaveText: function () {
if (this.text) {
var text = MML.mtext(MML.chars(this.text));
if (this.env.mathvariant) text.mathvariant = this.env.mathvariant;
this.Push(text);
}
this.text = "";
},
//
// Save a MathML element or array, setting its size and color, if any
//
Push: function (mml) {
if (mml instanceof Array) {
if (this.env.mathsize || this.env.mathcolor) {
mml = MML.mstyle.apply(MML,mml);
if (this.env.mathsize) mml.mathsize = this.env.mathsize;
if (this.env.mathcolor) mml.mathcolor = this.env.mathcolor;
}
this.mml.push.apply(this.mml,mml);
} else {
if (this.env.mathsize && !mml.mathsize) mml.mathsize = this.env.mathsize;
if (this.env.mathcolor && !mml.mathcolor) mml.mathcolor = this.env.mathcolor;
this.mml.push(mml);
}
},
//
// Throw an error
//
Error: function (message) {
TEX.Error(message);
}
});
MathJax.Hub.Startup.signal.Post('TeX text-macros Ready');
});
MathJax.Ajax.loadComplete('[MathJax]/extensions/TeX/text-macros.js');

170
web/assets/MathJax/unpacked/extensions/TeX/unicode.js vendored Normal file
View File

@@ -0,0 +1,170 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/unicode.js
*
* Implements the \unicode extension to TeX to allow arbitrary unicode
* code points to be entered into the TeX file. You can specify
* the height and depth of the character (the width is determined by
* the browser), and the default font from which to take the character.
*
* Examples:
* \unicode{65} % the character 'A'
* \unicode{x41} % the character 'A'
* \unicode[.55,0.05]{x22D6} % less-than with dot, with height .55 and depth 0.05
* \unicode[.55,0.05][Geramond]{x22D6} % same taken from Geramond font
* \unicode[Garamond]{x22D6} % same, but with default height, depth of .8,.2
*
* Once a size and font are provided for a given code point, they need
* not be specified again in subsequent \unicode calls for that character.
* Note that a font list can be given, but Internet Explorer has a buggy
* implementation of font-family where it only looks in the first
* available font and if the glyph is not in that, it does not look at
* later fonts, but goes directly to the default font as set in the
* Internet-Options/Font panel. For this reason, the default font list is
* "STIXGeneral,'Arial Unicode MS'", so if the user has STIX fonts, the
* symbol will be taken from that (almost all the symbols are in
* STIXGeneral), otherwise Arial Unicode MS is tried.
*
* To configure the default font list, use
*
* MathJax.Hub.Config({
* TeX: {
* unicode: {
* fonts: "STIXGeneral,'Arial Unicode MS'"
* }
* }
* });
*
* The result of \unicode will have TeX class ORD (i.e., it will act like a
* variable). Use \mathbin, \mathrel, etc, to specify a different class.
*
* ---------------------------------------------------------------------
*
* 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.
*/
//
// The configuration defaults, augmented by the user settings
//
MathJax.Extension["TeX/unicode"] = {
version: "2.7.8",
unicode: {},
config: MathJax.Hub.CombineConfig("TeX.unicode",{
fonts: "STIXGeneral,'Arial Unicode MS'"
})
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX;
var MML = MathJax.ElementJax.mml;
var UNICODE = MathJax.Extension["TeX/unicode"].unicode;
//
// Add \unicode macro
//
TEX.Definitions.Add({macros: {unicode: 'Unicode'}},null,true);
//
// Implementation of \unicode in parser
//
TEX.Parse.Augment({
Unicode: function(name) {
var HD = this.GetBrackets(name), font;
if (HD) {
if (HD.replace(/ /g,"").match(/^(\d+(\.\d*)?|\.\d+),(\d+(\.\d*)?|\.\d+)$/))
{HD = HD.replace(/ /g,"").split(/,/); font = this.GetBrackets(name)}
else {font = HD; HD = null}
}
var n = this.trimSpaces(this.GetArgument(name)).replace(/^0x/,"x");
if (!n.match(/^(x[0-9A-Fa-f]+|[0-9]+)$/)) {
TEX.Error(["BadUnicode","Argument to \\unicode must be a number"]);
}
var N = parseInt(n.match(/^x/) ? "0"+n : n);
if (!UNICODE[N]) {UNICODE[N] = [800,200,font,N]}
else if (!font) {font = UNICODE[N][2]}
if (HD) {
UNICODE[N][0] = Math.floor(HD[0]*1000);
UNICODE[N][1] = Math.floor(HD[1]*1000);
}
var variant = this.stack.env.font, def = {};
if (font) {
UNICODE[N][2] = def.fontfamily = font.replace(/"/g,"'");
if (variant) {
if (variant.match(/bold/)) {def.fontweight = "bold"}
if (variant.match(/italic|-mathit/)) {def.fontstyle = "italic"}
}
} else if (variant) {def.mathvariant = variant}
def.unicode = [].concat(UNICODE[N]); // make a copy
this.Push(MML.mtext(MML.entity("#"+n)).With(def));
}
});
MathJax.Hub.Startup.signal.Post("TeX unicode Ready");
});
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var FONTS = MathJax.Extension["TeX/unicode"].config.fonts;
//
// Override getVariant to make one that includes the font and size
//
var GETVARIANT = MML.mbase.prototype.HTMLgetVariant;
MML.mbase.Augment({
HTMLgetVariant: function () {
var variant = GETVARIANT.apply(this,arguments);
if (variant.unicode) {delete variant.unicode; delete variant.FONTS} // clear font cache in case of restart
if (!this.unicode) {return variant}
variant.unicode = true;
if (!variant.defaultFont) {
variant = MathJax.Hub.Insert({},variant); // make a copy
variant.defaultFont = {family:FONTS};
}
var family = this.unicode[2]; if (family) {family += ","+FONTS} else {family = FONTS}
variant.defaultFont[this.unicode[3]] = [
this.unicode[0],this.unicode[1],500,0,500,
{isUnknown:true, isUnicode:true, font:family}
];
return variant;
}
});
});
MathJax.Hub.Register.StartupHook("SVG Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var FONTS = MathJax.Extension["TeX/unicode"].config.fonts;
//
// Override getVariant to make one that includes the font and size
//
var GETVARIANT = MML.mbase.prototype.SVGgetVariant;
MML.mbase.Augment({
SVGgetVariant: function () {
var variant = GETVARIANT.call(this);
if (variant.unicode) {delete variant.unicode; delete variant.FONTS} // clear font cache in case of restart
if (!this.unicode) {return variant}
variant.unicode = true;
if (!variant.forceFamily) {variant = MathJax.Hub.Insert({},variant)} // make a copy
variant.defaultFamily = FONTS; variant.noRemap = true;
variant.h = this.unicode[0]; variant.d = this.unicode[1];
return variant;
}
});
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/unicode.js");

61
web/assets/MathJax/unpacked/extensions/TeX/verb.js vendored Normal file
View File

@@ -0,0 +1,61 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/TeX/verb.js
*
* Implements the \verb|...| command for including text verbatim
* (with no processing of macros or special characters).
*
* ---------------------------------------------------------------------
*
* 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.Extension["TeX/verb"] = {
version: "2.7.8"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEXDEF.Add({macros: {verb: 'Verb'}},null,true);
TEX.Parse.Augment({
/*
* Implement \verb|...|
*/
Verb: function (name) {
var c = this.GetNext(); var start = ++this.i;
if (c == "" ) {TEX.Error(["MissingArgFor","Missing argument for %1",name])}
while (this.i < this.string.length && this.string.charAt(this.i) != c) {this.i++}
if (this.i == this.string.length)
{TEX.Error(["NoClosingDelim","Can't find closing delimiter for %1", name])}
var text = this.string.slice(start,this.i).replace(/ /g,"\u00A0"); this.i++;
this.Push(MML.mtext(text).With({mathvariant:MML.VARIANT.MONOSPACE}));
}
});
MathJax.Hub.Startup.signal.Post("TeX verb Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/verb.js");

1
web/assets/MathJax/unpacked/extensions/a11y/accessibility-menu.js vendored Normal file
View File

@@ -0,0 +1 @@
!function(a,b){var c,d,e=a.config.menuSettings,f=Function.prototype.bind?function(a,b){return a.bind(b)}:function(a,b){return function(){a.apply(b,arguments)}},g=Object.keys||function(a){var b=[];for(var c in a)a.hasOwnProperty(c)&&b.push(c);return b},h=MathJax.Ajax.config.path;h.a11y||(h.a11y=a.config.root+"/extensions/a11y");var i=b["accessibility-menu"]={version:"1.5.0",prefix:"",defaults:{},modules:[],MakeOption:function(a){return i.prefix+a},GetOption:function(a){return e[i.MakeOption(a)]},AddDefaults:function(){for(var a,b=g(i.defaults),c=0;a=b[c];c++){var d=i.MakeOption(a);void 0===e[d]&&(e[d]=i.defaults[a])}},AddMenu:function(){for(var a,b=Array(this.modules.length),e=0;a=this.modules[e];e++)b[e]=a.placeHolder;var f=d.FindId("Accessibility");if(f)b.unshift(c.RULE()),f.submenu.items.push.apply(f.submenu.items,b);else{var g=(d.FindId("Settings","Renderer")||{}).submenu;g&&(b.unshift(c.RULE()),b.unshift(g.items.pop()),b.unshift(g.items.pop())),b.unshift("Accessibility");var f=c.SUBMENU.apply(c.SUBMENU,b),h=d.IndexOfId("Locale");h?d.items.splice(h,0,f):d.items.push(c.RULE(),f)}},Register:function(a){i.defaults[a.option]=!1,i.modules.push(a)},Startup:function(){c=MathJax.Menu.ITEM,d=MathJax.Menu.menu;for(var a,b=0;a=this.modules[b];b++)a.CreateMenu();this.AddMenu()},LoadExtensions:function(){for(var b,c=[],d=0;b=this.modules[d];d++)e[b.option]&&c.push(b.module);return c.length?a.Startup.loadArray(c):null}},j=MathJax.Extension.ModuleLoader=MathJax.Object.Subclass({option:"",name:["",""],module:"",placeHolder:null,submenu:!1,extension:null,Init:function(a,b,c,d,e){this.option=a,this.name=[b.replace(/ /g,""),b],this.module=c,this.extension=d,this.submenu=e||!1},CreateMenu:function(){var a=f(this.Load,this);this.submenu?this.placeHolder=c.SUBMENU(this.name,c.CHECKBOX(["Activate","Activate"],i.MakeOption(this.option),{action:a}),c.RULE(),c.COMMAND(["OptionsWhenActive","(Options when Active)"],null,{disabled:!0})):this.placeHolder=c.CHECKBOX(this.name,i.MakeOption(this.option),{action:a})},Load:function(){a.Queue(["Require",MathJax.Ajax,this.module,["Enable",this]])},Enable:function(a){var b=MathJax.Extension[this.extension];b&&(b.Enable(!0,!0),MathJax.Menu.saveCookie())}});i.Register(j("collapsible","Collapsible Math","[a11y]/collapsible.js","collapsible")),i.Register(j("autocollapse","Auto Collapse","[a11y]/auto-collapse.js","auto-collapse")),i.Register(j("explorer","Explorer","[a11y]/explorer.js","explorer",!0)),i.AddDefaults(),a.Register.StartupHook("End Extensions",function(){a.Register.StartupHook("MathMenu Ready",function(){i.Startup(),a.Startup.signal.Post("Accessibility Menu Ready")},5)},5),MathJax.Hub.Register.StartupHook("End Cookie",function(){MathJax.Callback.Queue(["LoadExtensions",i],["loadComplete",MathJax.Ajax,"[a11y]/accessibility-menu.js"])})}(MathJax.Hub,MathJax.Extension);

1
web/assets/MathJax/unpacked/extensions/a11y/auto-collapse.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/collapsible.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/explorer.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

BIN
web/assets/MathJax/unpacked/extensions/a11y/invalid_keypress.mp3 vendored Normal file
View File

Binary file not shown.

BIN
web/assets/MathJax/unpacked/extensions/a11y/invalid_keypress.ogg vendored Normal file
View File

Binary file not shown.

1511
web/assets/MathJax/unpacked/extensions/a11y/mathjax-sre.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/functions/algebra.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Algebra","mappings":{"default":{"default":"degree"}},"key":"deg","names":["deg"]},{"category":"Algebra","mappings":{"default":{"default":"determinant","short":"det"}},"key":"det","names":["det"]},{"category":"Algebra","mappings":{"default":{"default":"dimension"}},"key":"dim","names":["dim"]},{"category":"Algebra","mappings":{"default":{"default":"homomorphism","short":"hom"}},"key":"hom","names":["hom","Hom"]},{"category":"Algebra","mappings":{"default":{"default":"kernel"}},"key":"ker","names":["ker"]},{"category":"Algebra","mappings":{"default":{"default":"trace"}},"key":"Tr","names":["Tr","tr"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/functions/elementary.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Elementary","mappings":{"default":{"default":"logarithm","alternative":"logarithm function","short":"log"}},"key":"log","names":["log"]},{"category":"Elementary","mappings":{"default":{"default":"natural logarithm","alternative":"natural logarithm function","short":"natural log"},"mathspeak":{"default":"ln"}},"key":"ln","names":["ln"]},{"category":"Elementary","mappings":{"default":{"default":"logarithm base 10","short":"log base 10"}},"key":"lg","names":["lg"]},{"category":"Elementary","mappings":{"default":{"default":"exponential","alternative":"exponential function","short":"exp"}},"key":"exp","names":["exp","expt"]},{"category":"Elementary","mappings":{"default":{"default":"greatest common divisor","short":"gcd"}},"key":"gcd","names":["gcd"]},{"category":"Elementary","mappings":{"default":{"default":"least common multiple","short":"lcm"}},"key":"lcm","names":["lcm"]},{"category":"Complex","mappings":{"default":{"default":"argument","short":"arg"}},"key":"arg","names":["arg"]},{"category":"Complex","mappings":{"default":{"default":"imaginary part","short":"imaginary"},"mathspeak":{"default":"im"}},"key":"im","names":["im"]},{"category":"Complex","mappings":{"default":{"default":"real part","short":"real"},"mathspeak":{"default":"re"}},"key":"re","names":["re"]},{"category":"Limits","mappings":{"default":{"default":"infimum","short":"inf"}},"key":"inf","names":["inf"]},{"category":"Limits","mappings":{"default":{"default":"limit","short":"lim"},"mathspeak":{"default":"limit"}},"key":"lim","names":["lim"]},{"category":"Limits","mappings":{"default":{"default":"infimum default","alternative":"inferior limit","short":"liminf"}},"key":"liminf","names":["lim inf","liminf"]},{"category":"Limits","mappings":{"default":{"default":"supremum limit","alternative":"superior limit","short":"limsup"}},"key":"limsup","names":["lim sup","limsup"]},{"category":"Limits","mappings":{"default":{"default":"maximum","short":"max"}},"key":"max","names":["max"]},{"category":"Limits","mappings":{"default":{"default":"minimum","short":"min"}},"key":"min","names":["min"]},{"category":"Limits","mappings":{"default":{"default":"supremum","short":"sup"}},"key":"sup","names":["sup"]},{"category":"Limits","mappings":{"default":{"default":"injective limit","alternative":"direct limit","short":"colimit"}},"key":"injlim","names":["injlim","inj lim"]},{"category":"Limits","mappings":{"default":{"default":"projective limit","alternative":"inverse limit","short":"limit"}},"key":"projlim","names":["projlim","proj lim"]},{"category":"Elementary","mappings":{"default":{"default":"modulo","short":"mod"}},"key":"mod","names":["mod"]},{"category":"Probability","mappings":{"default":{"default":"probability"}},"key":"Pr","names":["Pr"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/functions/hyperbolic.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Hyperbolic","mappings":{"default":{"default":"hyperbolic cosine function","short":"hyperbolic cosine"}},"key":"cosh","names":["cosh"]},{"category":"Hyperbolic","mappings":{"default":{"default":"hyperbolic cotangent function","short":"hyperbolic cotangent"}},"key":"coth","names":["coth"]},{"category":"Hyperbolic","mappings":{"default":{"default":"hyperbolic cosecant function","short":"hyperbolic cosecant"}},"key":"csch","names":["csch"]},{"category":"Hyperbolic","mappings":{"default":{"default":"hyperbolic secant function","short":"hyperbolic secant"}},"key":"sech","names":["sech"]},{"category":"Hyperbolic","mappings":{"default":{"default":"hyperbolic sine function","short":"hyperbolic sine"}},"key":"sinh","names":["sinh"]},{"category":"Hyperbolic","mappings":{"default":{"default":"hyperbolic tangent function","short":"hyperbolic tangent"}},"key":"tanh","names":["tanh"]},{"category":"Area","mappings":{"default":{"default":"inverse hyperbolic cosine function","alternative":"area hyperbolic cosine function","short":"area hyperbolic cosine"}},"key":"arcosh","names":["arcosh","arccosh"]},{"category":"Area","mappings":{"default":{"default":"inverse hyperbolic cotangent function","alternative":"area hyperbolic cotangent function","short":"area hyperbolic cotangent"}},"key":"arcoth","names":["arcoth","arccoth"]},{"category":"Area","mappings":{"default":{"default":"inverse hyperbolic cosecant function","alternative":"area hyperbolic cosecant function","short":"area hyperbolic cosecant"}},"key":"arcsch","names":["arcsch","arccsch"]},{"category":"Area","mappings":{"default":{"default":"inverse hyperbolic secant function","alternative":"area hyperbolic secant function","short":"area hyperbolic secant"}},"key":"arsech","names":["arsech","arcsech"]},{"category":"Area","mappings":{"default":{"default":"inverse hyperbolic sine function","alternative":"area hyperbolic sine function","short":"area hyperbolic sine"}},"key":"arsinh","names":["arsinh","arcsinh"]},{"category":"Area","mappings":{"default":{"default":"inverse hyperbolic tangent function","alternative":"area hyperbolic tangent function","short":"area hyperbolic tangent"}},"key":"artanh","names":["artanh","arctanh"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/functions/trigonometry.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Trigonometric","mappings":{"default":{"default":"cosine function","short":"cosine"}},"key":"cos","names":["cos","cosine"]},{"category":"Trigonometric","mappings":{"default":{"default":"cotangent function","short":"cotangent"}},"key":"cot","names":["cot"]},{"category":"Trigonometric","mappings":{"default":{"default":"cosecant function","short":"cosecant"}},"key":"csc","names":["csc"]},{"category":"Trigonometric","mappings":{"default":{"default":"secant function","short":"secant"}},"key":"sec","names":["sec"]},{"category":"Trigonometric","mappings":{"default":{"default":"sine function","alternative":"sine function","short":"sine"}},"key":"sin","names":["sin","sine"]},{"category":"Trigonometric","mappings":{"default":{"default":"tangent function","short":"tangent"}},"key":"tan","names":["tan"]},{"category":"Cyclometric","mappings":{"default":{"default":"inverse cosine function","alternative":"arc cosine function","short":"arc cosine"}},"key":"arccos","names":["arccos"]},{"category":"Cyclometric","mappings":{"default":{"default":"inverse cotangent function","alternative":"arc cotangent function","short":"arc cotangent"}},"key":"arccot","names":["arccot"]},{"category":"Cyclometric","mappings":{"default":{"default":"inverse cosecant function","alternative":"arc cosecant function","short":"arc cosecant"}},"key":"arccsc","names":["arccsc"]},{"category":"Cyclometric","mappings":{"default":{"default":"inverse secant function","alternative":"arc secant function","short":"arc secant"}},"key":"arcsec","names":["arcsec"]},{"category":"Cyclometric","mappings":{"default":{"default":"inverse sine function","alternative":"arc sine function","short":"arc sine"}},"key":"arcsin","names":["arcsin"]},{"category":"Cyclometric","mappings":{"default":{"default":"inverse tangent function","alternative":"arc tangent function","short":"arc tangent"}},"key":"arctan","names":["arctan"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-capital.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Lu","key":"0391","mappings":{"default":{"default":"greek capital letter alpha","short":"cap alpha"},"mathspeak":{"default":"upper Alpha"}}},{"category":"Lu","key":"0392","mappings":{"default":{"default":"greek capital letter beta","short":"cap beta"},"mathspeak":{"default":"upper Beta"}}},{"category":"Lu","key":"0393","mappings":{"default":{"default":"greek capital letter gamma","short":"cap gamma"},"mathspeak":{"default":"upper Gamma"}}},{"category":"Lu","key":"0394","mappings":{"default":{"default":"greek capital letter delta","short":"cap delta"},"mathspeak":{"default":"upper Delta"}}},{"category":"Lu","key":"0395","mappings":{"default":{"default":"greek capital letter epsilon","short":"cap epsilon"},"mathspeak":{"default":"upper Epsilon"}}},{"category":"Lu","key":"0396","mappings":{"default":{"default":"greek capital letter zeta","short":"cap zeta"},"mathspeak":{"default":"upper Zeta"}}},{"category":"Lu","key":"0397","mappings":{"default":{"default":"greek capital letter eta","short":"cap eta"},"mathspeak":{"default":"upper Eta"}}},{"category":"Lu","key":"0398","mappings":{"default":{"default":"greek capital letter theta","short":"cap theta"},"mathspeak":{"default":"upper Theta"}}},{"category":"Lu","key":"0399","mappings":{"default":{"default":"greek capital letter iota","short":"cap iota"},"mathspeak":{"default":"upper Iota"}}},{"category":"Lu","key":"039A","mappings":{"default":{"default":"greek capital letter kappa","short":"cap kappa"},"mathspeak":{"default":"upper Kappa"}}},{"category":"Lu","key":"039B","mappings":{"default":{"default":"greek capital letter lamda","alternative":"greek capital letter lambda","short":"cap lamda"},"mathspeak":{"default":"upper Lamda"}}},{"category":"Lu","key":"039C","mappings":{"default":{"default":"greek capital letter mu","short":"cap mu"},"mathspeak":{"default":"upper Mu"}}},{"category":"Lu","key":"039D","mappings":{"default":{"default":"greek capital letter nu","short":"cap nu"},"mathspeak":{"default":"upper Nu"}}},{"category":"Lu","key":"039E","mappings":{"default":{"default":"greek capital letter xi","short":"cap xi"},"mathspeak":{"default":"upper Xi"}}},{"category":"Lu","key":"039F","mappings":{"default":{"default":"greek capital letter omicron","short":"cap omicron"},"mathspeak":{"default":"upper Omicron"}}},{"category":"Lu","key":"03A0","mappings":{"default":{"default":"greek capital letter pi","short":"cap pi"},"mathspeak":{"default":"upper Pi"}}},{"category":"Lu","key":"03A1","mappings":{"default":{"default":"greek capital letter rho","short":"cap rho"},"mathspeak":{"default":"upper Rho"}}},{"category":"Lu","key":"03A3","mappings":{"default":{"default":"greek capital letter sigma","short":"cap sigma"},"mathspeak":{"default":"upper Sigma"}}},{"category":"Lu","key":"03A4","mappings":{"default":{"default":"greek capital letter tau","short":"cap tau"},"mathspeak":{"default":"upper Tau"}}},{"category":"Lu","key":"03A5","mappings":{"default":{"default":"greek capital letter upsilon","short":"cap upsilon"},"mathspeak":{"default":"upper Upsilon"}}},{"category":"Lu","key":"03A6","mappings":{"default":{"default":"greek capital letter phi","short":"cap phi"},"mathspeak":{"default":"upper Phi"}}},{"category":"Lu","key":"03A7","mappings":{"default":{"default":"greek capital letter chi","short":"cap chi"},"mathspeak":{"default":"upper Chi"}}},{"category":"Lu","key":"03A8","mappings":{"default":{"default":"greek capital letter psi","short":"cap psi"},"mathspeak":{"default":"upper Psi"}}},{"category":"Lu","key":"03A9","mappings":{"default":{"default":"greek capital letter omega","short":"cap omega"},"mathspeak":{"default":"upper Omega"}}}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-mathfonts-bold.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-mathfonts-italic.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-mathfonts-sans-serif-bold.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-scripts.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Ll","key":"1D26","mappings":{"default":{"default":"greek letter small capital gamma","alternative":"greek letter gamma","short":"small cap gamma"},"mathspeak":{"default":"small upper Gamma"}}},{"category":"Ll","key":"1D27","mappings":{"default":{"default":"greek letter small capital lamda","alternative":"greek letter lamda","short":"small cap lamda"},"mathspeak":{"default":"small upper Lamda"}}},{"category":"Ll","key":"1D28","mappings":{"default":{"default":"greek letter small capital pi","alternative":"greek letter pi","short":"small cap pi"},"mathspeak":{"default":"small upper Pi"}}},{"category":"Ll","key":"1D29","mappings":{"default":{"default":"greek letter small capital rho","alternative":"greek letter rho","short":"small cap rho"},"mathspeak":{"default":"small upper Rho"}}},{"category":"Ll","key":"1D2A","mappings":{"default":{"default":"greek letter small capital psi","alternative":"greek letter psi","short":"small cap psi"},"mathspeak":{"default":"small upper Psi"}}},{"category":"Lm","key":"1D5E","mappings":{"default":{"default":"modifier letter small greek gamma","alternative":"greek letter superscript gamma","short":"superscript gamma"}}},{"category":"Lm","key":"1D60","mappings":{"default":{"default":"modifier letter small greek phi","alternative":"greek letter superscript phi","short":"superscript phi"}}},{"category":"Lm","key":"1D66","mappings":{"default":{"default":"greek subscript small letter beta","short":"subscript beta"}}},{"category":"Lm","key":"1D67","mappings":{"default":{"default":"greek subscript small letter gamma","alternative":"greek letter gamma","short":"subscript gamma"}}},{"category":"Lm","key":"1D68","mappings":{"default":{"default":"greek subscript small letter rho","alternative":"greek letter rho","short":"subscript rho"}}},{"category":"Lm","key":"1D69","mappings":{"default":{"default":"greek subscript small letter phi","alternative":"greek letter phi","short":"subscript phi"}}},{"category":"Lm","key":"1D6A","mappings":{"default":{"default":"greek subscript small letter chi","alternative":"greek letter chi","short":"subscript chi"}}}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-small.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Ll","key":"03B1","mappings":{"default":{"default":"greek small letter alpha","short":"alpha"}}},{"category":"Ll","key":"03B2","mappings":{"default":{"default":"greek small letter beta","short":"beta"}}},{"category":"Ll","key":"03B3","mappings":{"default":{"default":"greek small letter gamma","short":"gamma"}}},{"category":"Ll","key":"03B4","mappings":{"default":{"default":"greek small letter delta","short":"delta"}}},{"category":"Ll","key":"03B5","mappings":{"default":{"default":"greek small letter epsilon","short":"epsilon"}}},{"category":"Ll","key":"03B6","mappings":{"default":{"default":"greek small letter zeta","short":"zeta"}}},{"category":"Ll","key":"03B7","mappings":{"default":{"default":"greek small letter eta","short":"eta"}}},{"category":"Ll","key":"03B8","mappings":{"default":{"default":"greek small letter theta","short":"theta"}}},{"category":"Ll","key":"03B9","mappings":{"default":{"default":"greek small letter iota","short":"iota"}}},{"category":"Ll","key":"03BA","mappings":{"default":{"default":"greek small letter kappa","short":"kappa"}}},{"category":"Ll","key":"03BB","mappings":{"default":{"default":"greek small letter lamda","alternative":"greek small letter lambda","short":"lamda"}}},{"category":"Ll","key":"03BC","mappings":{"default":{"default":"greek small letter mu","short":"mu"}}},{"category":"Ll","key":"03BD","mappings":{"default":{"default":"greek small letter nu","short":"nu"}}},{"category":"Ll","key":"03BE","mappings":{"default":{"default":"greek small letter xi","short":"xi"}}},{"category":"Ll","key":"03BF","mappings":{"default":{"default":"greek small letter omicron","short":"omicron"}}},{"category":"Ll","key":"03C0","mappings":{"default":{"default":"greek small letter pi","short":"pi"}}},{"category":"Ll","key":"03C1","mappings":{"default":{"default":"greek small letter rho","short":"rho"}}},{"category":"Ll","key":"03C2","mappings":{"default":{"default":"greek small letter final sigma","short":"final sigma"}}},{"category":"Ll","key":"03C3","mappings":{"default":{"default":"greek small letter sigma","short":"sigma"}}},{"category":"Ll","key":"03C4","mappings":{"default":{"default":"greek small letter tau","short":"tau"}}},{"category":"Ll","key":"03C5","mappings":{"default":{"default":"greek small letter upsilon","short":"upsilon"}}},{"category":"Ll","key":"03C6","mappings":{"default":{"default":"greek small letter phi","short":"phi"}}},{"category":"Ll","key":"03C7","mappings":{"default":{"default":"greek small letter chi","short":"chi"}}},{"category":"Ll","key":"03C8","mappings":{"default":{"default":"greek small letter psi","short":"psi"}}},{"category":"Ll","key":"03C9","mappings":{"default":{"default":"greek small letter omega","short":"omega"}}}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/greek-symbols.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/hebrew_letters.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Lo","mappings":{"default":{"default":"alef symbol","alternative":"first transfinite cardinal","short":"alef"}},"key":"2135"},{"category":"Lo","mappings":{"default":{"default":"bet symbol","alternative":"second transfinite cardinal","short":"bet"}},"key":"2136"},{"category":"Lo","mappings":{"default":{"default":"gimel symbol","alternative":"third transfinite cardinal","short":"gimel"}},"key":"2137"},{"category":"Lo","mappings":{"default":{"default":"dalet symbol","alternative":"fourth transfinite cardinal","short":"dalet"}},"key":"2138"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-lower-double-accent.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-lower-normal.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-lower-phonetic.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-lower-single-accent.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-bold-fraktur.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-bold-script.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-bold.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-double-struck.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-fraktur.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-italic.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-monospace.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-sans-serif-bold.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-sans-serif-italic.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-sans-serif.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-mathfonts-script.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-rest.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-upper-double-accent.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-upper-normal.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/latin-upper-single-accent.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_angles.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Sm","mappings":{"default":{"default":"right angle with arc"}},"key":"22BE"},{"category":"Sm","mappings":{"default":{"default":"right angle with downwards zigzag arrow"}},"key":"237C"},{"category":"Sm","mappings":{"default":{"default":"three dimensional angle"}},"key":"27C0"},{"category":"Sm","mappings":{"default":{"default":"measured angle opening left"}},"key":"299B"},{"category":"Sm","mappings":{"default":{"default":"right angle variant with square"}},"key":"299C"},{"category":"Sm","mappings":{"default":{"default":"measured right angle with dot"}},"key":"299D"},{"category":"Sm","mappings":{"default":{"default":"angle with s inside"}},"key":"299E"},{"category":"Sm","mappings":{"default":{"default":"acute angle"}},"key":"299F"},{"category":"Sm","mappings":{"default":{"default":"spherical angle opening left"}},"key":"29A0"},{"category":"Sm","mappings":{"default":{"default":"spherical angle opening up"}},"key":"29A1"},{"category":"Sm","mappings":{"default":{"default":"turned angle"}},"key":"29A2"},{"category":"Sm","mappings":{"default":{"default":"reversed angle"}},"key":"29A3"},{"category":"Sm","mappings":{"default":{"default":"angle with underbar"}},"key":"29A4"},{"category":"Sm","mappings":{"default":{"default":"reversed angle with underbar"}},"key":"29A5"},{"category":"Sm","mappings":{"default":{"default":"oblique angle opening up"}},"key":"29A6"},{"category":"Sm","mappings":{"default":{"default":"oblique angle opening down"}},"key":"29A7"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing up and right"}},"key":"29A8"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing up and left"}},"key":"29A9"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing down and right"}},"key":"29AA"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing down and left"}},"key":"29AB"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing right and up"}},"key":"29AC"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing left and up"}},"key":"29AD"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing right and down"}},"key":"29AE"},{"category":"Sm","mappings":{"default":{"default":"measured angle with open arm ending in arrow pointing left and down"}},"key":"29AF"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_arrows.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_characters.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Ll","mappings":{"default":{"default":"script small l","short":"script l"}},"key":"2113"},{"category":"Sm","mappings":{"default":{"default":"script capital p","alternative":"script p","short":"script cap p"},"mathspeak":{"default":"script upper P"}},"key":"2118"},{"category":"Ll","mappings":{"default":{"default":"double struck small pi","short":"double struck pi"}},"key":"213C"},{"category":"Ll","mappings":{"default":{"default":"double struck small gamma","short":"double struck gamma"}},"key":"213D"},{"category":"Lu","mappings":{"default":{"default":"double struck capital gamma","short":"double struck cap gamma"},"mathspeak":{"default":"double struck upper Gamma"}},"key":"213E"},{"category":"Lu","mappings":{"default":{"default":"double struck capital pi","short":"double struck cap pi"},"mathspeak":{"default":"double struck upper Pi"}},"key":"213F"},{"category":"Sm","mappings":{"default":{"default":"double struck n ary summation"}},"key":"2140"},{"category":"Lu","mappings":{"default":{"default":"double struck italic capital d","short":"double struck italic cap d"},"mathspeak":{"default":"double struck italic upper D"}},"key":"2145"},{"category":"Ll","mappings":{"default":{"default":"double struck italic small d","short":"double struck italic d"}},"key":"2146"},{"category":"Ll","mappings":{"default":{"default":"double struck italic small e","short":"double struck italic e"}},"key":"2147"},{"category":"Ll","mappings":{"default":{"default":"double struck italic small i","short":"double struck italic i"}},"key":"2148"},{"category":"Ll","mappings":{"default":{"default":"double struck italic small j","short":"double struck italic j"}},"key":"2149"},{"category":"Ll","mappings":{"default":{"default":"italic small dotless i","short":"italic dotless i"}},"key":"1D6A4"},{"category":"Ll","mappings":{"default":{"default":"italic small dotless j","short":"italic dotless j"}},"key":"1D6A5"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_delimiters.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_digits.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_geometry.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_harpoons.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_non_characters.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Ll","mappings":{"default":{"default":"mathematical italic small h over two time greek letter pi","alternative":"italic small h over two pi","short":"italic h over two pi"},"physics":{"default":"planck constant over two pi","alternative":"planck constant over 2 pi"}},"key":"210F"},{"category":"So","mappings":{"default":{"default":"l b bar symbol","short":"l b bar"}},"key":"2114"},{"category":"So","mappings":{"default":{"default":"numero sign","alternative":"numero","short":"numero"}},"key":"2116"},{"category":"So","mappings":{"default":{"default":"sound recording copyright"}},"key":"2117"},{"category":"So","mappings":{"default":{"default":"prescription take"}},"key":"211E"},{"category":"So","mappings":{"default":{"default":"response"}},"key":"211F"},{"category":"So","mappings":{"default":{"default":"service mark"}},"key":"2120"},{"category":"So","mappings":{"default":{"default":"telephone sign","alternative":"t e l symbol"}},"key":"2121"},{"category":"So","mappings":{"default":{"default":"trade mark sign","alternative":"trademark","short":"trade mark"}},"key":"2122"},{"category":"So","mappings":{"default":{"default":"versicle"}},"key":"2123"},{"category":"So","mappings":{"default":{"default":"ounce sign","alternative":"ounce","short":"ounce"}},"key":"2125"},{"category":"Lu","mappings":{"default":{"default":"ohm sign","alternative":"ohm","short":"ohm"}},"key":"2126"},{"category":"So","mappings":{"default":{"default":"inverted ohm sign","alternative":"mho","short":"inverted ohm"}},"key":"2127"},{"category":"Lu","mappings":{"default":{"default":"kelvin sign","alternative":"degrees kelvin","short":"kelvin"}},"key":"212A"},{"category":"Lu","mappings":{"default":{"default":"angstrom sign","alternative":"angstrom unit","short":"angstrom"}},"key":"212B"},{"category":"So","mappings":{"default":{"default":"estimated symbol","short":"estimated"}},"key":"212E"},{"category":"Lu","mappings":{"default":{"default":"turned capital f","alternative":"turned f","short":"turned cap f"},"mathspeak":{"default":"turned upper F"}},"key":"2132"},{"category":"Ll","mappings":{"default":{"default":"information source"}},"key":"2139"},{"category":"So","mappings":{"default":{"default":"rotated capital q","short":"rotated cap q"},"mathspeak":{"default":"rotated upper Q"}},"key":"213A"},{"category":"So","mappings":{"default":{"default":"facsimile sign"}},"key":"213B"},{"category":"Sm","mappings":{"default":{"default":"turned sans serif capital g","short":"turned sans serif cap g"},"mathspeak":{"default":"turned sans serif upper G"}},"key":"2141"},{"category":"Sm","mappings":{"default":{"default":"turned sans serif capital l","short":"turned sans serif cap l"},"mathspeak":{"default":"turned sans serif upper L"}},"key":"2142"},{"category":"Sm","mappings":{"default":{"default":"reversed sans serif capital l","short":"reversed sans serif cap l"},"mathspeak":{"default":"reversed sans serif upper L"}},"key":"2143"},{"category":"Sm","mappings":{"default":{"default":"turned sans serif capital y","short":"turned sans serif cap y"},"mathspeak":{"default":"turned sans serif upper Y"}},"key":"2144"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_symbols.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/math_whitespace.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Zs","mappings":{"default":{"default":"space"}},"key":"0020"},{"category":"Zs","mappings":{"default":{"default":"no break space","alternative":"non breaking space"}},"key":"00A0"},{"category":"Cf","mappings":{"default":{"default":"soft hyphen"}},"key":"00AD"},{"category":"Zs","mappings":{"default":{"default":"en quad"}},"key":"2000"},{"category":"Zs","mappings":{"default":{"default":"em quad"}},"key":"2001"},{"category":"Zs","mappings":{"default":{"default":"en space"}},"key":"2002"},{"category":"Zs","mappings":{"default":{"default":"em space"}},"key":"2003"},{"category":"Zs","mappings":{"default":{"default":"three per em space"}},"key":"2004"},{"category":"Zs","mappings":{"default":{"default":"four per em space"}},"key":"2005"},{"category":"Zs","mappings":{"default":{"default":"six per em space"}},"key":"2006"},{"category":"Zs","mappings":{"default":{"default":"figure space"}},"key":"2007"},{"category":"Zs","mappings":{"default":{"default":"punctuation space"}},"key":"2008"},{"category":"Zs","mappings":{"default":{"default":"thin space"}},"key":"2009"},{"category":"Zs","mappings":{"default":{"default":"hair space"}},"key":"200A"},{"category":"Cf","mappings":{"default":{"default":"zero width space"}},"key":"200B"},{"category":"Cf","mappings":{"default":{"default":"zero width non joiner"}},"key":"200C"},{"category":"Cf","mappings":{"default":{"default":"zero width joiner"}},"key":"200D"},{"category":"Cf","mappings":{"default":{"default":"left to right mark"}},"key":"200E"},{"category":"Cf","mappings":{"default":{"default":"right to left mark"}},"key":"200F"},{"category":"Zl","mappings":{"default":{"default":"line separator"}},"key":"2028"},{"category":"Zp","mappings":{"default":{"default":"paragraph separator"}},"key":"2029"},{"category":"Cf","mappings":{"default":{"default":"left to right embedding"}},"key":"202A"},{"category":"Cf","mappings":{"default":{"default":"right to left embedding"}},"key":"202B"},{"category":"Cf","mappings":{"default":{"default":"pop directional formatting"}},"key":"202C"},{"category":"Cf","mappings":{"default":{"default":"left to right override"}},"key":"202D"},{"category":"Cf","mappings":{"default":{"default":"right to left override"}},"key":"202E"},{"category":"Zs","mappings":{"default":{"default":"narrow no break space"}},"key":"202F"},{"category":"Zs","mappings":{"default":{"default":"medium mathematical space"}},"key":"205F"},{"category":"Cf","mappings":{"default":{"default":"word joiner"}},"key":"2060"},{"category":"Cf","mappings":{"default":{"default":"function application","short":"of"}},"key":"2061"},{"category":"Cf","mappings":{"default":{"default":"invisible times","short":"times"}},"key":"2062"},{"category":"Cf","mappings":{"default":{"default":"invisible separator","short":"separator"}},"key":"2063"},{"category":"Cf","mappings":{"default":{"default":"invisible plus","short":"plus"}},"key":"2064"},{"category":"Cf","mappings":{"default":{"default":"inhibit symmetric swapping"}},"key":"206A"},{"category":"Cf","mappings":{"default":{"default":"activate symmetric swapping"}},"key":"206B"},{"category":"Cf","mappings":{"default":{"default":"national digit shapes"}},"key":"206E"},{"category":"Cf","mappings":{"default":{"default":"nominal digit shapes"}},"key":"206F"},{"category":"Cf","mappings":{"default":{"default":"zero width no break space","alternative":"byte order mark"}},"key":"FEFF"},{"category":"Cf","mappings":{"default":{"default":"interlinear annotation anchor"}},"key":"FFF9"},{"category":"Cf","mappings":{"default":{"default":"interlinear annotation separator"}},"key":"FFFA"},{"category":"Cf","mappings":{"default":{"default":"interlinear annotation terminator"}},"key":"FFFB"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/symbols/other_stars.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/energy.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"energy","mappings":{"default":{"default":"watts"}},"key":"W","names":["W","w"]},{"category":"energy","mappings":{"default":{"default":"kilowatts"}},"key":"kW","names":["kw","kW"]},{"category":"energy","mappings":{"default":{"default":"milliwatts"}},"key":"mW","names":["mw","mW"]},{"category":"energy","mappings":{"default":{"default":"kilowatt hours"}},"key":"kwh","names":["kwh","kWh"]},{"category":"energy","mappings":{"default":{"default":"joules"}},"key":"J","names":["J"]},{"category":"energy","mappings":{"default":{"default":"Newton"}},"key":"N","names":["N"]},{"category":"energy","mappings":{"default":{"default":"amperes"}},"key":"A","names":["A"]},{"category":"energy","mappings":{"default":{"default":"volts"}},"key":"V","names":["V"]},{"category":"energy","mappings":{"default":{"default":"microohm"}},"key":"µΩ","names":["µΩ"]},{"category":"energy","mappings":{"default":{"default":"milliohm"}},"key":"mΩ","names":["mΩ"]},{"category":"energy","mappings":{"default":{"default":"ohm"}},"key":"Ω","names":["Ω","Ohm"]},{"category":"energy","mappings":{"default":{"default":"kilohm"}},"key":"kΩ","names":["kΩ","KΩ"]},{"category":"energy","mappings":{"default":{"default":"ohm"}},"key":"Ω","names":["Ω"]},{"category":"energy","mappings":{"default":{"default":"megaohm"}},"key":"MΩ","names":["MΩ"]},{"category":"energy","mappings":{"default":{"default":"gigaohm"}},"key":"GΩ","names":["GΩ"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/length.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"Length","mappings":{"default":{"default":"millimeters"}},"key":"mm","names":["mm"]},{"category":"Length","mappings":{"default":{"default":"centimeters"}},"key":"cm","names":["cm"]},{"category":"Length","mappings":{"default":{"default":"meters"}},"key":"m","names":["m"]},{"category":"Length","mappings":{"default":{"default":"kilometers"}},"key":"km","names":["km"]},{"category":"Length","mappings":{"default":{"default":"feet"}},"key":"ft","names":["ft","ft."]},{"category":"Length","mappings":{"default":{"default":"inches"}},"key":"in","names":["in","in."]},{"category":"Length","mappings":{"default":{"default":"miles"}},"key":"mi","names":["mi","mi."]},{"category":"Length","mappings":{"default":{"default":"yards"}},"key":"yd","names":["yd","yd."]},{"category":"","mappings":{"default":{"default":"nautical miles"}},"key":"n.m.","names":["n.m."]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/memory.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"","mappings":{"default":{"default":"bits"}},"key":"b","names":["b"]},{"category":"","mappings":{"default":{"default":"bytes"}},"key":"B","names":["B"]},{"category":"","mappings":{"default":{"default":"kilobytes"}},"key":"KB","names":["KB"]},{"category":"","mappings":{"default":{"default":"megabytes"}},"key":"MB","names":["MB"]},{"category":"","mappings":{"default":{"default":"gigabytes"}},"key":"GB","names":["GB"]},{"category":"","mappings":{"default":{"default":"terabytes"}},"key":"TB","names":["TB"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/other.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"","mappings":{"default":{"default":"dozen"}},"key":"doz","names":["doz","doz.","dz","dz."]},{"category":"","mappings":{"default":{"default":"square"}},"key":"sq","names":["sq","sq."]},{"category":"","mappings":{"default":{"default":"hectare"}},"key":"ha","names":["ha"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/speed.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"","mappings":{"default":{"default":"knot"}},"key":"kt","names":["kt","kt."]},{"category":"","mappings":{"default":{"default":"miles per hour"}},"key":"mph","names":["mph"]},{"category":"","mappings":{"default":{"default":"revolutions per minute"}},"key":"rpm","names":["rpm"]},{"category":"","mappings":{"default":{"default":"kilometers per hour"}},"key":"kmh","names":["kmh"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/temperature.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"","mappings":{"default":{"default":"Fahrenheit"}},"key":"F","names":["F","F.","°F"]},{"category":"","mappings":{"default":{"default":"Celsius","alternative":"Centigrade"}},"key":"C","names":["C","°C"]},{"category":"","mappings":{"default":{"default":"Kelvin"}},"key":"K","names":["K","°K"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/time.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"time","mappings":{"default":{"default":"nanoseconds"}},"key":"ns","names":["ns"]},{"category":"time","mappings":{"default":{"default":"microseconds"}},"key":"µs","names":["µs"]},{"category":"time","mappings":{"default":{"default":"milliseconds"}},"key":"ms","names":["ms"]},{"category":"time","mappings":{"default":{"default":"seconds"}},"key":"s","names":["s"]},{"category":"time","mappings":{"default":{"default":"minutes"}},"key":"min","names":["min"]},{"category":"time","mappings":{"default":{"default":"hours"}},"key":"h","names":["h","hr"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/volume.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"volume","mappings":{"default":{"default":"barrels"}},"key":"bbl","names":["bbl.","bbl"]},{"category":"volume","mappings":{"default":{"default":"cubics"}},"key":"cu","names":["cu","cu."]},{"category":"volume","mappings":{"default":{"default":"fluid ounces"}},"key":"fl. oz.","names":["fl. oz."]},{"category":"volume","mappings":{"default":{"default":"gallons"}},"key":"gal","names":["gal","gal."]},{"category":"volume","mappings":{"default":{"default":"pints"}},"key":"pt","names":["pt","pt."]},{"category":"volume","mappings":{"default":{"default":"quarts"}},"key":"qt","names":["qt","qt."]},{"category":"volume","mappings":{"default":{"default":"tablespoons"}},"key":"tbsp","names":["tbsp","tbsp."]},{"category":"volume","mappings":{"default":{"default":"teaspoons"}},"key":"tsp","names":["tsp","tsp."]},{"category":"volume","mappings":{"default":{"default":"cubic centimeters"}},"key":"cc","names":["cc"]},{"category":"volume","mappings":{"default":{"default":"kiloliters"}},"key":"kl","names":["kl"]},{"category":"volume","mappings":{"default":{"default":"liters"}},"key":"l","names":["l"]},{"category":"volume","mappings":{"default":{"default":"milliliters"}},"key":"ml","names":["ml"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/en/units/weight.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"en"},{"category":"","mappings":{"default":{"default":"pounds"}},"key":"lb","names":["lb","lb."]},{"category":"","mappings":{"default":{"default":"long tons"}},"key":"LT","names":["LT","L.T."]},{"category":"","mappings":{"default":{"default":"ounces"}},"key":"oz","names":["oz","oz."]},{"key":"µg","names":["µg","mcg"],"mappings":{"default":{"default":"micrograms"}}},{"category":"","mappings":{"default":{"default":"grams"}},"key":"gr","names":["g","gr"]},{"category":"","mappings":{"default":{"default":"kilograms"}},"key":"kg","names":["kg"]},{"category":"","mappings":{"default":{"default":"micrograms"}},"key":"mcg","names":["mg","µg"]},{"category":"","mappings":{"default":{"default":"milligrams"}},"key":"mg","names":["mg"]},{"category":"","mappings":{"default":{"default":"tons"}},"key":"t","names":["t","T"]}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/es/functions/algebra.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"es"},{"key":"deg","names":["deg"],"mappings":{"default":{"default":"grados"}},"category":"Algebra"},{"key":"det","names":["det"],"mappings":{"default":{"default":"determinante"}},"category":"Algebra"},{"key":"dim","names":["dim"],"mappings":{"default":{"default":"dimensión"}},"category":"Algebra"},{"key":"hom","names":["hom","Hom"],"mappings":{"default":{"default":"homomorfismo"}},"category":"Algebra"},{"key":"ker","names":["ker"],"mappings":{"default":{"default":"kernel"}},"category":"Algebra"},{"key":"Tr","names":["Tr","tr"],"mappings":{"default":{"default":"traza"}},"category":"Algebra"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/es/functions/elementary.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"es"},{"key":"log","names":["log"],"mappings":{"default":{"default":"logaritmo"}},"category":"Logarithm"},{"key":"ln","names":["ln"],"mappings":{"default":{"default":"logaritmo neperiano"}},"category":"Logarithm"},{"key":"lg","names":["lg"],"mappings":{"default":{"default":"logaritmo base 10"}},"category":"Logarithm"},{"key":"exp","names":["exp","expt"],"mappings":{"default":{"default":"exponente"}},"category":"Elementary"},{"key":"gcd","names":["gcd"],"mappings":{"default":{"default":"MCD"}},"category":"Elementary"},{"key":"lcm","names":["lcm"],"mappings":{"default":{"default":"mcm"}},"category":"Elementary"},{"key":"arg","names":["arg"],"mappings":{"default":{"default":"argumento"}},"category":"Complex"},{"key":"im","names":["im"],"mappings":{"default":{"default":"parte imaginaria"}},"category":"Complex"},{"key":"re","names":["re"],"mappings":{"default":{"default":"residuo"}},"category":"Complex"},{"key":"inf","names":["inf"],"mappings":{"default":{"default":"extremo inferior"}},"category":"Limits"},{"key":"lim","names":["lim"],"mappings":{"default":{"default":"límite"}},"category":"Limits"},{"key":"max","names":["max"],"mappings":{"default":{"default":"máximo"}},"category":"Limits"},{"key":"min","names":["min"],"mappings":{"default":{"default":"mínimo"}},"category":"Limits"},{"key":"sup","names":["sup"],"mappings":{"default":{"default":"superior"}},"category":"Limits"},{"key":"lim inf","names":["lim inf","liminf"],"mappings":{"default":{"default":"límite inferior"}},"category":"Limits"},{"key":"lim sup","names":["lim sup","limsup"],"mappings":{"default":{"default":"límite superior"}},"category":"Limits"},{"key":"injlim","names":["injlim","inj lim"],"mappings":{"default":{"default":"límite directo"}},"category":"Limits"},{"key":"projlim","names":["projlim","proj lim"],"mappings":{"default":{"default":"límite inverso"}},"category":"Limits"},{"key":"mod","names":["mod"],"mappings":{"default":{"default":"módulo"}},"category":"Elementary"},{"key":"Pr","names":["Pr"],"mappings":{"default":{"default":"probabilidad"}},"category":"Probability"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/es/functions/hyperbolic.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"es"},{"key":"cosh","names":["cosh"],"mappings":{"default":{"default":"coseno hiperbólico"}},"category":"Hyperbolic"},{"key":"coth","names":["coth"],"mappings":{"default":{"default":"cotangente hiperbólica"}},"category":"Hyperbolic"},{"key":"csch","names":["csch"],"mappings":{"default":{"default":"cosecante hiperbólica"}},"category":"Hyperbolic"},{"key":"sech","names":["sech"],"mappings":{"default":{"default":"secante hiperbólica"}},"category":"Hyperbolic"},{"key":"sinh","names":["sinh"],"mappings":{"default":{"default":"seno hiperbólico"}},"category":"Hyperbolic"},{"key":"tanh","names":["tanh"],"mappings":{"default":{"default":"tangente hiperbólica"}},"category":"Hyperbolic"},{"key":"arcosh","names":["arcosh","arccosh"],"mappings":{"default":{"default":"area coseno hiperbólico"}},"category":"Area"},{"key":"arcoth","names":["arcoth","arccoth"],"mappings":{"default":{"default":"area cotangente hiperbólica"}},"category":"Area"},{"key":"arcsch","names":["arcsch","arccsch"],"mappings":{"default":{"default":"area cosecante hiperbólica"}},"category":"Area"},{"key":"arsech","names":["arsech","arcsech"],"mappings":{"default":{"default":"area secante hiperbólica"}},"category":"Area"},{"key":"arsinh","names":["arsinh","arcsinh"],"mappings":{"default":{"default":"area seno hiperbólico"}},"category":"Area"},{"key":"artanh","names":["artanh","arctanh"],"mappings":{"default":{"default":"area tangente hiperbólica"}},"category":"Area"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/es/functions/trigonometry.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"es"},{"key":"cos","names":["cos","cosine"],"mappings":{"default":{"default":"coseno"}},"category":"Trigonometric"},{"key":"cot","names":["cot"],"mappings":{"default":{"default":"cotangente"}},"category":"Trigonometric"},{"key":"csc","names":["csc"],"mappings":{"default":{"default":"cosecante"}},"category":"Trigonometric"},{"key":"sec","names":["sec"],"mappings":{"default":{"default":"secant"}},"category":"Trigonometric"},{"key":"sin","names":["sin","sine","sen"],"mappings":{"default":{"default":"seno"}},"category":"Trigonometric"},{"key":"tan","names":["tan"],"mappings":{"default":{"default":"tangente"}},"category":"Trigonometric"},{"key":"arccos","names":["arccos"],"mappings":{"default":{"default":"arco coseno"}},"category":"Cyclometric"},{"key":"arccot","names":["arccot"],"mappings":{"default":{"default":"arco cotangente"}},"category":"Cyclometric"},{"key":"arccsc","names":["arccsc"],"mappings":{"default":{"default":"arco cosecante"}},"category":"Cyclometric"},{"key":"arcsec","names":["arcsec"],"mappings":{"default":{"default":"arco secante"}},"category":"Cyclometric"},{"key":"arcsin","names":["arcsin"],"mappings":{"default":{"default":"arco seno"}},"category":"Cyclometric"},{"key":"arctan","names":["arctan"],"mappings":{"default":{"default":"arco tangente"}},"category":"Cyclometric"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/es/symbols/greek-capital.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"es"},{"key":"0391","mappings":{"default":{"default":"mayúscula Alfa"}},"category":"Lu"},{"key":"0392","mappings":{"default":{"default":"mayúscula Beta"}},"category":"Lu"},{"key":"0393","mappings":{"default":{"default":"mayúscula Gamma"}},"category":"Lu"},{"key":"0394","mappings":{"default":{"default":"mayúscula Delta"}},"category":"Lu"},{"key":"0395","mappings":{"default":{"default":"mayúscula Épsilon"}},"category":"Lu"},{"key":"0396","mappings":{"default":{"default":"mayúscula Zeta"}},"category":"Lu"},{"key":"0397","mappings":{"default":{"default":"mayúscula Eta"}},"category":"Lu"},{"key":"0398","mappings":{"default":{"default":"mayúscula Theta"}},"category":"Lu"},{"key":"0399","mappings":{"default":{"default":"mayúscula Iota"}},"category":"Lu"},{"key":"039A","mappings":{"default":{"default":"mayúscula Kappa"}},"category":"Lu"},{"key":"039B","mappings":{"default":{"default":"mayúscula Lambda"}},"category":"Lu"},{"key":"039C","mappings":{"default":{"default":"mayúscula Mi"}},"category":"Lu"},{"key":"039D","mappings":{"default":{"default":"mayúscula Ni"}},"category":"Lu"},{"key":"039E","mappings":{"default":{"default":"mayúscula Xi"}},"category":"Lu"},{"key":"039F","mappings":{"default":{"default":"mayúscula Ómicron"}},"category":"Lu"},{"key":"03A0","mappings":{"default":{"default":"mayúscula Pi"}},"category":"Lu"},{"key":"03A1","mappings":{"default":{"default":"mayúscula Rho"}},"category":"Lu"},{"key":"03A3","mappings":{"default":{"default":"mayúscula Sigma"}},"category":"Lu"},{"key":"03A4","mappings":{"default":{"default":"mayúscula Tau"}},"category":"Lu"},{"key":"03A5","mappings":{"default":{"default":"mayúscula Ípsilon"}},"category":"Lu"},{"key":"03A6","mappings":{"default":{"default":"mayúscula Phi"}},"category":"Lu"},{"key":"03A7","mappings":{"default":{"default":"mayúscula Ji"}},"category":"Lu"},{"key":"03A8","mappings":{"default":{"default":"mayúscula Psi"}},"category":"Lu"},{"key":"03A9","mappings":{"default":{"default":"mayúscula Omega"}},"category":"Lu"}]

1
web/assets/MathJax/unpacked/extensions/a11y/mathmaps/es/symbols/greek-mathfonts-bold.js vendored Normal file
View File

@@ -0,0 +1 @@
[{"locale":"es"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Alfa"}},"key":"1D6A8"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Beta"}},"key":"1D6A9"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Gamma"}},"key":"1D6AA"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Delta"}},"key":"1D6AB"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Épsilon"}},"key":"1D6AC"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Zeta"}},"key":"1D6AD"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Eta"}},"key":"1D6AE"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Theta"}},"key":"1D6AF"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Iota"}},"key":"1D6B0"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Kappa"}},"key":"1D6B1"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Lambda"}},"key":"1D6B2"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Mi"}},"key":"1D6B3"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Ni"}},"key":"1D6B4"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Xi"}},"key":"1D6B5"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Ómicron"}},"key":"1D6B6"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Pi"}},"key":"1D6B7"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Rho"}},"key":"1D6B8"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Sigma"}},"key":"1D6BA"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Tau"}},"key":"1D6BB"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Ípsilon"}},"key":"1D6BC"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Phi"}},"key":"1D6BD"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Ji"}},"key":"1D6BE"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Psi"}},"key":"1D6BF"},{"category":"Lu","mappings":{"default":{"default":"negrita mayúscula Omega"}},"key":"1D6C0"},{"category":"Ll","mappings":{"default":{"default":"negrita alfa"}},"key":"1D6C2"},{"category":"Ll","mappings":{"default":{"default":"negrita beta"}},"key":"1D6C3"},{"category":"Ll","mappings":{"default":{"default":"negrita gamma"}},"key":"1D6C4"},{"category":"Ll","mappings":{"default":{"default":"negrita delta"}},"key":"1D6C5"},{"category":"Ll","mappings":{"default":{"default":"negrita épsilon"}},"key":"1D6C6"},{"category":"Ll","mappings":{"default":{"default":"negrita zeta"}},"key":"1D6C7"},{"category":"Ll","mappings":{"default":{"default":"negrita eta"}},"key":"1D6C8"},{"category":"Ll","mappings":{"default":{"default":"negrita theta"}},"key":"1D6C9"},{"category":"Ll","mappings":{"default":{"default":"negrita iota"}},"key":"1D6CA"},{"category":"Ll","mappings":{"default":{"default":"negrita kappa"}},"key":"1D6CB"},{"category":"Ll","mappings":{"default":{"default":"negrita lambda"}},"key":"1D6CC"},{"category":"Ll","mappings":{"default":{"default":"negrita mi"}},"key":"1D6CD"},{"category":"Ll","mappings":{"default":{"default":"negrita ni"}},"key":"1D6CE"},{"category":"Ll","mappings":{"default":{"default":"negrita xi"}},"key":"1D6CF"},{"category":"Ll","mappings":{"default":{"default":"negrita ómicron"}},"key":"1D6D0"},{"category":"Ll","mappings":{"default":{"default":"negrita pi"}},"key":"1D6D1"},{"category":"Ll","mappings":{"default":{"default":"negrita rho"}},"key":"1D6D2"},{"category":"Ll","mappings":{"default":{"default":"negrita final sigma"}},"key":"1D6D3"},{"category":"Ll","mappings":{"default":{"default":"negrita sigma"}},"key":"1D6D4"},{"category":"Ll","mappings":{"default":{"default":"negrita tau"}},"key":"1D6D5"},{"category":"Ll","mappings":{"default":{"default":"negrita ípsilon"}},"key":"1D6D6"},{"category":"Ll","mappings":{"default":{"default":"negrita phi"}},"key":"1D6D7"},{"category":"Ll","mappings":{"default":{"default":"negrita ji"}},"key":"1D6D8"},{"category":"Ll","mappings":{"default":{"default":"negrita psi"}},"key":"1D6D9"},{"category":"Ll","mappings":{"default":{"default":"negrita omega"}},"key":"1D6DA"}]

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