MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

refactor jupyter notebook markdown cell evaluation

Browse Source 
PY-20041 Sometimes markdown cell fails to render on opening
 PY-14123 IPython Notebook: Markdown: too greedy link highlighting for several square brackets on the line
 PY-15152 IPython Notebook: Markdown: too much padding on the top of the cell
 PY-18625 ipynb files performance problems
 PY-19110 jupyter markdown not rendering
 PY-19367 Ipython Jupyter viewer does not support html display
 PY-20040 Too much whitespace in markdown cells
 PY-20068 title and list are not rendered correctly
This commit is contained in:
Ekaterina Tuzova
2016-10-19 17:00:38 +03:00
parent 654a5e87fc
commit 49bf35efc6
1216 changed files with 179805 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build/groovy/org/jetbrains/intellij/build/CommunityLibraryLicenses.groovy
+2
View File
@@ -248,6 +248,8 @@ class CommunityLibraryLicenses {
licenseUrl: "http://www.opensource.org/licenses/bsd-license.php"),
new LibraryLicense(name: "markdownj", libraryName: "markdownj", version: "0.4.2", license: "New BSD",
url: "https://github.com/myabc/markdownj", licenseUrl: "http://opensource.org/licenses/BSD-3-Clause"),
new LibraryLicense(name: "MathJax", libraryName: "MathJax", version: "2.6.1", license: "Apache-2.0",
url: "git://github.com/mathjax/MathJax", licenseUrl: "https://github.com/mathjax/MathJax/blob/master/LICENSE"),
new LibraryLicense(name: "maven-2.2.1-uber", version: "2.2.1", libraryName: "maven-2.2.1-uber.jar", license: "Apache 2.0",
url: "http://maven.apache.org/", licenseUrl: "http://www.apache.org/licenses/LICENSE-2.0"),
new LibraryLicense(name: "maven-artifact", version: "3.0.5", libraryName: "maven-artifact-3.0.5.jar", license: "Apache 2.0",
python/ipnb/ipnb.iml
+1 -1
View File
@@ -14,7 +14,6 @@
<orderEntry type="module" module-name="lang-impl" />
<orderEntry type="library" name="Guava" level="project" />
<orderEntry type="library" name="gson" level="project" />
<orderEntry type="library" name="markdownj" level="project" />
<orderEntry type="library" scope="TEST" name="JUnit4" level="project" />
<orderEntry type="module-library">
<library>
@@ -25,5 +24,6 @@
<SOURCES />
</library>
</orderEntry>
<orderEntry type="library" name="markdown4j-2.2" level="project" />
</component>
</module>
python/ipnb/resources/MathJax/MathJax.js
Vendored
+3273
View File
File diff suppressed because it is too large Load Diff
python/ipnb/resources/MathJax/config/AM_CHTML-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/AM_CHTML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/AsciiMath","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/AM_CHTML-full.js");
python/ipnb/resources/MathJax/config/AM_CHTML.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/AM_CHTML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/AsciiMath","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/AM_CHTML.js");
python/ipnb/resources/MathJax/config/AM_HTMLorMML-full.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/AM_HTMLorMML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/AsciiMath","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/AM_HTMLorMML-full.js");
python/ipnb/resources/MathJax/config/AM_HTMLorMML.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/AM_HTMLorMML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/AsciiMath","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/AM_HTMLorMML.js");
python/ipnb/resources/MathJax/config/AM_SVG-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/AM_SVG-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/AsciiMath","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/AM_SVG-full.js");
python/ipnb/resources/MathJax/config/AM_SVG.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/AM_SVG.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/AsciiMath","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/AM_SVG.js");
python/ipnb/resources/MathJax/config/Accessible-full.js
Vendored
+33
View File
@@ -0,0 +1,33 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/Accessible-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["tex2jax.js","mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","output/HTML-CSS","output/NativeMML","output/PreviewHTML"],
menuSettings: {
zoom: "Double-Click",
mpContext: true,
mpMouse: true
},
errorSettings: {
message: ["[",["MathError","Math Error"],"]"]
}
});
MathJax.Ajax.loadComplete("[MathJax]/config/Accessible-full.js");
python/ipnb/resources/MathJax/config/Accessible.js
Vendored
+33
View File
@@ -0,0 +1,33 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/Accessible.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["tex2jax.js","mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","output/HTML-CSS","output/NativeMML","output/PreviewHTML"],
menuSettings: {
zoom: "Double-Click",
mpContext: true,
mpMouse: true
},
errorSettings: {
message: ["[",["MathError","Math Error"],"]"]
}
});
MathJax.Ajax.loadComplete("[MathJax]/config/Accessible.js");
python/ipnb/resources/MathJax/config/MML_CHTML-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/MML_CHTML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/MathML","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/MML_CHTML-full.js");
python/ipnb/resources/MathJax/config/MML_CHTML.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/MML_CHTML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/MathML","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/MML_CHTML.js");
python/ipnb/resources/MathJax/config/MML_HTMLorMML-full.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/MML_HTMLorMML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/MathML","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/MML_HTMLorMML-full.js");
python/ipnb/resources/MathJax/config/MML_HTMLorMML.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/MML_HTMLorMML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/MathML","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/MML_HTMLorMML.js");
python/ipnb/resources/MathJax/config/MML_SVG-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/MML_SVG-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/MathML","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/MML_SVG-full.js");
python/ipnb/resources/MathJax/config/MML_SVG.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/MML_SVG.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/MathML","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/MML_SVG.js");
python/ipnb/resources/MathJax/config/MMLorHTML.js
Vendored
+111
View File
@@ -0,0 +1,111 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/config/MMLorHTML.js
*
* Chooses between the NativeMML and HTML-CSS output jax depending
* on the capabilities of the browser and configuration settings
* of the page.
*
* This file should be added to the config array when configuring
* MathJax. Note that if you include this, you should NOT include
* an output jax in the jax array (it will be added for you by
* this file).
*
* You can specify the preferred output jax on a global or
* browser-by-browser basis. To specify it globally, use
*
* MathJax.Hub.Config({
* MMLorHTML: {prefer: "MML"} // or "HTML"
* });
*
* To specify on a browser-by-borwser basis, use
*
* MathJax.Hub.Config({
* MMLorHTML: {prefer: {
* MSIE: "MML",
* Firefox: "MML",
* Opera: "HTML",
* other: "HTML"
* }}
* });
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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,BROWSER) {
var VERSION = "2.6.0";
var CONFIG = MathJax.Hub.CombineConfig("MMLorHTML",{
prefer: {
MSIE:"MML",
Firefox:"HTML",
Opera:"HTML",
Chrome:"HTML",
Safari:"HTML",
other:"HTML"
}
});
var MINBROWSERVERSION = {
Firefox: 3.0,
Opera: 9.52,
MSIE: 6.0,
Chrome: 0.3,
Safari: 2.0,
Konqueror: 4.0
};
var canUseHTML = (BROWSER.version === "0.0" ||
BROWSER.versionAtLeast(MINBROWSERVERSION[BROWSER]||0.0));
var canUseMML = (BROWSER.isFirefox && BROWSER.versionAtLeast("1.5")) ||
(BROWSER.isMSIE && BROWSER.hasMathPlayer) ||
(BROWSER.isSafari && BROWSER.versionAtLeast("5.0")) ||
(BROWSER.isOpera && BROWSER.versionAtLeast("9.52"));
HUB.Register.StartupHook("End Config",function () {
var prefer = (CONFIG.prefer && typeof(CONFIG.prefer) === "object" ?
CONFIG.prefer[MathJax.Hub.Browser]||CONFIG.prefer.other||"HTML" :
CONFIG.prefer);
if (canUseHTML || canUseMML) {
if (canUseMML && (prefer === "MML" || !canUseHTML)) {
if (MathJax.OutputJax.NativeMML) {MathJax.OutputJax.NativeMML.Register("jax/mml")}
else {HUB.config.jax.unshift("output/NativeMML")}
HUB.Startup.signal.Post("NativeMML output selected");
} else {
if (MathJax.OutputJax["HTML-CSS"]) {MathJax.OutputJax["HTML-CSS"].Register("jax/mml")}
else {HUB.config.jax.unshift("output/HTML-CSS")}
HUB.Startup.signal.Post("HTML-CSS output selected");
}
} else {
HUB.PreProcess.disabled = true;
HUB.prepareScripts.disabled = true;
MathJax.Message.Set(
["MathJaxNotSupported","Your browser does not support MathJax"],
null,4000
);
HUB.Startup.signal.Post("MathJax not supported");
}
});
})(MathJax.Hub,MathJax.Hub.Browser);
MathJax.Ajax.loadComplete("[MathJax]/config/MMLorHTML.js");
python/ipnb/resources/MathJax/config/Safe.js
Vendored
+37
View File
@@ -0,0 +1,37 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/config/Safe.js
*
* Allows you to load the Safe extension as part of the config list
* when you load MathJax.js, e.g.
*
* <script
* src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML,Safe">
* </script>
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2013-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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("End Config", function () {
if (!MathJax.Hub.config.extensions) {MathJax.Hub.config.extensions = []}
MathJax.Hub.config.extensions.push("Safe.js");
});
MathJax.Ajax.loadComplete("[MathJax]/config/Safe.js");
python/ipnb/resources/MathJax/config/TeX-AMS-MML_HTMLorMML-full.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS-MML_HTMLorMML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["tex2jax.js","mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS-MML_HTMLorMML-full.js");
python/ipnb/resources/MathJax/config/TeX-AMS-MML_HTMLorMML.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS-MML_HTMLorMML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["tex2jax.js","mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS-MML_HTMLorMML.js");
python/ipnb/resources/MathJax/config/TeX-AMS-MML_SVG-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS-MML_SVG-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS-MML_SVG-full.js");
python/ipnb/resources/MathJax/config/TeX-AMS-MML_SVG.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS-MML_SVG.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","mml2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS-MML_SVG.js");
python/ipnb/resources/MathJax/config/TeX-AMS_CHTML-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS_CHTML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS_CHTML-full.js");
python/ipnb/resources/MathJax/config/TeX-AMS_CHTML.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS_CHTML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS_CHTML.js");
python/ipnb/resources/MathJax/config/TeX-AMS_HTML-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS_HTML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","output/HTML-CSS","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS_HTML-full.js");
python/ipnb/resources/MathJax/config/TeX-AMS_HTML.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS_HTML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","output/HTML-CSS","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS_HTML.js");
python/ipnb/resources/MathJax/config/TeX-AMS_SVG-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS_SVG-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS_SVG-full.js");
python/ipnb/resources/MathJax/config/TeX-AMS_SVG.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-AMS_SVG.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-AMS_SVG.js");
python/ipnb/resources/MathJax/config/TeX-MML-AM_CHTML-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-MML-AM_CHTML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-MML-AM_CHTML-full.js");
python/ipnb/resources/MathJax/config/TeX-MML-AM_CHTML.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-MML-AM_CHTML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/CommonHTML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-MML-AM_CHTML.js");
python/ipnb/resources/MathJax/config/TeX-MML-AM_HTMLorMML-full.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-MML-AM_HTMLorMML-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-MML-AM_HTMLorMML-full.js");
python/ipnb/resources/MathJax/config/TeX-MML-AM_HTMLorMML.js
Vendored
+25
View File
@@ -0,0 +1,25 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-MML-AM_HTMLorMML.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
config: ["MMLorHTML.js"],
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/HTML-CSS","output/NativeMML","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-MML-AM_HTMLorMML.js");
python/ipnb/resources/MathJax/config/TeX-MML-AM_SVG-full.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-MML-AM_SVG-full.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-MML-AM_SVG-full.js");
python/ipnb/resources/MathJax/config/TeX-MML-AM_SVG.js
Vendored
+24
View File
@@ -0,0 +1,24 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* /MathJax/unpacked/config/TeX-MML-AM_SVG.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Config({
extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathEvents.js","MathZoom.js","MathMenu.js","toMathML.js","TeX/noErrors.js","TeX/noUndefined.js","TeX/AMSmath.js","TeX/AMSsymbols.js","fast-preview.js","AssistiveMML.js"],
jax: ["input/TeX","input/MathML","input/AsciiMath","output/SVG","output/PreviewHTML"]
});
MathJax.Ajax.loadComplete("[MathJax]/config/TeX-MML-AM_SVG.js");
python/ipnb/resources/MathJax/config/default.js
Vendored
+1116
View File
File diff suppressed because it is too large Load Diff
python/ipnb/resources/MathJax/config/local/local.js
Vendored
+40
View File
@@ -0,0 +1,40 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/config/local/local.js
*
* Include changes and configuration local to your installation
* in this file. For example, common macros can be defined here
* (see below). To use this file, add "local/local.js" to the
* config array in MathJax.js or your MathJax.Hub.Config() call.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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 TEX = MathJax.InputJax.TeX;
// place macros here. E.g.:
// TEX.Macro("R","{\\bf R}");
// TEX.Macro("op","\\mathop{\\rm #1}",1); // a macro with 1 parameter
});
MathJax.Ajax.loadComplete("[MathJax]/config/local/local.js");
python/ipnb/resources/MathJax/extensions/AssistiveMML.js
Vendored
+160
View File
@@ -0,0 +1,160 @@
/* -*- 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 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.1",
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" && 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" : "")
});
span.innerHTML = mml;
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]);
}
);
python/ipnb/resources/MathJax/extensions/CHTML-preview.js
Vendored
+30
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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"]
);
python/ipnb/resources/MathJax/extensions/FontWarnings.js
Vendored
+313
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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 (data[i] instanceof Array) {
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");
python/ipnb/resources/MathJax/extensions/HTML-CSS/handle-floats.js
Vendored
+82
View File
@@ -0,0 +1,82 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
//
// Make the display DIV be a table-cell
// Use padding to get the separation, since table cells don't do margin
// Make the width large (it will shrink to fit the remaining room)
//
MathJax.Hub.Config({
"HTML-CSS": {
styles: {
".MathJax_Display": {
display: "table-cell",
padding: "1em 0 ! important",
width: (MathJax.Hub.Browser.isMSIE && (document.documentMode||0) < 8 ? "100%" : "1000em")
}
}
}
});
//
// Two consecutive equations would end up side-by-side, so force a separator
// (Needed by IE8, IE9, and Firefox, at least).
//
MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var HTMLCSS = MathJax.OutputJax["HTML-CSS"],
TRANSLATE = HTMLCSS.Translate;
HTMLCSS.Augment({
Translate: function (script,state) {
TRANSLATE.apply(this,arguments);
if (script.MathJax.elementJax.HTMLCSS.display) {
var next = script.nextSibling;
if (!next || next.className !== "MathJax_MSIE_Separator") {
var span = HTMLCSS.Element("span",{className:"MathJax_MSIE_Separator"});
script.parentNode.insertBefore(span,next);
}
}
}
});
MathJax.Hub.Startup.signal.Post("HTML-CSS handle-floats Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/HTML-CSS/handle-floats.js");
python/ipnb/resources/MathJax/extensions/HelpDialog.js
Vendored
+203
View File
@@ -0,0 +1,203 @@
/*************************************************************
*
* MathJax/extensions/HelpDialog.js
*
* Implements the MathJax Help dialog box.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2013-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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,"HelpDialig Ready"],
["loadComplete",AJAX,"[MathJax]/extensions/HelpDialog.js"]
);
})(MathJax.Hub,MathJax.HTML,MathJax.Ajax,MathJax.OutputJax,MathJax.Localization);
python/ipnb/resources/MathJax/extensions/MatchWebFonts.js
Vendored
+309
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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);
python/ipnb/resources/MathJax/extensions/MathEvents.js
Vendored
+619
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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);
python/ipnb/resources/MathJax/extensions/MathML/content-mathml.js
Vendored
+1730
View File
File diff suppressed because it is too large Load Diff
python/ipnb/resources/MathJax/extensions/MathML/mml3.js
Vendored
+784
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/MathMenu.js
Vendored
+1657
View File
File diff suppressed because it is too large Load Diff
python/ipnb/resources/MathJax/extensions/MathZoom.js
Vendored
+366
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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);
python/ipnb/resources/MathJax/extensions/Safe.js
Vendored
+348
View File
@@ -0,0 +1,348 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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
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
}
});
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;
STYLE1.cssText = styles; STYLE2.cssText = "";
//
// Check each allowed style and transfer OK ones to div2
//
for (var name in CONFIG.safeStyles) {if (CONFIG.safeStyles.hasOwnProperty(name)) {
var value = this.filterStyle(name,STYLE1[name]);
if (value != null) {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,value) {
if (typeof value !== "string") {return null}
if (value.match(/^\s*expression/)) {return null}
if (value.match(/javascript:/)) {return null}
return (CONFIG.safeStyles[name] ? value : null);
},
//
// 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)}
});
});
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);
python/ipnb/resources/MathJax/extensions/TeX/AMScd.js
Vendored
+158
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0",
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");
python/ipnb/resources/MathJax/extensions/TeX/AMSmath.js
Vendored
+641
View File
@@ -0,0 +1,641 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.1",
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(" ");
};
/******************************************************************************/
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': ['2223',{texClass:MML.TEXCLASS.OPEN}],
'\\rvert': ['2223',{texClass:MML.TEXCLASS.CLOSE}],
'\\lVert': ['2225',{texClass:MML.TEXCLASS.OPEN}],
'\\rVert': ['2225',{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), "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);
op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
TEX.Definitions.macros[cs] = ['Macro','\\mathop{\\rm '+op+'}'+limits];
},
HandleOperatorName: function (name) {
var limits = (this.GetStar() ? "" : "\\nolimits\\SkipLimits");
var op = this.trimSpaces(this.GetArgument(name));
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" || 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>, preceed 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.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 && !stack.global.forcetag; // prevent automatic tagging in starred environments
},
EndEntry: function () {
if (this.row.length) {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.tag && !this.global.notags) {
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 maintainance.
*/
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");
python/ipnb/resources/MathJax/extensions/TeX/AMSsymbols.js
Vendored
+349
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/TeX/HTML.js
Vendored
+106
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/TeX/action.js
Vendored
+83
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/TeX/autobold.js
Vendored
+50
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/TeX/autoload-all.js
Vendored
+83
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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"]
);
python/ipnb/resources/MathJax/extensions/TeX/bbox.js
Vendored
+101
View File
@@ -0,0 +1,101 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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 = match[1]+match[3];
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}
});
MathJax.Hub.Startup.signal.Post("TeX bbox Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/bbox.js");
python/ipnb/resources/MathJax/extensions/TeX/begingroup.js
Vendored
+309
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/TeX/begingroup.js
*
* Implements \begingroup and \endgroup commands that make local
* definitions possible and are removed when the \endgroup occurs.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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][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 (!(value instanceof Array)) {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: ["Extension","newcommand"],
gdef: ["Extension","newcommand"]
}
},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"));
}
});
/****************************************************/
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.Register.StartupHook("TeX newcommand Ready",function () {
//
// Add the commands that depend on the newcommand code
//
TEXDEF.Add({
macros: {
global: "Global",
gdef: ["Macro","\\global\\def"]
}
},null,true);
TEX.Parse.Augment({
//
// 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") {
TEX.Error(["GlobalNotFollowedBy",
"%1 not followed by \\let, \\def, or \\newcommand",name]);
}
this.stack.env.isGlobal = true;
}
});
});
MathJax.Hub.Startup.signal.Post("TeX begingroup Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/begingroup.js");
python/ipnb/resources/MathJax/extensions/TeX/boldsymbol.js
Vendored
+75
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/TeX/cancel.js
Vendored
+110
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0",
//
// 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");
python/ipnb/resources/MathJax/extensions/TeX/color.js
Vendored
+281
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0",
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[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");
python/ipnb/resources/MathJax/extensions/TeX/enclose.js
Vendored
+91
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0",
//
// 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");
python/ipnb/resources/MathJax/extensions/TeX/extpfeil.js
Vendored
+102
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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);
TEXDEF.macros[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");
python/ipnb/resources/MathJax/extensions/TeX/mathchoice.js
Vendored
+107
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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");
python/ipnb/resources/MathJax/extensions/TeX/mediawiki-texvc.js
Vendored
+106
View File
@@ -0,0 +1,106 @@
MathJax.Extension["TeX/mediawiki-texvc"] = {
version: "2.6.0-beta.2"
};
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"],
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"],
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"],
varcoppa: ["Macro", "\u03D9"],
varstigma: ["Macro", "\u03DB"],
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");
python/ipnb/resources/MathJax/extensions/TeX/mhchem.js
Vendored
+494
View File
@@ -0,0 +1,494 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/mhchem"] = {
version: "2.6.0"
};
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 preceeding 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");
python/ipnb/resources/MathJax/extensions/TeX/newcommand.js
Vendored
+269
View File
@@ -0,0 +1,269 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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[name]) {macro = ["csMathchar0mi",TEXDEF.mathchar0mi[name]]} else
if (TEXDEF.mathchar0mo[name]) {macro = ["csMathchar0mo",TEXDEF.mathchar0mo[name]]} else
if (TEXDEF.mathchar7[name]) {macro = ["csMathchar7",TEXDEF.mathchar7[name]]} else
if (TEXDEF.delimiter["\\"+name] != null) {macro = ["csDelimiter",TEXDEF.delimiter["\\"+name]]}
}
} else {macro = ["Macro",c]; this.i++}
this.setDef(cs,macro);
},
/*
* Routines to set the macro and environment definitions
* (overridden by begingroup to make localized versions)
*/
setDef: function (name,value) {value.isUser = true; TEXDEF.macros[name] = value},
setEnv: function (name,value) {value.isUser = true; TEXDEF.environment[name] = value},
/*
* 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) {
if (this.string.charAt(this.i) === '{') {
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 {
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}
this.i += param.length;
return 1;
}
});
TEX.Environment = function (name) {
TEXDEF.environment[name] = ['BeginEnv','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");
python/ipnb/resources/MathJax/extensions/TeX/noErrors.js
Vendored
+405
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0";
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");
python/ipnb/resources/MathJax/extensions/TeX/noUndefined.js
Vendored
+72
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0",
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");
python/ipnb/resources/MathJax/extensions/TeX/unicode.js
Vendored
+167
View File
@@ -0,0 +1,167 @@
/* -*- 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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0",
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)),
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");
python/ipnb/resources/MathJax/extensions/TeX/verb.js
Vendored
+61
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-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.6.0"
};
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");
python/ipnb/resources/MathJax/extensions/asciimath2jax.js
Vendored
+239
View File
@@ -0,0 +1,239 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/asciimath2jax.js
*
* Implements the AsciiMath to Jax preprocessor that locates AsciiMath
* code within the text of a document and replaces it with SCRIPT tags for
* processing by MathJax.
*
* Modified by David Lippman, based on tex2jax.js.
* Additional work by Davide P. Cervone.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2012-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.asciimath2jax = {
version: "2.6.0",
config: {
delimiters: [['`','`']], // The star/stop delimiter pairs for asciimath code
skipTags: ["script","noscript","style","textarea","pre","code","annotation","annotation-xml"],
// The names of the tags whose contents will not be
// scanned for math delimiters
ignoreClass: "asciimath2jax_ignore", // the class name of elements whose contents should
// NOT be processed by asciimath2jax. Note that this
// is a regular expression, so be sure to quote any
// regexp special characters
processClass: "asciimath2jax_process", // the class name of elements whose contents SHOULD
// be processed when they appear inside ones that
// are ignored. Note that this is a regular expression,
// so be sure to quote any regexp special characters
preview: "AsciiMath" // set to "none" to not insert MathJax_Preview spans
// or set to an array specifying an HTML snippet
// to use the same preview for every equation.
},
PreProcess: function (element) {
if (!this.configured) {
this.config = MathJax.Hub.CombineConfig("asciimath2jax",this.config);
if (this.config.Augment) {MathJax.Hub.Insert(this,this.config.Augment)}
this.configured = true;
}
if (typeof(element) === "string") {element = document.getElementById(element)}
if (!element) {element = document.body}
if (this.createPatterns()) {this.scanElement(element,element.nextSibling)}
},
createPatterns: function () {
var starts = [], i, m, config = this.config; this.match = {};
if (config.delimiters.length === 0) {return false}
for (i = 0, m = config.delimiters.length; i < m; i++) {
starts.push(this.patternQuote(config.delimiters[i][0]));
this.match[config.delimiters[i][0]] = {
mode: "",
end: config.delimiters[i][1],
pattern: this.endPattern(config.delimiters[i][1])
};
}
this.start = new RegExp(starts.sort(this.sortLength).join("|"),"g");
this.skipTags = new RegExp("^("+config.skipTags.join("|")+")$","i");
var ignore = [];
if (MathJax.Hub.config.preRemoveClass) {ignore.push(MathJax.Hub.config.preRemoveClass)}
if (config.ignoreClass) {ignore.push(config.ignoreClass)}
this.ignoreClass = (ignore.length ? new RegExp("(^| )("+ignore.join("|")+")( |$)") : /^$/);
this.processClass = new RegExp("(^| )("+config.processClass+")( |$)");
return true;
},
patternQuote: function (s) {return s.replace(/([\^$(){}+*?\-|\[\]\:\\])/g,'\\$1')},
endPattern: function (end) {
return new RegExp(this.patternQuote(end)+"|\\\\.","g");
},
sortLength: function (a,b) {
if (a.length !== b.length) {return b.length - a.length}
return (a == b ? 0 : (a < b ? -1 : 1));
},
scanElement: function (element,stop,ignore) {
var cname, tname, ignoreChild, process;
while (element && element != stop) {
if (element.nodeName.toLowerCase() === '#text') {
if (!ignore) {element = this.scanText(element)}
} else {
cname = (typeof(element.className) === "undefined" ? "" : element.className);
tname = (typeof(element.tagName) === "undefined" ? "" : element.tagName);
if (typeof(cname) !== "string") {cname = String(cname)} // jsxgraph uses non-string class names!
process = this.processClass.exec(cname);
if (element.firstChild && !cname.match(/(^| )MathJax/) &&
(process || !this.skipTags.exec(tname))) {
ignoreChild = (ignore || this.ignoreClass.exec(cname)) && !process;
this.scanElement(element.firstChild,stop,ignoreChild);
}
}
if (element) {element = element.nextSibling}
}
},
scanText: function (element) {
if (element.nodeValue.replace(/\s+/,'') == '') {return element}
var match, prev;
this.search = {start: true};
this.pattern = this.start;
while (element) {
this.pattern.lastIndex = 0;
while (element && element.nodeName.toLowerCase() === '#text' &&
(match = this.pattern.exec(element.nodeValue))) {
if (this.search.start) {element = this.startMatch(match,element)}
else {element = this.endMatch(match,element)}
}
if (this.search.matched) {element = this.encloseMath(element)}
if (element) {
do {prev = element; element = element.nextSibling}
while (element && (element.nodeName.toLowerCase() === 'br' ||
element.nodeName.toLowerCase() === '#comment'));
if (!element || element.nodeName !== '#text') {return prev}
}
}
return element;
},
startMatch: function (match,element) {
var delim = this.match[match[0]];
if (delim != null) {
this.search = {
end: delim.end, mode: delim.mode,
open: element, olen: match[0].length,
opos: this.pattern.lastIndex - match[0].length
};
this.switchPattern(delim.pattern);
}
return element;
},
endMatch: function (match,element) {
if (match[0] == this.search.end) {
this.search.close = element;
this.search.cpos = this.pattern.lastIndex;
this.search.clen = (this.search.isBeginEnd ? 0 : match[0].length);
this.search.matched = true;
element = this.encloseMath(element);
this.switchPattern(this.start);
}
return element;
},
switchPattern: function (pattern) {
pattern.lastIndex = this.pattern.lastIndex;
this.pattern = pattern;
this.search.start = (pattern === this.start);
},
encloseMath: function (element) {
var search = this.search, close = search.close, CLOSE, math;
if (search.cpos === close.length) {close = close.nextSibling}
else {close = close.splitText(search.cpos)}
if (!close) {CLOSE = close = MathJax.HTML.addText(search.close.parentNode,"")}
search.close = close;
math = (search.opos ? search.open.splitText(search.opos) : search.open);
while (math.nextSibling && math.nextSibling !== close) {
if (math.nextSibling.nodeValue !== null) {
if (math.nextSibling.nodeName === "#comment") {
math.nodeValue += math.nextSibling.nodeValue.replace(/^\[CDATA\[((.|\n|\r)*)\]\]$/,"$1");
} else {
math.nodeValue += math.nextSibling.nodeValue;
}
} else if (this.msieNewlineBug) {
math.nodeValue += (math.nextSibling.nodeName.toLowerCase() === "br" ? "\n" : " ");
} else {
math.nodeValue += " ";
}
math.parentNode.removeChild(math.nextSibling);
}
var AM = math.nodeValue.substr(search.olen,math.nodeValue.length-search.olen-search.clen);
math.parentNode.removeChild(math);
if (this.config.preview !== "none") {this.createPreview(search.mode,AM)}
math = this.createMathTag(search.mode,AM);
this.search = {}; this.pattern.lastIndex = 0;
if (CLOSE) {CLOSE.parentNode.removeChild(CLOSE)}
return math;
},
insertNode: function (node) {
var search = this.search;
search.close.parentNode.insertBefore(node,search.close);
},
createPreview: function (mode,asciimath) {
var preview = this.config.preview;
if (preview === "none") return;
if (preview === "AsciiMath") {preview = [this.filterPreview(asciimath)]}
if (preview) {
preview = MathJax.HTML.Element("span",{className:MathJax.Hub.config.preRemoveClass},preview);
this.insertNode(preview);
}
},
createMathTag: function (mode,asciimath) {
var script = document.createElement("script");
script.type = "math/asciimath" + mode;
MathJax.HTML.setScript(script,asciimath);
this.insertNode(script);
return script;
},
filterPreview: function (asciimath) {return asciimath},
msieNewlineBug: (MathJax.Hub.Browser.isMSIE && (document.documentMode||0) < 9)
};
// We register the preprocessors with the following priorities:
// - mml2jax.js: 5
// - jsMath2jax.js: 8
// - asciimath2jax.js, tex2jax.js: 10 (default)
// See issues 18 and 484 and the other *2jax.js files.
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.asciimath2jax]);
MathJax.Ajax.loadComplete("[MathJax]/extensions/asciimath2jax.js");
python/ipnb/resources/MathJax/extensions/fast-preview.js
Vendored
+155
View File
@@ -0,0 +1,155 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/fast-preview.js
*
* Implements a fast preview using the PreviewHTML output jax
* and then a slower update to the more accurate HTML-CSS output
* (or whatever the user has selected).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2014-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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,BROWSER) {
var SETTINGS = HUB.config.menuSettings;
var JAX = MathJax.OutputJax;
var msieColorBug = BROWSER.isMSIE && (document.documentMode||0) < 8;
var FastPreview = MathJax.Extension["fast-preview"] = {
version: "2.6.0",
enabled: true,
//
// Configuration for the chunking of the main output
// after the previews have been created, and other configuration.
//
config: HUB.CombineConfig("fast-preview",{
Chunks: {EqnChunk: 10000, EqnChunkFactor: 1, EqnChunkDelay: 0},
color: "inherit!important",
updateTime: 30, updateDelay: 6,
messageStyle: "none",
disabled: BROWSER.isMSIE && !BROWSER.versionAtLeast("8.0")
}),
//
// Ajust the chunking of the output jax
//
Config: function () {
if (HUB.config["CHTML-preview"])
MathJax.Hub.Config({"fast-preview": HUB.config["CHTML-preview"]});
var update, delay, style, done, saved;
var config = this.config;
if (!config.disabled && SETTINGS.FastPreview == null)
HUB.Config({menuSettings:{FastPreview:true}});
if (SETTINGS.FastPreview) {
MathJax.Ajax.Styles({".MathJax_Preview .MJXf-math":{color:config.color}});
HUB.Config({"HTML-CSS": config.Chunks, CommonHTML: config.Chunks, SVG: config.Chunks});
}
HUB.Register.MessageHook("Begin Math Output",function () {
if (!done && FastPreview.Active()) {
update = HUB.processUpdateTime; delay = HUB.processUpdateDelay;
style = HUB.config.messageStyle;
HUB.processUpdateTime = config.updateTime;
HUB.processUpdateDelay = config.updateDelay;
HUB.Config({messageStyle: config.messageStyle});
MathJax.Message.Clear(0,0);
saved = true;
}
});
HUB.Register.MessageHook("End Math Output",function () {
if (!done && saved) {
HUB.processUpdateTime = update;
HUB.processUpdateDelay = delay;
HUB.Config({messageStyle: style});
done = true;
}
});
},
//
// Allow page to override user settings (for things like editor previews)
//
Disable: function () {this.enabled = false},
Enable: function () {this.enabled = true},
Active: function () {
return SETTINGS.FastPreview && this.enabled &&
!(JAX[SETTINGS.renderer]||{}).noFastPreview;
},
//
// Insert a preview span, if there isn't one already,
// and call the PreviewHTML output jax to create the preview
//
Preview: function (data) {
if (!this.Active()) return;
var preview = data.script.MathJax.preview || data.script.previousSibling;
if (!preview || preview.className !== MathJax.Hub.config.preRemoveClass) {
preview = HTML.Element("span",{className:MathJax.Hub.config.preRemoveClass});
data.script.parentNode.insertBefore(preview,data.script);
data.script.MathJax.preview = preview;
}
preview.innerHTML = "";
preview.style.color = (msieColorBug ? "black" : "inherit");
return this.postFilter(preview,data);
},
postFilter: function (preview,data) {
//
// Load the PreviewHTML jax if it is not already loaded
//
if (!data.math.root.toPreviewHTML) {
var queue = MathJax.Callback.Queue();
queue.Push(
["Require",MathJax.Ajax,"[MathJax]/jax/output/PreviewHTML/config.js"],
["Require",MathJax.Ajax,"[MathJax]/jax/output/PreviewHTML/jax.js"]
);
HUB.RestartAfter(queue.Push({}));
}
data.math.root.toPreviewHTML(preview);
},
//
// Hook into the input jax postFilter to create the previews as
// the input jax are processed.
//
Register: function (name) {
HUB.Register.StartupHook(name+" Jax Require",function () {
var jax = MathJax.InputJax[name];
jax.postfilterHooks.Add(["Preview",MathJax.Extension["fast-preview"]],50);
});
}
}
//
// Hook into each input jax
//
FastPreview.Register("TeX");
FastPreview.Register("MathML");
FastPreview.Register("AsciiMath");
HUB.Register.StartupHook("End Config",["Config",FastPreview]);
HUB.Startup.signal.Post("fast-preview Ready");
})(MathJax.Hub,MathJax.HTML,MathJax.Hub.Browser);
MathJax.Ajax.loadComplete("[MathJax]/extensions/fast-preview.js");
python/ipnb/resources/MathJax/extensions/jsMath2jax.js
Vendored
+102
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/jsMath2jax.js
*
* Implements a jsMath to Jax preprocessor that locates jsMath-style
* <SPAN CLASS="math">...</SPAN> and <DIV CLASS="math">...</DIV> tags
* and replaces them with SCRIPT tags for processing by MathJax.
* (Note: use the tex2jax preprocessor to convert TeX delimiters or
* custom delimiters to MathJax SCRIPT tags. This preprocessor is
* only for the SPAN and DIV form of jsMath delimiters).
*
* To use this preprocessor, include "jsMath2jax.js" in the extensions
* array in your config/MathJax.js file, or the MathJax.Hub.Config() call
* in your HTML document.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.jsMath2jax = {
version: "2.6.0",
config: {
preview: "TeX" // Set to "none" to prevent preview strings from being inserted
// or to an array that specifies an HTML snippet to use for
// the preview.
},
PreProcess: function (element) {
if (!this.configured) {
this.config = MathJax.Hub.CombineConfig("jsMath2jax",this.config);
if (this.config.Augment) {MathJax.Hub.Insert(this,this.config.Augment)}
if (typeof(this.config.previewTeX) !== "undefined" && !this.config.previewTeX)
{this.config.preview = "none"} // backward compatibility for previewTeX parameter
this.previewClass = MathJax.Hub.config.preRemoveClass;
this.configured = true;
}
if (typeof(element) === "string") {element = document.getElementById(element)}
if (!element) {element = document.body}
var span = element.getElementsByTagName("span"), i;
for (i = span.length-1; i >= 0; i--)
{if (String(span[i].className).match(/(^| )math( |$)/)) {this.ConvertMath(span[i],"")}}
var div = element.getElementsByTagName("div");
for (i = div.length-1; i >= 0; i--)
{if (String(div[i].className).match(/(^| )math( |$)/)) {this.ConvertMath(div[i],"; mode=display")}}
},
ConvertMath: function (node,mode) {
if (node.getElementsByTagName("script").length === 0) {
var parent = node.parentNode,
script = this.createMathTag(mode,node.innerHTML);
if (node.nextSibling) {parent.insertBefore(script,node.nextSibling)}
else {parent.appendChild(script)}
if (this.config.preview !== "none") {this.createPreview(node)}
parent.removeChild(node);
}
},
createPreview: function (node) {
var preview = this.config.preview;
if (preview === "TeX") {preview = [this.filterPreview(node.innerHTML)]}
if (preview) {
preview = MathJax.HTML.Element("span",{className: MathJax.Hub.config.preRemoveClass},preview);
node.parentNode.insertBefore(preview,node);
}
},
createMathTag: function (mode,tex) {
tex = tex.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&amp;/g,"&");
var script = document.createElement("script");
script.type = "math/tex" + mode;
MathJax.HTML.setScript(script,tex);
return script;
},
filterPreview: function (tex) {return tex}
};
// We register the preprocessors with the following priorities:
// - mml2jax.js: 5
// - jsMath2jax.js: 8
// - asciimath2jax.js, tex2jax.js: 10 (default)
// See issues 18 and 484 and the other *2jax.js files.
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.jsMath2jax],8);
MathJax.Ajax.loadComplete("[MathJax]/extensions/jsMath2jax.js");
python/ipnb/resources/MathJax/extensions/mml2jax.js
Vendored
+261
View File
@@ -0,0 +1,261 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/mml2jax.js
*
* Implements the MathML to Jax preprocessor that locates <math> nodes
* within the text of a document and replaces them with SCRIPT tags
* for processing by MathJax.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.mml2jax = {
version: "2.6.0",
config: {
preview: "mathml" // Use the <math> element as the
// preview. Set to "none" for no preview,
// set to "alttext" to use the alttext attribute
// of the <math> element, set to "altimg" to use
// an image described by the altimg* attributes
// or set to an array specifying an HTML snippet
// to use a fixed preview for all math
},
MMLnamespace: "http://www.w3.org/1998/Math/MathML",
PreProcess: function (element) {
if (!this.configured) {
this.config = MathJax.Hub.CombineConfig("mml2jax",this.config);
if (this.config.Augment) {MathJax.Hub.Insert(this,this.config.Augment)}
this.InitBrowser();
this.configured = true;
}
if (typeof(element) === "string") {element = document.getElementById(element)}
if (!element) {element = document.body}
var mathArray = [];
//
// Handle all math tags with no namespaces
//
this.PushMathElements(mathArray,element,"math");
//
// Handle math with namespaces in XHTML
//
this.PushMathElements(mathArray,element,"math",this.MMLnamespace);
//
// Handle math with namespaces in HTML
//
var i, m;
if (typeof(document.namespaces) !== "undefined") {
//
// IE namespaces are listed in document.namespaces
//
try {
for (i = 0, m = document.namespaces.length; i < m; i++) {
var ns = document.namespaces[i];
if (ns.urn === this.MMLnamespace)
{this.PushMathElements(mathArray,element,ns.name+":math")}
}
} catch (err) {}
} else {
//
// Everybody else
//
var html = document.getElementsByTagName("html")[0];
if (html) {
for (i = 0, m = html.attributes.length; i < m; i++) {
var attr = html.attributes[i];
if (attr.nodeName.substr(0,6) === "xmlns:" && attr.nodeValue === this.MMLnamespace)
{this.PushMathElements(mathArray,element,attr.nodeName.substr(6)+":math")}
}
}
}
this.ProcessMathArray(mathArray);
},
PushMathElements: function (array,element,name,namespace) {
var math, preview = MathJax.Hub.config.preRemoveClass;
if (namespace) {
if (!element.getElementsByTagNameNS) return;
math = element.getElementsByTagNameNS(namespace,name);
} else {
math = element.getElementsByTagName(name);
}
for (var i = 0, m = math.length; i < m; i++) {
var parent = math[i].parentNode;
if (parent && parent.className !== preview &&
!parent.isMathJax && !math[i].prefix === !namespace) array.push(math[i]);
}
},
ProcessMathArray: function (math) {
var i, m = math.length;
if (m) {
if (this.MathTagBug) {
for (i = 0; i < m; i++) {
if (math[i].nodeName === "MATH") {this.ProcessMathFlattened(math[i])}
else {this.ProcessMath(math[i])}
}
} else {
for (i = 0; i < m; i++) {this.ProcessMath(math[i])}
}
}
},
ProcessMath: function (math) {
var parent = math.parentNode;
if (!parent || parent.className === MathJax.Hub.config.preRemoveClass) return;
var script = document.createElement("script");
script.type = "math/mml";
parent.insertBefore(script,math);
if (this.AttributeBug) {
var html = this.OuterHTML(math);
if (this.CleanupHTML) {
html = html.replace(/<\?import .*?>/i,"").replace(/<\?xml:namespace .*?\/>/i,"");
html = html.replace(/&nbsp;/g,"&#xA0;");
}
MathJax.HTML.setScript(script,html); parent.removeChild(math);
} else {
var span = MathJax.HTML.Element("span"); span.appendChild(math);
MathJax.HTML.setScript(script,span.innerHTML);
}
if (this.config.preview !== "none") {this.createPreview(math,script)}
},
ProcessMathFlattened: function (math) {
var parent = math.parentNode;
if (!parent || parent.className === MathJax.Hub.config.preRemoveClass) return;
var script = document.createElement("script");
script.type = "math/mml";
parent.insertBefore(script,math);
var mml = "", node, MATH = math;
while (math && math.nodeName !== "/MATH") {
node = math; math = math.nextSibling;
mml += this.NodeHTML(node);
node.parentNode.removeChild(node);
}
if (math && math.nodeName === "/MATH") {math.parentNode.removeChild(math)}
script.text = mml + "</math>";
if (this.config.preview !== "none") {this.createPreview(MATH,script)}
},
NodeHTML: function (node) {
var html, i, m;
if (node.nodeName === "#text") {
html = this.quoteHTML(node.nodeValue);
} else if (node.nodeName === "#comment") {
html = "<!--" + node.nodeValue + "-->"
} else {
// In IE, outerHTML doesn't properly quote attributes, so quote them by hand
// In Opera, HTML special characters aren't quoted in attributes, so quote them
html = "<"+node.nodeName.toLowerCase();
for (i = 0, m = node.attributes.length; i < m; i++) {
var attribute = node.attributes[i];
if (attribute.specified && attribute.nodeName.substr(0,10) !== "_moz-math-") {
// Opera 11.5 beta turns xmlns into xmlns:xmlns, so put it back (*** check after 11.5 is out ***)
html += " "+attribute.nodeName.toLowerCase().replace(/xmlns:xmlns/,"xmlns")+"=";
var value = attribute.nodeValue; // IE < 8 doesn't properly set style by setAttributes
if (value == null && attribute.nodeName === "style" && node.style) {value = node.style.cssText}
html += '"'+this.quoteHTML(value)+'"';
}
}
html += ">";
// Handle internal HTML (possibly due to <semantics> annotation or missing </math>)
if (node.outerHTML != null && node.outerHTML.match(/(.<\/[A-Z]+>|\/>)$/)) {
for (i = 0, m = node.childNodes.length; i < m; i++)
{html += this.OuterHTML(node.childNodes[i])}
html += "</"+node.nodeName.toLowerCase()+">";
}
}
return html;
},
OuterHTML: function (node) {
if (node.nodeName.charAt(0) === "#") {return this.NodeHTML(node)}
if (!this.AttributeBug) {return node.outerHTML}
var html = this.NodeHTML(node);
for (var i = 0, m = node.childNodes.length; i < m; i++)
{html += this.OuterHTML(node.childNodes[i]);}
html += "</"+node.nodeName.toLowerCase()+">";
return html;
},
quoteHTML: function (string) {
if (string == null) {string = ""}
return string.replace(/&/g,"&#x26;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/\"/g,"&quot;");
},
createPreview: function (math,script) {
var preview = this.config.preview;
if (preview === "none") return;
var isNodePreview = false;
if (preview === "mathml") {
isNodePreview = true;
// mathml preview does not work with IE < 9, so fallback to alttext.
if (this.MathTagBug) {preview = "alttext"} else {preview = math.cloneNode(true)}
}
if (preview === "alttext" || preview === "altimg") {
isNodePreview = true;
var alttext = this.filterPreview(math.getAttribute("alttext"));
if (preview === "alttext") {
if (alttext != null) {preview = MathJax.HTML.TextNode(alttext)} else {preview = null}
} else {
var src = math.getAttribute("altimg");
if (src != null) {
// FIXME: use altimg-valign when display="inline"?
var style = {width: math.getAttribute("altimg-width"), height: math.getAttribute("altimg-height")};
preview = MathJax.HTML.Element("img",{src:src,alt:alttext,style:style});
} else {preview = null}
}
}
if (preview) {
var span;
if (isNodePreview) {
span = MathJax.HTML.Element("span",{className:MathJax.Hub.config.preRemoveClass});
span.appendChild(preview);
} else {
span = MathJax.HTML.Element("span",{className:MathJax.Hub.config.preRemoveClass},preview);
}
script.parentNode.insertBefore(span,script);
}
},
filterPreview: function (text) {return text},
InitBrowser: function () {
var test = MathJax.HTML.Element("span",{id:"<", className: "mathjax", innerHTML: "<math><mi>x</mi><mspace /></math>"});
var html = test.outerHTML || "";
this.AttributeBug = html !== "" && !(
html.match(/id="&lt;"/) && // "<" should convert to "&lt;"
html.match(/class="mathjax"/) && // IE leaves out quotes
html.match(/<\/math>/) // Opera 9 drops tags after self-closing tags
);
this.MathTagBug = test.childNodes.length > 1; // IE < 9 flattens unknown tags
this.CleanupHTML = MathJax.Hub.Browser.isMSIE; // remove namespace and other added tags
}
};
//
// We register the preprocessors with the following priorities:
// - mml2jax.js: 5
// - jsMath2jax.js: 8
// - asciimath2jax.js, tex2jax.js: 10 (default)
// See issues 18 and 484 and the other *2jax.js files.
//
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.mml2jax],5);
MathJax.Ajax.loadComplete("[MathJax]/extensions/mml2jax.js");
python/ipnb/resources/MathJax/extensions/tex2jax.js
Vendored
+309
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/tex2jax.js
*
* Implements the TeX to Jax preprocessor that locates TeX code
* within the text of a document and replaces it with SCRIPT tags
* for processing by MathJax.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.tex2jax = {
version: "2.6.0",
config: {
inlineMath: [ // The start/stop pairs for in-line math
// ['$','$'], // (comment out any you don't want, or add your own, but
['\\(','\\)'] // be sure that you don't have an extra comma at the end)
],
displayMath: [ // The start/stop pairs for display math
['$$','$$'], // (comment out any you don't want, or add your own, but
['\\[','\\]'] // be sure that you don't have an extra comma at the end)
],
balanceBraces: true, // determines whether tex2jax requires braces to be
// balanced within math delimiters (allows for nested
// dollar signs). Set to false to get pre-v2.0 compatibility.
skipTags: ["script","noscript","style","textarea","pre","code","annotation","annotation-xml"],
// The names of the tags whose contents will not be
// scanned for math delimiters
ignoreClass: "tex2jax_ignore", // the class name of elements whose contents should
// NOT be processed by tex2jax. Note that this
// is a regular expression, so be sure to quote any
// regexp special characters
processClass: "tex2jax_process", // the class name of elements whose contents SHOULD
// be processed when they appear inside ones that
// are ignored. Note that this is a regular expression,
// so be sure to quote any regexp special characters
processEscapes: false, // set to true to allow \$ to produce a dollar without
// starting in-line math mode
processEnvironments: true, // set to true to process \begin{xxx}...\end{xxx} outside
// of math mode, false to prevent that
processRefs: true, // set to true to process \ref{...} outside of math mode
preview: "TeX" // set to "none" to not insert MathJax_Preview spans
// or set to an array specifying an HTML snippet
// to use the same preview for every equation.
},
PreProcess: function (element) {
if (!this.configured) {
this.config = MathJax.Hub.CombineConfig("tex2jax",this.config);
if (this.config.Augment) {MathJax.Hub.Insert(this,this.config.Augment)}
if (typeof(this.config.previewTeX) !== "undefined" && !this.config.previewTeX)
{this.config.preview = "none"} // backward compatibility for previewTeX parameter
this.configured = true;
}
if (typeof(element) === "string") {element = document.getElementById(element)}
if (!element) {element = document.body}
if (this.createPatterns()) {this.scanElement(element,element.nextSibling)}
},
createPatterns: function () {
var starts = [], parts = [], i, m, config = this.config;
this.match = {};
for (i = 0, m = config.inlineMath.length; i < m; i++) {
starts.push(this.patternQuote(config.inlineMath[i][0]));
this.match[config.inlineMath[i][0]] = {
mode: "",
end: config.inlineMath[i][1],
pattern: this.endPattern(config.inlineMath[i][1])
};
}
for (i = 0, m = config.displayMath.length; i < m; i++) {
starts.push(this.patternQuote(config.displayMath[i][0]));
this.match[config.displayMath[i][0]] = {
mode: "; mode=display",
end: config.displayMath[i][1],
pattern: this.endPattern(config.displayMath[i][1])
};
}
if (starts.length) {parts.push(starts.sort(this.sortLength).join("|"))}
if (config.processEnvironments) {parts.push("\\\\begin\\{([^}]*)\\}")}
if (config.processEscapes) {parts.push("\\\\*\\\\\\\$")}
if (config.processRefs) {parts.push("\\\\(eq)?ref\\{[^}]*\\}")}
this.start = new RegExp(parts.join("|"),"g");
this.skipTags = new RegExp("^("+config.skipTags.join("|")+")$","i");
var ignore = [];
if (MathJax.Hub.config.preRemoveClass) {ignore.push(MathJax.Hub.config.preRemoveClass)};
if (config.ignoreClass) {ignore.push(config.ignoreClass)}
this.ignoreClass = (ignore.length ? new RegExp("(^| )("+ignore.join("|")+")( |$)") : /^$/);
this.processClass = new RegExp("(^| )("+config.processClass+")( |$)");
return (parts.length > 0);
},
patternQuote: function (s) {return s.replace(/([\^$(){}+*?\-|\[\]\:\\])/g,'\\$1')},
endPattern: function (end) {
return new RegExp(this.patternQuote(end)+"|\\\\.|[{}]","g");
},
sortLength: function (a,b) {
if (a.length !== b.length) {return b.length - a.length}
return (a == b ? 0 : (a < b ? -1 : 1));
},
scanElement: function (element,stop,ignore) {
var cname, tname, ignoreChild, process;
while (element && element != stop) {
if (element.nodeName.toLowerCase() === '#text') {
if (!ignore) {element = this.scanText(element)}
} else {
cname = (typeof(element.className) === "undefined" ? "" : element.className);
tname = (typeof(element.tagName) === "undefined" ? "" : element.tagName);
if (typeof(cname) !== "string") {cname = String(cname)} // jsxgraph uses non-string class names!
process = this.processClass.exec(cname);
if (element.firstChild && !cname.match(/(^| )MathJax/) &&
(process || !this.skipTags.exec(tname))) {
ignoreChild = (ignore || this.ignoreClass.exec(cname)) && !process;
this.scanElement(element.firstChild,stop,ignoreChild);
}
}
if (element) {element = element.nextSibling}
}
},
scanText: function (element) {
if (element.nodeValue.replace(/\s+/,'') == '') {return element}
var match, prev;
this.search = {start: true};
this.pattern = this.start;
while (element) {
this.pattern.lastIndex = 0;
while (element && element.nodeName.toLowerCase() === '#text' &&
(match = this.pattern.exec(element.nodeValue))) {
if (this.search.start) {element = this.startMatch(match,element)}
else {element = this.endMatch(match,element)}
}
if (this.search.matched) {element = this.encloseMath(element)}
if (element) {
do {prev = element; element = element.nextSibling}
while (element && (element.nodeName.toLowerCase() === 'br' ||
element.nodeName.toLowerCase() === '#comment'));
if (!element || element.nodeName !== '#text')
{return (this.search.close ? this.prevEndMatch() : prev)}
}
}
return element;
},
startMatch: function (match,element) {
var delim = this.match[match[0]];
if (delim != null) { // a start delimiter
this.search = {
end: delim.end, mode: delim.mode, pcount: 0,
open: element, olen: match[0].length, opos: this.pattern.lastIndex - match[0].length
};
this.switchPattern(delim.pattern);
} else if (match[0].substr(0,6) === "\\begin") { // \begin{...}
this.search = {
end: "\\end{"+match[1]+"}", mode: "; mode=display", pcount: 0,
open: element, olen: 0, opos: this.pattern.lastIndex - match[0].length,
isBeginEnd: true
};
this.switchPattern(this.endPattern(this.search.end));
} else if (match[0].substr(0,4) === "\\ref" || match[0].substr(0,6) === "\\eqref") {
this.search = {
mode: "", end: "", open: element, pcount: 0,
olen: 0, opos: this.pattern.lastIndex - match[0].length
}
return this.endMatch([""],element);
} else { // escaped dollar signs
// put $ in a span so it doesn't get processed again
// split off backslashes so they don't get removed later
var slashes = match[0].substr(0,match[0].length-1), n, span;
if (slashes.length % 2 === 0) {span = [slashes.replace(/\\\\/g,"\\")]; n = 1}
else {span = [slashes.substr(1).replace(/\\\\/g,"\\"),"$"]; n = 0}
span = MathJax.HTML.Element("span",null,span);
var text = MathJax.HTML.TextNode(element.nodeValue.substr(0,match.index));
element.nodeValue = element.nodeValue.substr(match.index + match[0].length - n);
element.parentNode.insertBefore(span,element);
element.parentNode.insertBefore(text,span);
this.pattern.lastIndex = n;
}
return element;
},
endMatch: function (match,element) {
var search = this.search;
if (match[0] == search.end) {
if (!search.close || search.pcount === 0) {
search.close = element;
search.cpos = this.pattern.lastIndex;
search.clen = (search.isBeginEnd ? 0 : match[0].length);
}
if (search.pcount === 0) {
search.matched = true;
element = this.encloseMath(element);
this.switchPattern(this.start);
}
}
else if (match[0] === "{") {search.pcount++}
else if (match[0] === "}" && search.pcount) {search.pcount--}
return element;
},
prevEndMatch: function () {
this.search.matched = true;
var element = this.encloseMath(this.search.close);
this.switchPattern(this.start);
return element;
},
switchPattern: function (pattern) {
pattern.lastIndex = this.pattern.lastIndex;
this.pattern = pattern;
this.search.start = (pattern === this.start);
},
encloseMath: function (element) {
var search = this.search, close = search.close, CLOSE, math;
if (search.cpos === close.length) {close = close.nextSibling}
else {close = close.splitText(search.cpos)}
if (!close) {CLOSE = close = MathJax.HTML.addText(search.close.parentNode,"")}
search.close = close;
math = (search.opos ? search.open.splitText(search.opos) : search.open);
while (math.nextSibling && math.nextSibling !== close) {
if (math.nextSibling.nodeValue !== null) {
if (math.nextSibling.nodeName === "#comment") {
math.nodeValue += math.nextSibling.nodeValue.replace(/^\[CDATA\[((.|\n|\r)*)\]\]$/,"$1");
} else {
math.nodeValue += math.nextSibling.nodeValue;
}
} else if (this.msieNewlineBug) {
math.nodeValue += (math.nextSibling.nodeName.toLowerCase() === "br" ? "\n" : " ");
} else {
math.nodeValue += " ";
}
math.parentNode.removeChild(math.nextSibling);
}
var TeX = math.nodeValue.substr(search.olen,math.nodeValue.length-search.olen-search.clen);
math.parentNode.removeChild(math);
if (this.config.preview !== "none") {this.createPreview(search.mode,TeX)}
math = this.createMathTag(search.mode,TeX);
this.search = {}; this.pattern.lastIndex = 0;
if (CLOSE) {CLOSE.parentNode.removeChild(CLOSE)}
return math;
},
insertNode: function (node) {
var search = this.search;
search.close.parentNode.insertBefore(node,search.close);
},
createPreview: function (mode,tex) {
var preview = this.config.preview;
if (preview === "none") return;
if (preview === "TeX") {preview = [this.filterPreview(tex)]}
if (preview) {
preview = MathJax.HTML.Element("span",{className:MathJax.Hub.config.preRemoveClass},preview);
this.insertNode(preview);
}
},
createMathTag: function (mode,tex) {
var script = document.createElement("script");
script.type = "math/tex" + mode;
MathJax.HTML.setScript(script,tex);
this.insertNode(script);
return script;
},
filterPreview: function (tex) {return tex},
msieNewlineBug: (MathJax.Hub.Browser.isMSIE && document.documentMode < 9)
};
// We register the preprocessors with the following priorities:
// - mml2jax.js: 5
// - jsMath2jax.js: 8
// - asciimath2jax.js, tex2jax.js: 10 (default)
// See issues 18 and 484 and the other *2jax.js files.
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.tex2jax]);
MathJax.Ajax.loadComplete("[MathJax]/extensions/tex2jax.js");
python/ipnb/resources/MathJax/extensions/toMathML.js
Vendored
+241
View File
@@ -0,0 +1,241 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/extensions/toMathML.js
*
* Implements a toMathML() method for the mml Element Jax that returns
* a MathML string from a given math expression.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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.LoadHook("[MathJax]/jax/element/mml/jax.js",function () {
var VERSION = "2.6.1";
var MML = MathJax.ElementJax.mml,
SETTINGS = MathJax.Hub.config.menuSettings;
MML.mbase.Augment({
toMathML: function (space) {
var inferred = (this.inferred && this.parent.inferRow);
if (space == null) {space = ""}
var tag = this.type, attr = this.toMathMLattributes();
if (tag === "mspace") {return space + "<"+tag+attr+" />"}
var data = [], SPACE = (this.isToken ? "" : space+(inferred ? "" : " "));
for (var i = 0, m = this.data.length; i < m; i++) {
if (this.data[i]) {data.push(this.data[i].toMathML(SPACE))}
else if (!this.isToken && !this.isChars) {data.push(SPACE+"<mrow />")}
}
if (this.isToken || this.isChars) {return space + "<"+tag+attr+">"+data.join("")+"</"+tag+">"}
if (inferred) {return data.join("\n")}
if (data.length === 0 || (data.length === 1 && data[0] === ""))
{return space + "<"+tag+attr+" />"}
return space + "<"+tag+attr+">\n"+data.join("\n")+"\n"+ space +"</"+tag+">";
},
toMathMLattributes: function () {
var defaults = (this.type === "mstyle" ? MML.math.prototype.defaults : this.defaults);
var names = (this.attrNames||MML.copyAttributeNames),
skip = MML.skipAttributes, copy = MML.copyAttributes;
var attr = [];
if (this.type === "math" && (!this.attr || !this.attr.xmlns))
{attr.push('xmlns="http://www.w3.org/1998/Math/MathML"')}
if (!this.attrNames) {
for (var id in defaults) {if (!skip[id] && !copy[id] && defaults.hasOwnProperty(id)) {
if (this[id] != null && this[id] !== defaults[id]) {
if (this.Get(id,null,1) !== this[id])
attr.push(id+'="'+this.toMathMLattribute(this[id])+'"');
}
}}
}
for (var i = 0, m = names.length; i < m; i++) {
if (copy[names[i]] === 1 && !defaults.hasOwnProperty(names[i])) continue;
value = (this.attr||{})[names[i]]; if (value == null) {value = this[names[i]]}
if (value != null) {attr.push(names[i]+'="'+this.toMathMLquote(value)+'"')}
}
this.toMathMLclass(attr);
if (attr.length) {return " "+attr.join(" ")} else {return ""}
},
toMathMLclass: function (attr) {
var CLASS = []; if (this["class"]) {CLASS.push(this["class"])}
if (this.isa(MML.TeXAtom) && SETTINGS.texHints) {
var TEXCLASS = ["ORD","OP","BIN","REL","OPEN","CLOSE","PUNCT","INNER","VCENTER"][this.texClass];
if (TEXCLASS) {
CLASS.push("MJX-TeXAtom-"+TEXCLASS)
if (TEXCLASS === "OP" && !this.movablelimits) CLASS.push("MJX-fixedlimits");
}
}
if (this.mathvariant && this.toMathMLvariants[this.mathvariant])
{CLASS.push("MJX"+this.mathvariant)}
if (this.variantForm) {CLASS.push("MJX-variant")}
if (CLASS.length) {attr.unshift('class="'+CLASS.join(" ")+'"')}
},
toMathMLattribute: function (value) {
if (typeof(value) === "string" &&
value.replace(/ /g,"").match(/^(([-+])?(\d+(\.\d*)?|\.\d+))mu$/)) {
// FIXME: should take scriptlevel into account
return (RegExp.$2||"")+((1/18)*RegExp.$3).toFixed(3).replace(/\.?0+$/,"")+"em";
}
else if (this.toMathMLvariants[value]) {return this.toMathMLvariants[value]}
return this.toMathMLquote(value);
},
toMathMLvariants: {
"-tex-caligraphic": MML.VARIANT.SCRIPT,
"-tex-caligraphic-bold": MML.VARIANT.BOLDSCRIPT,
"-tex-oldstyle": MML.VARIANT.NORMAL,
"-tex-oldstyle-bold": MML.VARIANT.BOLD,
"-tex-mathit": MML.VARIANT.ITALIC
},
toMathMLquote: function (string) {
string = String(string).split("");
for (var i = 0, m = string.length; i < m; i++) {
var n = string[i].charCodeAt(0);
if (n <= 0xD7FF || 0xE000 <= n) {
// Code points U+0000 to U+D7FF and U+E000 to U+FFFF.
// They are directly represented by n.
if (n > 0x7E || (n < 0x20 && n !== 0x0A && n !== 0x0D && n !== 0x09)) {
string[i] = "&#x"+n.toString(16).toUpperCase()+";";
} else {
var c =
{'&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;'}[string[i]];
if (c) {string[i] = c}
}
} else if (i+1 < m) {
// Code points U+10000 to U+10FFFF.
// n is the lead surrogate, let's read the trail surrogate.
var trailSurrogate = string[i+1].charCodeAt(0);
var codePoint = (((n-0xD800)<<10)+(trailSurrogate-0xDC00)+0x10000);
string[i] = "&#x"+codePoint.toString(16).toUpperCase()+";";
string[i+1] = "";
i++;
} else {
// n is a lead surrogate without corresponding trail surrogate:
// remove that character.
string[i] = "";
}
}
return string.join("");
}
});
//
// Override math.toMathML in order to add semantics tag
// for the input format, if the user requests that in the
// Show As menu.
//
MML.math.Augment({
toMathML: function (space,jax) {
var annotation;
if (space == null) {space = ""}
if (jax && jax.originalText && SETTINGS.semantics)
{annotation = MathJax.InputJax[jax.inputJax].annotationEncoding}
var nested = (this.data[0] && this.data[0].data.length > 1);
var tag = this.type, attr = this.toMathMLattributes();
var data = [], SPACE = space + (annotation ? " " + (nested ? " " : "") : "") + " ";
for (var i = 0, m = this.data.length; i < m; i++) {
if (this.data[i]) {data.push(this.data[i].toMathML(SPACE))}
else {data.push(SPACE+"<mrow />")}
}
if (data.length === 0 || (data.length === 1 && data[0] === "")) {
if (!annotation) {return "<"+tag+attr+" />"}
data.push(SPACE+"<mrow />");
}
if (annotation) {
if (nested) {data.unshift(space+" <mrow>"); data.push(space+" </mrow>")}
data.unshift(space+" <semantics>");
var xmlEscapedTex = jax.originalText.replace(/[&<>]/g, function(item) {
return { '>': '&gt;', '<': '&lt;','&': '&amp;' }[item]
});
data.push(space+' <annotation encoding="'+annotation+'">'+xmlEscapedTex+"</annotation>");
data.push(space+" </semantics>");
}
return space+"<"+tag+attr+">\n"+data.join("\n")+"\n"+space+"</"+tag+">";
}
});
MML.msubsup.Augment({
toMathML: function (space) {
var tag = this.type;
if (this.data[this.sup] == null) {tag = "msub"}
if (this.data[this.sub] == null) {tag = "msup"}
var attr = this.toMathMLattributes();
delete this.data[0].inferred;
var data = [];
for (var i = 0, m = this.data.length; i < m; i++)
{if (this.data[i]) {data.push(this.data[i].toMathML(space+" "))}}
return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">";
}
});
MML.munderover.Augment({
toMathML: function (space) {
var tag = this.type;
var base = this.data[this.base];
if (base && base.isa(MML.TeXAtom) && base.movablelimits && !base.Get("displaystyle")) {
type = "msubsup";
if (this.data[this.under] == null) {tag = "msup"}
if (this.data[this.over] == null) {tag = "msub"}
} else {
if (this.data[this.under] == null) {tag = "mover"}
if (this.data[this.over] == null) {tag = "munder"}
}
var attr = this.toMathMLattributes();
delete this.data[0].inferred;
var data = [];
for (var i = 0, m = this.data.length; i < m; i++)
{if (this.data[i]) {data.push(this.data[i].toMathML(space+" "))}}
return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">";
}
});
MML.TeXAtom.Augment({
toMathML: function (space) {
// FIXME: Handle spacing using mpadded?
var attr = this.toMathMLattributes();
if (!attr && this.data[0].data.length === 1) {return space.substr(2) + this.data[0].toMathML(space)}
return space+"<mrow"+attr+">\n" + this.data[0].toMathML(space+" ")+"\n"+space+"</mrow>";
}
});
MML.chars.Augment({
toMathML: function (space) {return (space||"") + this.toMathMLquote(this.toString())}
});
MML.entity.Augment({
toMathML: function (space) {return (space||"") + "&"+this.data[0]+";<!-- "+this.toString()+" -->"}
});
MML.xml.Augment({
toMathML: function (space) {return (space||"") + this.toString()}
});
MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () {
MML.TeXmathchoice.Augment({
toMathML: function (space) {return this.Core().toMathML(space)}
});
});
MathJax.Hub.Startup.signal.Post("toMathML Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/toMathML.js");
python/ipnb/resources/MathJax/jax/element/mml/jax.js
Vendored
+1817
View File
File diff suppressed because it is too large Load Diff
python/ipnb/resources/MathJax/jax/element/mml/optable/Arrows.js
Vendored
+122
View File
@@ -0,0 +1,122 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Arrows.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u219A': MO.RELACCENT, // leftwards arrow with stroke
'\u219B': MO.RELACCENT, // rightwards arrow with stroke
'\u219C': MO.WIDEREL, // leftwards wave arrow
'\u219D': MO.WIDEREL, // rightwards wave arrow
'\u219E': MO.WIDEREL, // leftwards two headed arrow
'\u219F': MO.WIDEREL, // upwards two headed arrow
'\u21A0': MO.WIDEREL, // rightwards two headed arrow
'\u21A1': MO.RELSTRETCH, // downwards two headed arrow
'\u21A2': MO.WIDEREL, // leftwards arrow with tail
'\u21A3': MO.WIDEREL, // rightwards arrow with tail
'\u21A4': MO.WIDEREL, // leftwards arrow from bar
'\u21A5': MO.RELSTRETCH, // upwards arrow from bar
'\u21A7': MO.RELSTRETCH, // downwards arrow from bar
'\u21A8': MO.RELSTRETCH, // up down arrow with base
'\u21AB': MO.WIDEREL, // leftwards arrow with loop
'\u21AC': MO.WIDEREL, // rightwards arrow with loop
'\u21AD': MO.WIDEREL, // left right wave arrow
'\u21AE': MO.RELACCENT, // left right arrow with stroke
'\u21AF': MO.RELSTRETCH, // downwards zigzag arrow
'\u21B0': MO.RELSTRETCH, // upwards arrow with tip leftwards
'\u21B1': MO.RELSTRETCH, // upwards arrow with tip rightwards
'\u21B2': MO.RELSTRETCH, // downwards arrow with tip leftwards
'\u21B3': MO.RELSTRETCH, // downwards arrow with tip rightwards
'\u21B4': MO.RELSTRETCH, // rightwards arrow with corner downwards
'\u21B5': MO.RELSTRETCH, // downwards arrow with corner leftwards
'\u21B6': MO.RELACCENT, // anticlockwise top semicircle arrow
'\u21B7': MO.RELACCENT, // clockwise top semicircle arrow
'\u21B8': MO.REL, // north west arrow to long bar
'\u21B9': MO.WIDEREL, // leftwards arrow to bar over rightwards arrow to bar
'\u21BA': MO.REL, // anticlockwise open circle arrow
'\u21BB': MO.REL, // clockwise open circle arrow
'\u21BE': MO.RELSTRETCH, // upwards harpoon with barb rightwards
'\u21BF': MO.RELSTRETCH, // upwards harpoon with barb leftwards
'\u21C2': MO.RELSTRETCH, // downwards harpoon with barb rightwards
'\u21C3': MO.RELSTRETCH, // downwards harpoon with barb leftwards
'\u21C4': MO.WIDEREL, // rightwards arrow over leftwards arrow
'\u21C5': MO.RELSTRETCH, // upwards arrow leftwards of downwards arrow
'\u21C6': MO.WIDEREL, // leftwards arrow over rightwards arrow
'\u21C7': MO.WIDEREL, // leftwards paired arrows
'\u21C8': MO.RELSTRETCH, // upwards paired arrows
'\u21C9': MO.WIDEREL, // rightwards paired arrows
'\u21CA': MO.RELSTRETCH, // downwards paired arrows
'\u21CB': MO.WIDEREL, // leftwards harpoon over rightwards harpoon
'\u21CD': MO.RELACCENT, // leftwards double arrow with stroke
'\u21CE': MO.RELACCENT, // left right double arrow with stroke
'\u21CF': MO.RELACCENT, // rightwards double arrow with stroke
'\u21D6': MO.RELSTRETCH, // north west double arrow
'\u21D7': MO.RELSTRETCH, // north east double arrow
'\u21D8': MO.RELSTRETCH, // south east double arrow
'\u21D9': MO.RELSTRETCH, // south west double arrow
'\u21DA': MO.WIDEREL, // leftwards triple arrow
'\u21DB': MO.WIDEREL, // rightwards triple arrow
'\u21DC': MO.WIDEREL, // leftwards squiggle arrow
'\u21DD': MO.WIDEREL, // rightwards squiggle arrow
'\u21DE': MO.REL, // upwards arrow with double stroke
'\u21DF': MO.REL, // downwards arrow with double stroke
'\u21E0': MO.WIDEREL, // leftwards dashed arrow
'\u21E1': MO.RELSTRETCH, // upwards dashed arrow
'\u21E2': MO.WIDEREL, // rightwards dashed arrow
'\u21E3': MO.RELSTRETCH, // downwards dashed arrow
'\u21E4': MO.WIDEREL, // leftwards arrow to bar
'\u21E5': MO.WIDEREL, // rightwards arrow to bar
'\u21E6': MO.WIDEREL, // leftwards white arrow
'\u21E7': MO.RELSTRETCH, // upwards white arrow
'\u21E8': MO.WIDEREL, // rightwards white arrow
'\u21E9': MO.RELSTRETCH, // downwards white arrow
'\u21EA': MO.RELSTRETCH, // upwards white arrow from bar
'\u21EB': MO.RELSTRETCH, // upwards white arrow on pedestal
'\u21EC': MO.RELSTRETCH, // upwards white arrow on pedestal with horizontal bar
'\u21ED': MO.RELSTRETCH, // upwards white arrow on pedestal with vertical bar
'\u21EE': MO.RELSTRETCH, // upwards white double arrow
'\u21EF': MO.RELSTRETCH, // upwards white double arrow on pedestal
'\u21F0': MO.WIDEREL, // rightwards white arrow from wall
'\u21F1': MO.REL, // north west arrow to corner
'\u21F2': MO.REL, // south east arrow to corner
'\u21F3': MO.RELSTRETCH, // up down white arrow
'\u21F4': MO.RELACCENT, // right arrow with small circle
'\u21F5': MO.RELSTRETCH, // downwards arrow leftwards of upwards arrow
'\u21F6': MO.WIDEREL, // three rightwards arrows
'\u21F7': MO.RELACCENT, // leftwards arrow with vertical stroke
'\u21F8': MO.RELACCENT, // rightwards arrow with vertical stroke
'\u21F9': MO.RELACCENT, // left right arrow with vertical stroke
'\u21FA': MO.RELACCENT, // leftwards arrow with double vertical stroke
'\u21FB': MO.RELACCENT, // rightwards arrow with double vertical stroke
'\u21FC': MO.RELACCENT, // left right arrow with double vertical stroke
'\u21FD': MO.WIDEREL, // leftwards open-headed arrow
'\u21FE': MO.WIDEREL, // rightwards open-headed arrow
'\u21FF': MO.WIDEREL // left right open-headed arrow
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/Arrows.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/BasicLatin.js
Vendored
+65
View File
@@ -0,0 +1,65 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
'|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
},
postfix: {
'!!': [1,0,TEXCLASS.BIN], // multiple character operator: !!
'\'': MO.ACCENT, // apostrophe
'++': [0,0,TEXCLASS.BIN], // multiple character operator: ++
'--': [0,0,TEXCLASS.BIN], // multiple character operator: --
'..': [0,0,TEXCLASS.BIN], // multiple character operator: ..
'...': MO.ORD, // multiple character operator: ...
'||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
'|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
},
infix: {
'!=': MO.BIN4, // multiple character operator: !=
'&&': MO.BIN4, // multiple character operator: &&
'**': [1,1,TEXCLASS.BIN], // multiple character operator: **
'*=': MO.BIN4, // multiple character operator: *=
'+=': MO.BIN4, // multiple character operator: +=
'-=': MO.BIN4, // multiple character operator: -=
'->': MO.BIN5, // multiple character operator: ->
'//': [1,1,TEXCLASS.BIN], // multiple character operator: //
'/=': MO.BIN4, // multiple character operator: /=
':=': MO.BIN4, // multiple character operator: :=
'<=': MO.BIN5, // multiple character operator: <=
'<>': [1,1,TEXCLASS.BIN], // multiple character operator: <>
'==': MO.BIN4, // multiple character operator: ==
'>=': MO.BIN5, // multiple character operator: >=
'@': MO.ORD11, // commercial at
'||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
'|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/CombDiacritMarks.js
Vendored
+35
View File
@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u0311': MO.ACCENT // combining inverted breve
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiacritMarks.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/CombDiactForSymbols.js
Vendored
+36
View File
@@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/CombDiactForSymbols.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u20DB': MO.ACCENT, // combining three dots above
'\u20DC': MO.ACCENT // combining four dots above
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiactForSymbols.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/Dingbats.js
Vendored
+38
View File
@@ -0,0 +1,38 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Dingbats.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2772': MO.OPEN // light left tortoise shell bracket ornament
},
postfix: {
'\u2773': MO.CLOSE // light right tortoise shell bracket ornament
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/Dingbats.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/GeneralPunctuation.js
Vendored
+42
View File
@@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
'\u2018': [0,0,TEXCLASS.OPEN,{fence: true}], // left single quotation mark
'\u201C': [0,0,TEXCLASS.OPEN,{fence: true}] // left double quotation mark
},
postfix: {
'\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
'\u2019': [0,0,TEXCLASS.CLOSE,{fence: true}], // right single quotation mark
'\u201D': [0,0,TEXCLASS.CLOSE,{fence: true}] // right double quotation mark
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/GeneralPunctuation.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/GeometricShapes.js
Vendored
+66
View File
@@ -0,0 +1,66 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u25A0': MO.BIN3, // black square
'\u25A1': MO.BIN3, // white square
'\u25AA': MO.BIN3, // black small square
'\u25AB': MO.BIN3, // white small square
'\u25AD': MO.BIN3, // white rectangle
'\u25AE': MO.BIN3, // black vertical rectangle
'\u25AF': MO.BIN3, // white vertical rectangle
'\u25B0': MO.BIN3, // black parallelogram
'\u25B1': MO.BIN3, // white parallelogram
'\u25B2': MO.BIN4, // black up-pointing triangle
'\u25B4': MO.BIN4, // black up-pointing small triangle
'\u25B6': MO.BIN4, // black right-pointing triangle
'\u25B7': MO.BIN4, // white right-pointing triangle
'\u25B8': MO.BIN4, // black right-pointing small triangle
'\u25BC': MO.BIN4, // black down-pointing triangle
'\u25BE': MO.BIN4, // black down-pointing small triangle
'\u25C0': MO.BIN4, // black left-pointing triangle
'\u25C1': MO.BIN4, // white left-pointing triangle
'\u25C2': MO.BIN4, // black left-pointing small triangle
'\u25C4': MO.BIN4, // black left-pointing pointer
'\u25C5': MO.BIN4, // white left-pointing pointer
'\u25C6': MO.BIN4, // black diamond
'\u25C7': MO.BIN4, // white diamond
'\u25C8': MO.BIN4, // white diamond containing black small diamond
'\u25C9': MO.BIN4, // fisheye
'\u25CC': MO.BIN4, // dotted circle
'\u25CD': MO.BIN4, // circle with vertical fill
'\u25CE': MO.BIN4, // bullseye
'\u25CF': MO.BIN4, // black circle
'\u25D6': MO.BIN4, // left half black circle
'\u25D7': MO.BIN4, // right half black circle
'\u25E6': MO.BIN4 // white bullet
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/GeometricShapes.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/GreekAndCoptic.js
Vendored
+35
View File
@@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u03F6': MO.REL // greek reversed lunate epsilon symbol
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/GreekAndCoptic.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/Latin1Supplement.js
Vendored
+37
View File
@@ -0,0 +1,37 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Latin1Supplement.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u00B0': MO.ORD, // degree sign
'\u00B4': MO.ACCENT, // acute accent
'\u00B8': MO.ACCENT // cedilla
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/Latin1Supplement.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/LetterlikeSymbols.js
Vendored
+36
View File
@@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2145': MO.ORD21, // double-struck italic capital d
'\u2146': [2,0,TEXCLASS.ORD] // double-struck italic small d
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/LetterlikeSymbols.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/MathOperators.js
Vendored
+228
View File
@@ -0,0 +1,228 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MathOperators.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2204': MO.ORD21, // there does not exist
'\u221B': MO.ORD11, // cube root
'\u221C': MO.ORD11, // fourth root
'\u2221': MO.ORD, // measured angle
'\u2222': MO.ORD, // spherical angle
'\u222C': MO.INTEGRAL, // double integral
'\u222D': MO.INTEGRAL, // triple integral
'\u222F': MO.INTEGRAL, // surface integral
'\u2230': MO.INTEGRAL, // volume integral
'\u2231': MO.INTEGRAL, // clockwise integral
'\u2232': MO.INTEGRAL, // clockwise contour integral
'\u2233': MO.INTEGRAL // anticlockwise contour integral
},
infix: {
'\u2201': [1,2,TEXCLASS.ORD], // complement
'\u2206': MO.BIN3, // increment
'\u220A': MO.REL, // small element of
'\u220C': MO.REL, // does not contain as member
'\u220D': MO.REL, // small contains as member
'\u220E': MO.BIN3, // end of proof
'\u2214': MO.BIN4, // dot plus
'\u221F': MO.REL, // right angle
'\u2224': MO.REL, // does not divide
'\u2226': MO.REL, // not parallel to
'\u2234': MO.REL, // therefore
'\u2235': MO.REL, // because
'\u2236': MO.REL, // ratio
'\u2237': MO.REL, // proportion
'\u2238': MO.BIN4, // dot minus
'\u2239': MO.REL, // excess
'\u223A': MO.BIN4, // geometric proportion
'\u223B': MO.REL, // homothetic
'\u223D': MO.REL, // reversed tilde
'\u223D\u0331': MO.BIN3, // reversed tilde with underline
'\u223E': MO.REL, // inverted lazy s
'\u223F': MO.BIN3, // sine wave
'\u2241': MO.REL, // not tilde
'\u2242': MO.REL, // minus tilde
'\u2242\u0338': MO.REL, // minus tilde with slash
'\u2244': MO.REL, // not asymptotically equal to
'\u2246': MO.REL, // approximately but not actually equal to
'\u2247': MO.REL, // neither approximately nor actually equal to
'\u2249': MO.REL, // not almost equal to
'\u224A': MO.REL, // almost equal or equal to
'\u224B': MO.REL, // triple tilde
'\u224C': MO.REL, // all equal to
'\u224E': MO.REL, // geometrically equivalent to
'\u224E\u0338': MO.REL, // geometrically equivalent to with slash
'\u224F': MO.REL, // difference between
'\u224F\u0338': MO.REL, // difference between with slash
'\u2251': MO.REL, // geometrically equal to
'\u2252': MO.REL, // approximately equal to or the image of
'\u2253': MO.REL, // image of or approximately equal to
'\u2254': MO.REL, // colon equals
'\u2255': MO.REL, // equals colon
'\u2256': MO.REL, // ring in equal to
'\u2257': MO.REL, // ring equal to
'\u2258': MO.REL, // corresponds to
'\u2259': MO.REL, // estimates
'\u225A': MO.REL, // equiangular to
'\u225C': MO.REL, // delta equal to
'\u225D': MO.REL, // equal to by definition
'\u225E': MO.REL, // measured by
'\u225F': MO.REL, // questioned equal to
'\u2262': MO.REL, // not identical to
'\u2263': MO.REL, // strictly equivalent to
'\u2266': MO.REL, // less-than over equal to
'\u2266\u0338': MO.REL, // less-than over equal to with slash
'\u2267': MO.REL, // greater-than over equal to
'\u2268': MO.REL, // less-than but not equal to
'\u2269': MO.REL, // greater-than but not equal to
'\u226A\u0338': MO.REL, // much less than with slash
'\u226B\u0338': MO.REL, // much greater than with slash
'\u226C': MO.REL, // between
'\u226D': MO.REL, // not equivalent to
'\u226E': MO.REL, // not less-than
'\u226F': MO.REL, // not greater-than
'\u2270': MO.REL, // neither less-than nor equal to
'\u2271': MO.REL, // neither greater-than nor equal to
'\u2272': MO.REL, // less-than or equivalent to
'\u2273': MO.REL, // greater-than or equivalent to
'\u2274': MO.REL, // neither less-than nor equivalent to
'\u2275': MO.REL, // neither greater-than nor equivalent to
'\u2276': MO.REL, // less-than or greater-than
'\u2277': MO.REL, // greater-than or less-than
'\u2278': MO.REL, // neither less-than nor greater-than
'\u2279': MO.REL, // neither greater-than nor less-than
'\u227C': MO.REL, // precedes or equal to
'\u227D': MO.REL, // succeeds or equal to
'\u227E': MO.REL, // precedes or equivalent to
'\u227F': MO.REL, // succeeds or equivalent to
'\u227F\u0338': MO.REL, // succeeds or equivalent to with slash
'\u2280': MO.REL, // does not precede
'\u2281': MO.REL, // does not succeed
'\u2282\u20D2': MO.REL, // subset of with vertical line
'\u2283\u20D2': MO.REL, // superset of with vertical line
'\u2284': MO.REL, // not a subset of
'\u2285': MO.REL, // not a superset of
'\u2288': MO.REL, // neither a subset of nor equal to
'\u2289': MO.REL, // neither a superset of nor equal to
'\u228A': MO.REL, // subset of with not equal to
'\u228B': MO.REL, // superset of with not equal to
'\u228C': MO.BIN4, // multiset
'\u228D': MO.BIN4, // multiset multiplication
'\u228F': MO.REL, // square image of
'\u228F\u0338': MO.REL, // square image of with slash
'\u2290': MO.REL, // square original of
'\u2290\u0338': MO.REL, // square original of with slash
'\u229A': MO.BIN4, // circled ring operator
'\u229B': MO.BIN4, // circled asterisk operator
'\u229C': MO.BIN4, // circled equals
'\u229D': MO.BIN4, // circled dash
'\u229E': MO.BIN4, // squared plus
'\u229F': MO.BIN4, // squared minus
'\u22A0': MO.BIN4, // squared times
'\u22A1': MO.BIN4, // squared dot operator
'\u22A6': MO.REL, // assertion
'\u22A7': MO.REL, // models
'\u22A9': MO.REL, // forces
'\u22AA': MO.REL, // triple vertical bar right turnstile
'\u22AB': MO.REL, // double vertical bar double right turnstile
'\u22AC': MO.REL, // does not prove
'\u22AD': MO.REL, // not true
'\u22AE': MO.REL, // does not force
'\u22AF': MO.REL, // negated double vertical bar double right turnstile
'\u22B0': MO.REL, // precedes under relation
'\u22B1': MO.REL, // succeeds under relation
'\u22B2': MO.REL, // normal subgroup of
'\u22B3': MO.REL, // contains as normal subgroup
'\u22B4': MO.REL, // normal subgroup of or equal to
'\u22B5': MO.REL, // contains as normal subgroup or equal to
'\u22B6': MO.REL, // original of
'\u22B7': MO.REL, // image of
'\u22B8': MO.REL, // multimap
'\u22B9': MO.REL, // hermitian conjugate matrix
'\u22BA': MO.BIN4, // intercalate
'\u22BB': MO.BIN4, // xor
'\u22BC': MO.BIN4, // nand
'\u22BD': MO.BIN4, // nor
'\u22BE': MO.BIN3, // right angle with arc
'\u22BF': MO.BIN3, // right triangle
'\u22C7': MO.BIN4, // division times
'\u22C9': MO.BIN4, // left normal factor semidirect product
'\u22CA': MO.BIN4, // right normal factor semidirect product
'\u22CB': MO.BIN4, // left semidirect product
'\u22CC': MO.BIN4, // right semidirect product
'\u22CD': MO.REL, // reversed tilde equals
'\u22CE': MO.BIN4, // curly logical or
'\u22CF': MO.BIN4, // curly logical and
'\u22D0': MO.REL, // double subset
'\u22D1': MO.REL, // double superset
'\u22D2': MO.BIN4, // double intersection
'\u22D3': MO.BIN4, // double union
'\u22D4': MO.REL, // pitchfork
'\u22D5': MO.REL, // equal and parallel to
'\u22D6': MO.REL, // less-than with dot
'\u22D7': MO.REL, // greater-than with dot
'\u22D8': MO.REL, // very much less-than
'\u22D9': MO.REL, // very much greater-than
'\u22DA': MO.REL, // less-than equal to or greater-than
'\u22DB': MO.REL, // greater-than equal to or less-than
'\u22DC': MO.REL, // equal to or less-than
'\u22DD': MO.REL, // equal to or greater-than
'\u22DE': MO.REL, // equal to or precedes
'\u22DF': MO.REL, // equal to or succeeds
'\u22E0': MO.REL, // does not precede or equal
'\u22E1': MO.REL, // does not succeed or equal
'\u22E2': MO.REL, // not square image of or equal to
'\u22E3': MO.REL, // not square original of or equal to
'\u22E4': MO.REL, // square image of or not equal to
'\u22E5': MO.REL, // square original of or not equal to
'\u22E6': MO.REL, // less-than but not equivalent to
'\u22E7': MO.REL, // greater-than but not equivalent to
'\u22E8': MO.REL, // precedes but not equivalent to
'\u22E9': MO.REL, // succeeds but not equivalent to
'\u22EA': MO.REL, // not normal subgroup of
'\u22EB': MO.REL, // does not contain as normal subgroup
'\u22EC': MO.REL, // not normal subgroup of or equal to
'\u22ED': MO.REL, // does not contain as normal subgroup or equal
'\u22F0': MO.REL, // up right diagonal ellipsis
'\u22F2': MO.REL, // element of with long horizontal stroke
'\u22F3': MO.REL, // element of with vertical bar at end of horizontal stroke
'\u22F4': MO.REL, // small element of with vertical bar at end of horizontal stroke
'\u22F5': MO.REL, // element of with dot above
'\u22F6': MO.REL, // element of with overbar
'\u22F7': MO.REL, // small element of with overbar
'\u22F8': MO.REL, // element of with underbar
'\u22F9': MO.REL, // element of with two horizontal strokes
'\u22FA': MO.REL, // contains with long horizontal stroke
'\u22FB': MO.REL, // contains with vertical bar at end of horizontal stroke
'\u22FC': MO.REL, // small contains with vertical bar at end of horizontal stroke
'\u22FD': MO.REL, // contains with overbar
'\u22FE': MO.REL, // small contains with overbar
'\u22FF': MO.REL // z notation bag membership
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MathOperators.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/MiscMathSymbolsA.js
Vendored
+42
View File
@@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u27E6': MO.OPEN, // mathematical left white square bracket
'\u27EA': MO.OPEN, // mathematical left double angle bracket
'\u27EC': MO.OPEN // mathematical left white tortoise shell bracket
},
postfix: {
'\u27E7': MO.CLOSE, // mathematical right white square bracket
'\u27EB': MO.CLOSE, // mathematical right double angle bracket
'\u27ED': MO.CLOSE // mathematical right white tortoise shell bracket
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsA.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/MiscMathSymbolsB.js
Vendored
+168
View File
@@ -0,0 +1,168 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsB.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2980': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // triple vertical bar delimiter
'\u2983': MO.OPEN, // left white curly bracket
'\u2985': MO.OPEN, // left white parenthesis
'\u2987': MO.OPEN, // z notation left image bracket
'\u2989': MO.OPEN, // z notation left binding bracket
'\u298B': MO.OPEN, // left square bracket with underbar
'\u298D': MO.OPEN, // left square bracket with tick in top corner
'\u298F': MO.OPEN, // left square bracket with tick in bottom corner
'\u2991': MO.OPEN, // left angle bracket with dot
'\u2993': MO.OPEN, // left arc less-than bracket
'\u2995': MO.OPEN, // double left arc greater-than bracket
'\u2997': MO.OPEN, // left black tortoise shell bracket
'\u29FC': MO.OPEN // left-pointing curved angle bracket
},
postfix: {
'\u2980': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // triple vertical bar delimiter
'\u2984': MO.CLOSE, // right white curly bracket
'\u2986': MO.CLOSE, // right white parenthesis
'\u2988': MO.CLOSE, // z notation right image bracket
'\u298A': MO.CLOSE, // z notation right binding bracket
'\u298C': MO.CLOSE, // right square bracket with underbar
'\u298E': MO.CLOSE, // right square bracket with tick in bottom corner
'\u2990': MO.CLOSE, // right square bracket with tick in top corner
'\u2992': MO.CLOSE, // right angle bracket with dot
'\u2994': MO.CLOSE, // right arc greater-than bracket
'\u2996': MO.CLOSE, // double right arc less-than bracket
'\u2998': MO.CLOSE, // right black tortoise shell bracket
'\u29FD': MO.CLOSE // right-pointing curved angle bracket
},
infix: {
'\u2981': MO.BIN3, // z notation spot
'\u2982': MO.BIN3, // z notation type colon
'\u2999': MO.BIN3, // dotted fence
'\u299A': MO.BIN3, // vertical zigzag line
'\u299B': MO.BIN3, // measured angle opening left
'\u299C': MO.BIN3, // right angle variant with square
'\u299D': MO.BIN3, // measured right angle with dot
'\u299E': MO.BIN3, // angle with s inside
'\u299F': MO.BIN3, // acute angle
'\u29A0': MO.BIN3, // spherical angle opening left
'\u29A1': MO.BIN3, // spherical angle opening up
'\u29A2': MO.BIN3, // turned angle
'\u29A3': MO.BIN3, // reversed angle
'\u29A4': MO.BIN3, // angle with underbar
'\u29A5': MO.BIN3, // reversed angle with underbar
'\u29A6': MO.BIN3, // oblique angle opening up
'\u29A7': MO.BIN3, // oblique angle opening down
'\u29A8': MO.BIN3, // measured angle with open arm ending in arrow pointing up and right
'\u29A9': MO.BIN3, // measured angle with open arm ending in arrow pointing up and left
'\u29AA': MO.BIN3, // measured angle with open arm ending in arrow pointing down and right
'\u29AB': MO.BIN3, // measured angle with open arm ending in arrow pointing down and left
'\u29AC': MO.BIN3, // measured angle with open arm ending in arrow pointing right and up
'\u29AD': MO.BIN3, // measured angle with open arm ending in arrow pointing left and up
'\u29AE': MO.BIN3, // measured angle with open arm ending in arrow pointing right and down
'\u29AF': MO.BIN3, // measured angle with open arm ending in arrow pointing left and down
'\u29B0': MO.BIN3, // reversed empty set
'\u29B1': MO.BIN3, // empty set with overbar
'\u29B2': MO.BIN3, // empty set with small circle above
'\u29B3': MO.BIN3, // empty set with right arrow above
'\u29B4': MO.BIN3, // empty set with left arrow above
'\u29B5': MO.BIN3, // circle with horizontal bar
'\u29B6': MO.BIN4, // circled vertical bar
'\u29B7': MO.BIN4, // circled parallel
'\u29B8': MO.BIN4, // circled reverse solidus
'\u29B9': MO.BIN4, // circled perpendicular
'\u29BA': MO.BIN4, // circle divided by horizontal bar and top half divided by vertical bar
'\u29BB': MO.BIN4, // circle with superimposed x
'\u29BC': MO.BIN4, // circled anticlockwise-rotated division sign
'\u29BD': MO.BIN4, // up arrow through circle
'\u29BE': MO.BIN4, // circled white bullet
'\u29BF': MO.BIN4, // circled bullet
'\u29C0': MO.REL, // circled less-than
'\u29C1': MO.REL, // circled greater-than
'\u29C2': MO.BIN3, // circle with small circle to the right
'\u29C3': MO.BIN3, // circle with two horizontal strokes to the right
'\u29C4': MO.BIN4, // squared rising diagonal slash
'\u29C5': MO.BIN4, // squared falling diagonal slash
'\u29C6': MO.BIN4, // squared asterisk
'\u29C7': MO.BIN4, // squared small circle
'\u29C8': MO.BIN4, // squared square
'\u29C9': MO.BIN3, // two joined squares
'\u29CA': MO.BIN3, // triangle with dot above
'\u29CB': MO.BIN3, // triangle with underbar
'\u29CC': MO.BIN3, // s in triangle
'\u29CD': MO.BIN3, // triangle with serifs at bottom
'\u29CE': MO.REL, // right triangle above left triangle
'\u29CF': MO.REL, // left triangle beside vertical bar
'\u29CF\u0338': MO.REL, // left triangle beside vertical bar with slash
'\u29D0': MO.REL, // vertical bar beside right triangle
'\u29D0\u0338': MO.REL, // vertical bar beside right triangle with slash
'\u29D1': MO.REL, // bowtie with left half black
'\u29D2': MO.REL, // bowtie with right half black
'\u29D3': MO.REL, // black bowtie
'\u29D4': MO.REL, // times with left half black
'\u29D5': MO.REL, // times with right half black
'\u29D6': MO.BIN4, // white hourglass
'\u29D7': MO.BIN4, // black hourglass
'\u29D8': MO.BIN3, // left wiggly fence
'\u29D9': MO.BIN3, // right wiggly fence
'\u29DB': MO.BIN3, // right double wiggly fence
'\u29DC': MO.BIN3, // incomplete infinity
'\u29DD': MO.BIN3, // tie over infinity
'\u29DE': MO.REL, // infinity negated with vertical bar
'\u29DF': MO.BIN3, // double-ended multimap
'\u29E0': MO.BIN3, // square with contoured outline
'\u29E1': MO.REL, // increases as
'\u29E2': MO.BIN4, // shuffle product
'\u29E3': MO.REL, // equals sign and slanted parallel
'\u29E4': MO.REL, // equals sign and slanted parallel with tilde above
'\u29E5': MO.REL, // identical to and slanted parallel
'\u29E6': MO.REL, // gleich stark
'\u29E7': MO.BIN3, // thermodynamic
'\u29E8': MO.BIN3, // down-pointing triangle with left half black
'\u29E9': MO.BIN3, // down-pointing triangle with right half black
'\u29EA': MO.BIN3, // black diamond with down arrow
'\u29EB': MO.BIN3, // black lozenge
'\u29EC': MO.BIN3, // white circle with down arrow
'\u29ED': MO.BIN3, // black circle with down arrow
'\u29EE': MO.BIN3, // error-barred white square
'\u29EF': MO.BIN3, // error-barred black square
'\u29F0': MO.BIN3, // error-barred white diamond
'\u29F1': MO.BIN3, // error-barred black diamond
'\u29F2': MO.BIN3, // error-barred white circle
'\u29F3': MO.BIN3, // error-barred black circle
'\u29F4': MO.REL, // rule-delayed
'\u29F5': MO.BIN4, // reverse solidus operator
'\u29F6': MO.BIN4, // solidus with overbar
'\u29F7': MO.BIN4, // reverse solidus with horizontal stroke
'\u29F8': MO.BIN3, // big solidus
'\u29F9': MO.BIN3, // big reverse solidus
'\u29FA': MO.BIN3, // double plus
'\u29FB': MO.BIN3, // triple plus
'\u29FE': MO.BIN4, // tiny
'\u29FF': MO.BIN4 // miny
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsB.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/MiscSymbolsAndArrows.js
Vendored
+36
View File
@@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscSymbolsAndArrows.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u2B45': MO.RELSTRETCH, // leftwards quadruple arrow
'\u2B46': MO.RELSTRETCH // rightwards quadruple arrow
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscSymbolsAndArrows.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/MiscTechnical.js
Vendored
+40
View File
@@ -0,0 +1,40 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u23B4': MO.WIDEACCENT, // top square bracket
'\u23B5': MO.WIDEACCENT, // bottom square bracket
'\u23DC': MO.WIDEACCENT, // top parenthesis
'\u23DD': MO.WIDEACCENT, // bottom parenthesis
'\u23E0': MO.WIDEACCENT, // top tortoise shell bracket
'\u23E1': MO.WIDEACCENT // bottom tortoise shell bracket
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/MiscTechnical.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/SpacingModLetters.js
Vendored
+38
View File
@@ -0,0 +1,38 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
postfix: {
'\u02CD': MO.WIDEACCENT, // modifier letter low macron
'\u02DA': MO.ACCENT, // ring above
'\u02DD': MO.ACCENT, // double acute accent
'\u02F7': MO.WIDEACCENT // modifier letter low tilde
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SpacingModLetters.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/SuppMathOperators.js
Vendored
+289
View File
@@ -0,0 +1,289 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SuppMathOperators.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
prefix: {
'\u2A03': MO.OP, // n-ary union operator with dot
'\u2A05': MO.OP, // n-ary square intersection operator
'\u2A07': MO.OP, // two logical and operator
'\u2A08': MO.OP, // two logical or operator
'\u2A09': MO.OP, // n-ary times operator
'\u2A0A': MO.OP, // modulo two sum
'\u2A0B': MO.INTEGRAL2, // summation with integral
'\u2A0C': MO.INTEGRAL, // quadruple integral operator
'\u2A0D': MO.INTEGRAL2, // finite part integral
'\u2A0E': MO.INTEGRAL2, // integral with double stroke
'\u2A0F': MO.INTEGRAL2, // integral average with slash
'\u2A10': MO.OP, // circulation function
'\u2A11': MO.OP, // anticlockwise integration
'\u2A12': MO.OP, // line integration with rectangular path around pole
'\u2A13': MO.OP, // line integration with semicircular path around pole
'\u2A14': MO.OP, // line integration not including the pole
'\u2A15': MO.INTEGRAL2, // integral around a point operator
'\u2A16': MO.INTEGRAL2, // quaternion integral operator
'\u2A17': MO.INTEGRAL2, // integral with leftwards arrow with hook
'\u2A18': MO.INTEGRAL2, // integral with times sign
'\u2A19': MO.INTEGRAL2, // integral with intersection
'\u2A1A': MO.INTEGRAL2, // integral with union
'\u2A1B': MO.INTEGRAL2, // integral with overbar
'\u2A1C': MO.INTEGRAL2, // integral with underbar
'\u2AFC': MO.OP, // large triple vertical bar operator
'\u2AFF': MO.OP // n-ary white vertical bar
},
infix: {
'\u2A1D': MO.BIN3, // join
'\u2A1E': MO.BIN3, // large left triangle operator
'\u2A1F': MO.BIN3, // z notation schema composition
'\u2A20': MO.BIN3, // z notation schema piping
'\u2A21': MO.BIN3, // z notation schema projection
'\u2A22': MO.BIN4, // plus sign with small circle above
'\u2A23': MO.BIN4, // plus sign with circumflex accent above
'\u2A24': MO.BIN4, // plus sign with tilde above
'\u2A25': MO.BIN4, // plus sign with dot below
'\u2A26': MO.BIN4, // plus sign with tilde below
'\u2A27': MO.BIN4, // plus sign with subscript two
'\u2A28': MO.BIN4, // plus sign with black triangle
'\u2A29': MO.BIN4, // minus sign with comma above
'\u2A2A': MO.BIN4, // minus sign with dot below
'\u2A2B': MO.BIN4, // minus sign with falling dots
'\u2A2C': MO.BIN4, // minus sign with rising dots
'\u2A2D': MO.BIN4, // plus sign in left half circle
'\u2A2E': MO.BIN4, // plus sign in right half circle
'\u2A30': MO.BIN4, // multiplication sign with dot above
'\u2A31': MO.BIN4, // multiplication sign with underbar
'\u2A32': MO.BIN4, // semidirect product with bottom closed
'\u2A33': MO.BIN4, // smash product
'\u2A34': MO.BIN4, // multiplication sign in left half circle
'\u2A35': MO.BIN4, // multiplication sign in right half circle
'\u2A36': MO.BIN4, // circled multiplication sign with circumflex accent
'\u2A37': MO.BIN4, // multiplication sign in double circle
'\u2A38': MO.BIN4, // circled division sign
'\u2A39': MO.BIN4, // plus sign in triangle
'\u2A3A': MO.BIN4, // minus sign in triangle
'\u2A3B': MO.BIN4, // multiplication sign in triangle
'\u2A3C': MO.BIN4, // interior product
'\u2A3D': MO.BIN4, // righthand interior product
'\u2A3E': MO.BIN4, // z notation relational composition
'\u2A40': MO.BIN4, // intersection with dot
'\u2A41': MO.BIN4, // union with minus sign
'\u2A42': MO.BIN4, // union with overbar
'\u2A43': MO.BIN4, // intersection with overbar
'\u2A44': MO.BIN4, // intersection with logical and
'\u2A45': MO.BIN4, // union with logical or
'\u2A46': MO.BIN4, // union above intersection
'\u2A47': MO.BIN4, // intersection above union
'\u2A48': MO.BIN4, // union above bar above intersection
'\u2A49': MO.BIN4, // intersection above bar above union
'\u2A4A': MO.BIN4, // union beside and joined with union
'\u2A4B': MO.BIN4, // intersection beside and joined with intersection
'\u2A4C': MO.BIN4, // closed union with serifs
'\u2A4D': MO.BIN4, // closed intersection with serifs
'\u2A4E': MO.BIN4, // double square intersection
'\u2A4F': MO.BIN4, // double square union
'\u2A50': MO.BIN4, // closed union with serifs and smash product
'\u2A51': MO.BIN4, // logical and with dot above
'\u2A52': MO.BIN4, // logical or with dot above
'\u2A53': MO.BIN4, // double logical and
'\u2A54': MO.BIN4, // double logical or
'\u2A55': MO.BIN4, // two intersecting logical and
'\u2A56': MO.BIN4, // two intersecting logical or
'\u2A57': MO.BIN4, // sloping large or
'\u2A58': MO.BIN4, // sloping large and
'\u2A59': MO.REL, // logical or overlapping logical and
'\u2A5A': MO.BIN4, // logical and with middle stem
'\u2A5B': MO.BIN4, // logical or with middle stem
'\u2A5C': MO.BIN4, // logical and with horizontal dash
'\u2A5D': MO.BIN4, // logical or with horizontal dash
'\u2A5E': MO.BIN4, // logical and with double overbar
'\u2A5F': MO.BIN4, // logical and with underbar
'\u2A60': MO.BIN4, // logical and with double underbar
'\u2A61': MO.BIN4, // small vee with underbar
'\u2A62': MO.BIN4, // logical or with double overbar
'\u2A63': MO.BIN4, // logical or with double underbar
'\u2A64': MO.BIN4, // z notation domain antirestriction
'\u2A65': MO.BIN4, // z notation range antirestriction
'\u2A66': MO.REL, // equals sign with dot below
'\u2A67': MO.REL, // identical with dot above
'\u2A68': MO.REL, // triple horizontal bar with double vertical stroke
'\u2A69': MO.REL, // triple horizontal bar with triple vertical stroke
'\u2A6A': MO.REL, // tilde operator with dot above
'\u2A6B': MO.REL, // tilde operator with rising dots
'\u2A6C': MO.REL, // similar minus similar
'\u2A6D': MO.REL, // congruent with dot above
'\u2A6E': MO.REL, // equals with asterisk
'\u2A6F': MO.REL, // almost equal to with circumflex accent
'\u2A70': MO.REL, // approximately equal or equal to
'\u2A71': MO.BIN4, // equals sign above plus sign
'\u2A72': MO.BIN4, // plus sign above equals sign
'\u2A73': MO.REL, // equals sign above tilde operator
'\u2A74': MO.REL, // double colon equal
'\u2A75': MO.REL, // two consecutive equals signs
'\u2A76': MO.REL, // three consecutive equals signs
'\u2A77': MO.REL, // equals sign with two dots above and two dots below
'\u2A78': MO.REL, // equivalent with four dots above
'\u2A79': MO.REL, // less-than with circle inside
'\u2A7A': MO.REL, // greater-than with circle inside
'\u2A7B': MO.REL, // less-than with question mark above
'\u2A7C': MO.REL, // greater-than with question mark above
'\u2A7D': MO.REL, // less-than or slanted equal to
'\u2A7D\u0338': MO.REL, // less-than or slanted equal to with slash
'\u2A7E': MO.REL, // greater-than or slanted equal to
'\u2A7E\u0338': MO.REL, // greater-than or slanted equal to with slash
'\u2A7F': MO.REL, // less-than or slanted equal to with dot inside
'\u2A80': MO.REL, // greater-than or slanted equal to with dot inside
'\u2A81': MO.REL, // less-than or slanted equal to with dot above
'\u2A82': MO.REL, // greater-than or slanted equal to with dot above
'\u2A83': MO.REL, // less-than or slanted equal to with dot above right
'\u2A84': MO.REL, // greater-than or slanted equal to with dot above left
'\u2A85': MO.REL, // less-than or approximate
'\u2A86': MO.REL, // greater-than or approximate
'\u2A87': MO.REL, // less-than and single-line not equal to
'\u2A88': MO.REL, // greater-than and single-line not equal to
'\u2A89': MO.REL, // less-than and not approximate
'\u2A8A': MO.REL, // greater-than and not approximate
'\u2A8B': MO.REL, // less-than above double-line equal above greater-than
'\u2A8C': MO.REL, // greater-than above double-line equal above less-than
'\u2A8D': MO.REL, // less-than above similar or equal
'\u2A8E': MO.REL, // greater-than above similar or equal
'\u2A8F': MO.REL, // less-than above similar above greater-than
'\u2A90': MO.REL, // greater-than above similar above less-than
'\u2A91': MO.REL, // less-than above greater-than above double-line equal
'\u2A92': MO.REL, // greater-than above less-than above double-line equal
'\u2A93': MO.REL, // less-than above slanted equal above greater-than above slanted equal
'\u2A94': MO.REL, // greater-than above slanted equal above less-than above slanted equal
'\u2A95': MO.REL, // slanted equal to or less-than
'\u2A96': MO.REL, // slanted equal to or greater-than
'\u2A97': MO.REL, // slanted equal to or less-than with dot inside
'\u2A98': MO.REL, // slanted equal to or greater-than with dot inside
'\u2A99': MO.REL, // double-line equal to or less-than
'\u2A9A': MO.REL, // double-line equal to or greater-than
'\u2A9B': MO.REL, // double-line slanted equal to or less-than
'\u2A9C': MO.REL, // double-line slanted equal to or greater-than
'\u2A9D': MO.REL, // similar or less-than
'\u2A9E': MO.REL, // similar or greater-than
'\u2A9F': MO.REL, // similar above less-than above equals sign
'\u2AA0': MO.REL, // similar above greater-than above equals sign
'\u2AA1': MO.REL, // double nested less-than
'\u2AA1\u0338': MO.REL, // double nested less-than with slash
'\u2AA2': MO.REL, // double nested greater-than
'\u2AA2\u0338': MO.REL, // double nested greater-than with slash
'\u2AA3': MO.REL, // double nested less-than with underbar
'\u2AA4': MO.REL, // greater-than overlapping less-than
'\u2AA5': MO.REL, // greater-than beside less-than
'\u2AA6': MO.REL, // less-than closed by curve
'\u2AA7': MO.REL, // greater-than closed by curve
'\u2AA8': MO.REL, // less-than closed by curve above slanted equal
'\u2AA9': MO.REL, // greater-than closed by curve above slanted equal
'\u2AAA': MO.REL, // smaller than
'\u2AAB': MO.REL, // larger than
'\u2AAC': MO.REL, // smaller than or equal to
'\u2AAD': MO.REL, // larger than or equal to
'\u2AAE': MO.REL, // equals sign with bumpy above
'\u2AAF\u0338': MO.REL, // precedes above single-line equals sign with slash
'\u2AB0\u0338': MO.REL, // succeeds above single-line equals sign with slash
'\u2AB1': MO.REL, // precedes above single-line not equal to
'\u2AB2': MO.REL, // succeeds above single-line not equal to
'\u2AB3': MO.REL, // precedes above equals sign
'\u2AB4': MO.REL, // succeeds above equals sign
'\u2AB5': MO.REL, // precedes above not equal to
'\u2AB6': MO.REL, // succeeds above not equal to
'\u2AB7': MO.REL, // precedes above almost equal to
'\u2AB8': MO.REL, // succeeds above almost equal to
'\u2AB9': MO.REL, // precedes above not almost equal to
'\u2ABA': MO.REL, // succeeds above not almost equal to
'\u2ABB': MO.REL, // double precedes
'\u2ABC': MO.REL, // double succeeds
'\u2ABD': MO.REL, // subset with dot
'\u2ABE': MO.REL, // superset with dot
'\u2ABF': MO.REL, // subset with plus sign below
'\u2AC0': MO.REL, // superset with plus sign below
'\u2AC1': MO.REL, // subset with multiplication sign below
'\u2AC2': MO.REL, // superset with multiplication sign below
'\u2AC3': MO.REL, // subset of or equal to with dot above
'\u2AC4': MO.REL, // superset of or equal to with dot above
'\u2AC5': MO.REL, // subset of above equals sign
'\u2AC6': MO.REL, // superset of above equals sign
'\u2AC7': MO.REL, // subset of above tilde operator
'\u2AC8': MO.REL, // superset of above tilde operator
'\u2AC9': MO.REL, // subset of above almost equal to
'\u2ACA': MO.REL, // superset of above almost equal to
'\u2ACB': MO.REL, // subset of above not equal to
'\u2ACC': MO.REL, // superset of above not equal to
'\u2ACD': MO.REL, // square left open box operator
'\u2ACE': MO.REL, // square right open box operator
'\u2ACF': MO.REL, // closed subset
'\u2AD0': MO.REL, // closed superset
'\u2AD1': MO.REL, // closed subset or equal to
'\u2AD2': MO.REL, // closed superset or equal to
'\u2AD3': MO.REL, // subset above superset
'\u2AD4': MO.REL, // superset above subset
'\u2AD5': MO.REL, // subset above subset
'\u2AD6': MO.REL, // superset above superset
'\u2AD7': MO.REL, // superset beside subset
'\u2AD8': MO.REL, // superset beside and joined by dash with subset
'\u2AD9': MO.REL, // element of opening downwards
'\u2ADA': MO.REL, // pitchfork with tee top
'\u2ADB': MO.REL, // transversal intersection
'\u2ADC': MO.REL, // forking
'\u2ADD': MO.REL, // nonforking
'\u2ADE': MO.REL, // short left tack
'\u2ADF': MO.REL, // short down tack
'\u2AE0': MO.REL, // short up tack
'\u2AE1': MO.REL, // perpendicular with s
'\u2AE2': MO.REL, // vertical bar triple right turnstile
'\u2AE3': MO.REL, // double vertical bar left turnstile
'\u2AE4': MO.REL, // vertical bar double left turnstile
'\u2AE5': MO.REL, // double vertical bar double left turnstile
'\u2AE6': MO.REL, // long dash from left member of double vertical
'\u2AE7': MO.REL, // short down tack with overbar
'\u2AE8': MO.REL, // short up tack with underbar
'\u2AE9': MO.REL, // short up tack above short down tack
'\u2AEA': MO.REL, // double down tack
'\u2AEB': MO.REL, // double up tack
'\u2AEC': MO.REL, // double stroke not sign
'\u2AED': MO.REL, // reversed double stroke not sign
'\u2AEE': MO.REL, // does not divide with reversed negation slash
'\u2AEF': MO.REL, // vertical line with circle above
'\u2AF0': MO.REL, // vertical line with circle below
'\u2AF1': MO.REL, // down tack with circle below
'\u2AF2': MO.REL, // parallel with horizontal stroke
'\u2AF3': MO.REL, // parallel with tilde operator
'\u2AF4': MO.BIN4, // triple vertical bar binary relation
'\u2AF5': MO.BIN4, // triple vertical bar with horizontal stroke
'\u2AF6': MO.BIN4, // triple colon operator
'\u2AF7': MO.REL, // triple nested less-than
'\u2AF8': MO.REL, // triple nested greater-than
'\u2AF9': MO.REL, // double-line slanted less-than or equal to
'\u2AFA': MO.REL, // double-line slanted greater-than or equal to
'\u2AFB': MO.BIN4, // triple solidus binary relation
'\u2AFD': MO.BIN4, // double solidus operator
'\u2AFE': MO.BIN3 // white vertical bar
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SuppMathOperators.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/SupplementalArrowsA.js
Vendored
+40
View File
@@ -0,0 +1,40 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsA.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u27F0': MO.RELSTRETCH, // upwards quadruple arrow
'\u27F1': MO.RELSTRETCH, // downwards quadruple arrow
'\u27FB': MO.WIDEREL, // long leftwards arrow from bar
'\u27FD': MO.WIDEREL, // long leftwards double arrow from bar
'\u27FE': MO.WIDEREL, // long rightwards double arrow from bar
'\u27FF': MO.WIDEREL // long rightwards squiggle arrow
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsA.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/element/mml/optable/SupplementalArrowsB.js
Vendored
+162
View File
@@ -0,0 +1,162 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js
*
* Copyright (c) 2010-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (MML) {
var MO = MML.mo.OPTYPES;
var TEXCLASS = MML.TEXCLASS;
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
infix: {
'\u2900': MO.RELACCENT, // rightwards two-headed arrow with vertical stroke
'\u2901': MO.RELACCENT, // rightwards two-headed arrow with double vertical stroke
'\u2902': MO.RELACCENT, // leftwards double arrow with vertical stroke
'\u2903': MO.RELACCENT, // rightwards double arrow with vertical stroke
'\u2904': MO.RELACCENT, // left right double arrow with vertical stroke
'\u2905': MO.RELACCENT, // rightwards two-headed arrow from bar
'\u2906': MO.RELACCENT, // leftwards double arrow from bar
'\u2907': MO.RELACCENT, // rightwards double arrow from bar
'\u2908': MO.REL, // downwards arrow with horizontal stroke
'\u2909': MO.REL, // upwards arrow with horizontal stroke
'\u290A': MO.RELSTRETCH, // upwards triple arrow
'\u290B': MO.RELSTRETCH, // downwards triple arrow
'\u290C': MO.WIDEREL, // leftwards double dash arrow
'\u290D': MO.WIDEREL, // rightwards double dash arrow
'\u290E': MO.WIDEREL, // leftwards triple dash arrow
'\u290F': MO.WIDEREL, // rightwards triple dash arrow
'\u2910': MO.WIDEREL, // rightwards two-headed triple dash arrow
'\u2911': MO.RELACCENT, // rightwards arrow with dotted stem
'\u2912': MO.RELSTRETCH, // upwards arrow to bar
'\u2913': MO.RELSTRETCH, // downwards arrow to bar
'\u2914': MO.RELACCENT, // rightwards arrow with tail with vertical stroke
'\u2915': MO.RELACCENT, // rightwards arrow with tail with double vertical stroke
'\u2916': MO.RELACCENT, // rightwards two-headed arrow with tail
'\u2917': MO.RELACCENT, // rightwards two-headed arrow with tail with vertical stroke
'\u2918': MO.RELACCENT, // rightwards two-headed arrow with tail with double vertical stroke
'\u2919': MO.RELACCENT, // leftwards arrow-tail
'\u291A': MO.RELACCENT, // rightwards arrow-tail
'\u291B': MO.RELACCENT, // leftwards double arrow-tail
'\u291C': MO.RELACCENT, // rightwards double arrow-tail
'\u291D': MO.RELACCENT, // leftwards arrow to black diamond
'\u291E': MO.RELACCENT, // rightwards arrow to black diamond
'\u291F': MO.RELACCENT, // leftwards arrow from bar to black diamond
'\u2920': MO.RELACCENT, // rightwards arrow from bar to black diamond
'\u2921': MO.RELSTRETCH, // north west and south east arrow
'\u2922': MO.RELSTRETCH, // north east and south west arrow
'\u2923': MO.REL, // north west arrow with hook
'\u2924': MO.REL, // north east arrow with hook
'\u2925': MO.REL, // south east arrow with hook
'\u2926': MO.REL, // south west arrow with hook
'\u2927': MO.REL, // north west arrow and north east arrow
'\u2928': MO.REL, // north east arrow and south east arrow
'\u2929': MO.REL, // south east arrow and south west arrow
'\u292A': MO.REL, // south west arrow and north west arrow
'\u292B': MO.REL, // rising diagonal crossing falling diagonal
'\u292C': MO.REL, // falling diagonal crossing rising diagonal
'\u292D': MO.REL, // south east arrow crossing north east arrow
'\u292E': MO.REL, // north east arrow crossing south east arrow
'\u292F': MO.REL, // falling diagonal crossing north east arrow
'\u2930': MO.REL, // rising diagonal crossing south east arrow
'\u2931': MO.REL, // north east arrow crossing north west arrow
'\u2932': MO.REL, // north west arrow crossing north east arrow
'\u2933': MO.RELACCENT, // wave arrow pointing directly right
'\u2934': MO.REL, // arrow pointing rightwards then curving upwards
'\u2935': MO.REL, // arrow pointing rightwards then curving downwards
'\u2936': MO.REL, // arrow pointing downwards then curving leftwards
'\u2937': MO.REL, // arrow pointing downwards then curving rightwards
'\u2938': MO.REL, // right-side arc clockwise arrow
'\u2939': MO.REL, // left-side arc anticlockwise arrow
'\u293A': MO.RELACCENT, // top arc anticlockwise arrow
'\u293B': MO.RELACCENT, // bottom arc anticlockwise arrow
'\u293C': MO.RELACCENT, // top arc clockwise arrow with minus
'\u293D': MO.RELACCENT, // top arc anticlockwise arrow with plus
'\u293E': MO.REL, // lower right semicircular clockwise arrow
'\u293F': MO.REL, // lower left semicircular anticlockwise arrow
'\u2940': MO.REL, // anticlockwise closed circle arrow
'\u2941': MO.REL, // clockwise closed circle arrow
'\u2942': MO.RELACCENT, // rightwards arrow above short leftwards arrow
'\u2943': MO.RELACCENT, // leftwards arrow above short rightwards arrow
'\u2944': MO.RELACCENT, // short rightwards arrow above leftwards arrow
'\u2945': MO.RELACCENT, // rightwards arrow with plus below
'\u2946': MO.RELACCENT, // leftwards arrow with plus below
'\u2947': MO.RELACCENT, // rightwards arrow through x
'\u2948': MO.RELACCENT, // left right arrow through small circle
'\u2949': MO.REL, // upwards two-headed arrow from small circle
'\u294A': MO.RELACCENT, // left barb up right barb down harpoon
'\u294B': MO.RELACCENT, // left barb down right barb up harpoon
'\u294C': MO.REL, // up barb right down barb left harpoon
'\u294D': MO.REL, // up barb left down barb right harpoon
'\u294E': MO.WIDEREL, // left barb up right barb up harpoon
'\u294F': MO.RELSTRETCH, // up barb right down barb right harpoon
'\u2950': MO.WIDEREL, // left barb down right barb down harpoon
'\u2951': MO.RELSTRETCH, // up barb left down barb left harpoon
'\u2952': MO.WIDEREL, // leftwards harpoon with barb up to bar
'\u2953': MO.WIDEREL, // rightwards harpoon with barb up to bar
'\u2954': MO.RELSTRETCH, // upwards harpoon with barb right to bar
'\u2955': MO.RELSTRETCH, // downwards harpoon with barb right to bar
'\u2956': MO.RELSTRETCH, // leftwards harpoon with barb down to bar
'\u2957': MO.RELSTRETCH, // rightwards harpoon with barb down to bar
'\u2958': MO.RELSTRETCH, // upwards harpoon with barb left to bar
'\u2959': MO.RELSTRETCH, // downwards harpoon with barb left to bar
'\u295A': MO.WIDEREL, // leftwards harpoon with barb up from bar
'\u295B': MO.WIDEREL, // rightwards harpoon with barb up from bar
'\u295C': MO.RELSTRETCH, // upwards harpoon with barb right from bar
'\u295D': MO.RELSTRETCH, // downwards harpoon with barb right from bar
'\u295E': MO.WIDEREL, // leftwards harpoon with barb down from bar
'\u295F': MO.WIDEREL, // rightwards harpoon with barb down from bar
'\u2960': MO.RELSTRETCH, // upwards harpoon with barb left from bar
'\u2961': MO.RELSTRETCH, // downwards harpoon with barb left from bar
'\u2962': MO.RELACCENT, // leftwards harpoon with barb up above leftwards harpoon with barb down
'\u2963': MO.REL, // upwards harpoon with barb left beside upwards harpoon with barb right
'\u2964': MO.RELACCENT, // rightwards harpoon with barb up above rightwards harpoon with barb down
'\u2965': MO.REL, // downwards harpoon with barb left beside downwards harpoon with barb right
'\u2966': MO.RELACCENT, // leftwards harpoon with barb up above rightwards harpoon with barb up
'\u2967': MO.RELACCENT, // leftwards harpoon with barb down above rightwards harpoon with barb down
'\u2968': MO.RELACCENT, // rightwards harpoon with barb up above leftwards harpoon with barb up
'\u2969': MO.RELACCENT, // rightwards harpoon with barb down above leftwards harpoon with barb down
'\u296A': MO.RELACCENT, // leftwards harpoon with barb up above long dash
'\u296B': MO.RELACCENT, // leftwards harpoon with barb down below long dash
'\u296C': MO.RELACCENT, // rightwards harpoon with barb up above long dash
'\u296D': MO.RELACCENT, // rightwards harpoon with barb down below long dash
'\u296E': MO.RELSTRETCH, // upwards harpoon with barb left beside downwards harpoon with barb right
'\u296F': MO.RELSTRETCH, // downwards harpoon with barb left beside upwards harpoon with barb right
'\u2970': MO.RELACCENT, // right double arrow with rounded head
'\u2971': MO.RELACCENT, // equals sign above rightwards arrow
'\u2972': MO.RELACCENT, // tilde operator above rightwards arrow
'\u2973': MO.RELACCENT, // leftwards arrow above tilde operator
'\u2974': MO.RELACCENT, // rightwards arrow above tilde operator
'\u2975': MO.RELACCENT, // rightwards arrow above almost equal to
'\u2976': MO.RELACCENT, // less-than above leftwards arrow
'\u2977': MO.RELACCENT, // leftwards arrow through less-than
'\u2978': MO.RELACCENT, // greater-than above rightwards arrow
'\u2979': MO.RELACCENT, // subset above rightwards arrow
'\u297A': MO.RELACCENT, // leftwards arrow through subset
'\u297B': MO.RELACCENT, // superset above leftwards arrow
'\u297C': MO.RELACCENT, // left fish tail
'\u297D': MO.RELACCENT, // right fish tail
'\u297E': MO.REL, // up fish tail
'\u297F': MO.REL // down fish tail
}
}
});
MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsB.js");
})(MathJax.ElementJax.mml);
python/ipnb/resources/MathJax/jax/input/AsciiMath/config.js
Vendored
+46
View File
@@ -0,0 +1,46 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/input/AsciiMath/config.js
*
* Initializes the AsciiMath InputJax (the main definition is in
* MathJax/jax/input/AsciiMath/jax.js, which is loaded when needed).
*
* Originally adapted for MathJax by David Lippman.
* Additional work done by Davide P. Cervone.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2012-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.InputJax.AsciiMath = MathJax.InputJax({
id: "AsciiMath",
version: "2.6.0",
directory: MathJax.InputJax.directory + "/AsciiMath",
extensionDir: MathJax.InputJax.extensionDir + "/AsciiMath",
config: {
fixphi: true, // switch phi and varphi unicode values
useMathMLspacing: true, // use MathML spacing rather than TeX spacing?
displaystyle: true, // put limits above and below operators
decimalsign: "." // can change to "," but watch out for "(1,2)"
}
});
MathJax.InputJax.AsciiMath.Register("math/asciimath");
MathJax.InputJax.AsciiMath.loadComplete("config.js");
python/ipnb/resources/MathJax/jax/input/AsciiMath/jax.js
Vendored
+1480
View File
File diff suppressed because it is too large Load Diff
python/ipnb/resources/MathJax/jax/input/MathML/config.js
Vendored
+41
View File
@@ -0,0 +1,41 @@
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/*************************************************************
*
* MathJax/jax/input/MathML/config.js
*
* Initializes the MathML InputJax (the main definition is in
* MathJax/jax/input/MathML/jax.js, which is loaded when needed).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2015 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.InputJax.MathML = MathJax.InputJax({
id: "MathML",
version: "2.6.1",
directory: MathJax.InputJax.directory + "/MathML",
extensionDir: MathJax.InputJax.extensionDir + "/MathML",
entityDir: MathJax.InputJax.directory + "/MathML/entities",
config: {
useMathMLspacing: false // false means use TeX spacing, true means MML spacing
}
});
MathJax.InputJax.MathML.Register("math/mml");
MathJax.InputJax.MathML.loadComplete("config.js");

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