E-book viewer: SUpport for displaying mathematics in epub files, via mathjax

This commit is contained in:
Kovid Goyal 2012-08-18 15:53:50 +05:30
parent 7e57c01eb1
commit 5bd3086aed
199 changed files with 33621 additions and 3 deletions

View File

@ -41,6 +41,12 @@ License: Apache 2.0
The full text of the Apache 2.0 license is available at: The full text of the Apache 2.0 license is available at:
http://www.apache.org/licenses/LICENSE-2.0 http://www.apache.org/licenses/LICENSE-2.0
Files: resources/viewer/mathjax/*
Copyright: Unknown
License: Apache 2.0
The full text of the Apache 2.0 license is available at:
http://www.apache.org/licenses/LICENSE-2.0
Files: /src/cherrypy/* Files: /src/cherrypy/*
Copyright: Copyright (c) 2004-2007, CherryPy Team (team@cherrypy.org) Copyright: Copyright (c) 2004-2007, CherryPy Team (team@cherrypy.org)
Copyright: Copyright (C) 2005, Tiago Cogumbreiro <cogumbreiro@users.sf.net> Copyright: Copyright (C) 2005, Tiago Cogumbreiro <cogumbreiro@users.sf.net>

Binary file not shown.

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,286 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.0";
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"],
"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"],
"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"],
"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"],
"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"],
"MathJax can use either the ",
["a",{href:"http://www.stixfonts.org/",target:"_blank"},"STIX fonts"],
" or the ",
["a",{href:"http://www.mathjax.org/help-v2/fonts/",target:"_blank"},["MathJax TeX fonts"]],
". Download and install either one to improve your MathJax experience."
],
STIXfonts: [
["p"],
"This page is designed to use the ",
["a",{href:"http://www.stixfonts.org/",target:"_blank"},"STIX fonts"],
". Download and install those fonts to improve your MathJax experience."
],
TeXfonts: [
["p"],
"This page is designed to use the ",
["a",{href:"http://www.mathjax.org/help-v2/fonts/",target:"_blank"},["MathJax TeX fonts"]],
". Download and install those fonts to improve your MathJax experience."
]
},
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");
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 && CONFIG.HTML[data[i][0]])
{data.splice.apply(data,[i,1].concat(CONFIG.HTML[data[i][0]]))} else {i++}
}
DATA.div = HTMLCSS.addElement(frame,"div",{id:"MathJax_FontWarning",style:CONFIG.messageStyle},data);
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]) {CREATEMESSAGE(CONFIG.Message[MSG])}
}
});
}
})(MathJax.Hub,MathJax.HTML);
MathJax.Ajax.loadComplete("[MathJax]/extensions/FontWarnings.js");

View File

@ -0,0 +1,531 @@
/*************************************************************
*
* MathJax/extensions/MathEvents.js
*
* Implements the event handlers needed by the output jax to perform
* menu, hover, and other events.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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,OUTPUT,INPUT) {
var VERSION = "2.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: -4, y: -3, // menu button offsets
wx: -2, // button offset for full-width equations
src: AJAX.fileURL(OUTPUT.imageDir+"/MenuArrow-15.png") // button image
},
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_Hover_Arrow": {
position:"absolute",
width:"15px", height:"11px",
cursor:"pointer"
}
}
};
//
// 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
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()}
if (event.stopPropagation) {event.stopPropagation()}
event.cancelBubble = true;
event.returnValue = false;
}
return false;
},
//
// 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, post the menu
// Otherwse lad the menu code and try again
//
var MENU = MathJax.Menu;
if (MENU) {
MENU.jax = jax;
var source = MENU.menu.Find("Show Math As").menu;
source.items[1].name = (INPUT[jax.inputJax].sourceMenuTitle||"Original Form");
source.items[0].hidden = (jax.inputJax === "Error"); // hide MathML choice for error messages
var MathPlayer = MENU.menu.Find("Math Settings","MathPlayer");
MathPlayer.hidden = !(jax.outputJax === "NativeMML" && HUB.Browser.hasMathPlayer);
return MENU.menu.Post(event);
} else {
if (!AJAX.loadingMathMenu) {
AJAX.loadingMathMenu = true;
var ev = {
pageX:event.pageX, pageY:event.pageY,
clientX:event.clientX, clientY:event.clientY
};
CALLBACK.Queue(
AJAX.Require("[MathJax]/extensions/MathMenu.js"),
function () {delete AJAX.loadingMathMenu; if (!MathJax.Menu) {MathJax.Menu = {}}},
["ContextMenu",this,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 && (from.isMathJax != to.isMathJax ||
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 && (from.isMathJax != to.isMathJax ||
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",
style:{display:"inline-block", "z-index": 1, width:0, height:0, position:"relative"}
},[["img",{
className: "MathJax_Hover_Arrow", isMathJax: true, math: math,
src: CONFIG.button.src, 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)"
}
}]]
);
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 () {
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.last = now;
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) {
if (TOUCH.timeout) {
clearTimeout(TOUCH.timeout);
delete TOUCH.timeout; TOUCH.last = 0;
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;
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.OutputJax,MathJax.InputJax);

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,316 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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",
"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_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") {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 Mw = Math.floor(.85*document.body.clientWidth),
Mh = Math.floor(.85*Math.max(document.body.clientHeight,document.documentElement.clientHeight));
var div = HTML.Element(
"span",{
style: {position:"relative", display:"inline-block", height:0, width:0},
id:"MathJax_ZoomFrame"
},[
["span",{id:"MathJax_ZoomOverlay", onmousedown:this.Remove}],
["span",{
id:"MathJax_Zoom", onclick:this.Remove,
style:{
visibility:"hidden", fontSize:this.settings.zscale,
"max-width":Mw+"px", "max-height":Mh+"px"
}
},[["span",{style:{display:"inline-block", "white-space":"nowrap"}}]]
]]
);
var zoom = div.lastChild, span = zoom.firstChild, overlay = div.firstChild;
math.parentNode.insertBefore(div,math);
if (span.addEventListener) {span.addEventListener("mousedown",this.Remove,true)}
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 < Mw && zoom.offsetHeight < Mh) {zoom.style.overflow = "visible"}
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) {
var XY = this.Resize(), x = XY.x, y = XY.y, W = bbox.mW;
var dx = -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 x = 0, y = 0, obj,
div = document.getElementById("MathJax_ZoomFrame"),
overlay = document.getElementById("MathJax_ZoomOverlay");
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 = ""}
overlay.style.left = (-x)+"px"; overlay.style.top = (-y)+"px";
if (ZOOM.msiePositionBug) {setTimeout(ZOOM.SetWH,0)} else {ZOOM.SetWH()}
return {x:x, y:y};
},
SetWH: function () {
var overlay = document.getElementById("MathJax_ZoomOverlay");
overlay.style.width = overlay.style.height = "1px"; // so scrollWidth/Height will be right below
var doc = document.documentElement || document.body;
overlay.style.width = doc.scrollWidth + "px";
overlay.style.height = Math.max(doc.clientHeight,doc.scrollHeight) + "px";
},
//
// Remove zoom display and event handlers
//
Remove: function (event) {
var div = document.getElementById("MathJax_ZoomFrame");
if (div) {
var JAX = MathJax.OutputJax[div.nextSibling.jaxID];
var jax = JAX.getJaxFromMath(div.nextSibling);
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);

View File

@ -0,0 +1,567 @@
/*************************************************************
*
* MathJax/extensions/TeX/AMSmath.js
*
* Implements AMS math environments and macros.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* 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.0",
number: 0, // current equation number
startNumber: 0, // current starting equation number (for when equation is restarted)
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) {return W.join("em ") + "em"};
/******************************************************************************/
TEXDEF.Add({
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'],
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],
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: ['Macro','\\mathop{\\rm inj\\,lim}'],
projlim: ['Macro','\\mathop{\\rm proj\\,lim}'],
varliminf: ['Macro','\\mathop{\\underline{\\rm lim}}'],
varlimsup: ['Macro','\\mathop{\\overline{\\rm lim}}'],
varinjlim: ['Macro','\\mathop{\\underrightarrow{\\rm lim\\Rule{-1pt}{0pt}{1pt}}\\Rule{0pt}{0pt}{.45em}}'],
varprojlim: ['Macro','\\mathop{\\underleftarrow{\\rm lim\\Rule{-1pt}{0pt}{1pt}}\\Rule{0pt}{0pt}{.45em}}'],
DeclareMathOperator: 'HandleDeclareOp',
operatorname: 'HandleOperatorName',
genfrac: 'Genfrac',
frac: ['Genfrac',"","","",""],
tfrac: ['Genfrac',"","","",1],
dfrac: ['Genfrac',"","","",0],
binom: ['Genfrac',"(",")","0em",""],
tbinom: ['Genfrac',"(",")","0em",1],
dbinom: ['Genfrac',"(",")","0em",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([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18])],
'align*': ['AMSarray',null,false,true, 'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18])],
multline: ['Multline',null,true],
'multline*': ['Multline',null,false],
split: ['AMSarray',null,false,false,'rl',COLS([5/18])],
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: ['AlignedArray',null,null,null,'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18]),".5em",'D'],
gathered: ['AlignedArray',null,null,null,'c',null,".5em",'D'],
subarray: ['Array',null,null,null,null,COLS([0,0,0,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]
},
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(name+" not allowed in "+global.notags+" environment")}
if (global.tag) {TEX.Error("Multiple "+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 (!AMS.refUpdate) {
if (global.label) {TEX.Error("Multiple "+name+"'s")}
global.label = label;
if (AMS.labels[label] || AMS.eqlabels[label]) {TEX.Error("Label '"+label+"' mutiply defined")}
AMS.eqlabels[label] = "???"; // 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 = "??"; AMS.badref = !AMS.refUpdate}
var tag = ref; if (eqref) {tag = CONFIG.formatTag(tag)}
if (CONFIG.useLabelIds) {ref = label}
this.Push(MML.mrow.apply(MML,this.InternalMath(tag)).With({
href:CONFIG.formatURL(CONFIG.formatID(ref)), "class":"MathJax_ref"
}));
},
/*
* Handle \DeclareMathOperator
*/
HandleDeclareOp: function (name) {
var limits = (this.GetStar() ? "\\limits" : "");
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() ? "\\limits" : "\\nolimits");
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;
},
/*
* Record presence of \shoveleft and \shoveright
*/
HandleShove: function (name,shove) {
var top = this.stack.Top();
if (top.type !== "multline" || top.data.length) {TEX.Error(name+" must come at the beginning of the line")}
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("Illegal alignment specified in "+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)} else {left = this.convertDelimiter(left)}
if (right == null) {right = this.GetDelimiterArg(name)} else {right = this.convertDelimiter(right)}
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 = MML.mfenced(frac).With({open: left, close: right})}
if (style !== "") {
var STYLE = (["D","T","S","SS"])[style];
if (STYLE == null) {TEX.Error("Bad math style for "+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
}
});
},
/*
* 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("Argument to \\begin{"+begin.name+"} must me a positive integer")}
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.Array.call(this,begin,null,null,align,spacing,".5em",'D');
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("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);
},
/*
* Get a delimiter or empty argument
*/
GetDelimiterArg: function (name) {
var c = this.trimSpaces(this.GetArgument(name));
if (c == "") {return null}
if (TEXDEF.delimiter[c] == null) {TEX.Error("Missing or unrecognized delimiter for "+name)}
return this.convertDelimiter(c);
},
/*
* 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) {
AMS.eqlabels[global.label] = global.tagID;
if (CONFIG.useLabelIds) {tag.id = CONFIG.formatID(global.label)}
}
delete global.tag; delete global.tagID; delete global.label;
return tag;
}
});
/*
* 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 () {
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("multline rows must have exactly one column")}
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
},
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;
}
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,
columnalign: mml.displayAlign
};
if (mml.displayAlign === MML.INDENTALIGN.LEFT) {
def.width = "100%";
if (mml.displayIndent && !String(mml.displayIndent).match(/^0+(\.0*)?($|[a-z%])/)) {
def.columnwidth = mml.displayIndent + " fit"; def.columnspacing = "0"
row = [row[0],MML.mtd(),row[1]];
}
} else if (mml.displayAlign === MML.INDENTALIGN.RIGHT) {
def.width = "100%";
if (mml.displayIndent && !String(mml.displayIndent).match(/^0+(\.0*)?($|[a-z%])/)) {
def.columnwidth = "fit "+mml.displayIndent; def.columnspacing = "0"
row[2] = MML.mtd();
}
}
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.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.labels,AMS.eqlabels); // save labels from this equation
if (AMS.badref && !data.math.texError) {AMS.refs.push(data.script)} // reprocess later
});
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 = {}}
}
/******************************************************************************/
MathJax.Hub.Startup.signal.Post("TeX AMSmath Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSmath.js");

View File

@ -0,0 +1,401 @@
/*************************************************************
*
* MathJax/extensions/TeX/AMSsymbols.js
*
* Implements macros for accessing the AMS symbol fonts.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* 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.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 MathJax_Main
backprime: ['2035',{variantForm: true}],
hslash: ['210F',{variantForm: true}],
varnothing: ['2205',{variantForm: true}],
blacktriangle: '25B2',
triangledown: '25BD',
blacktriangledown: '25BC',
square: '25A1',
Box: '25A1',
blacksquare: '25A0',
lozenge: '25CA',
Diamond: '25CA',
blacklozenge: '29EB',
circledS: ['24C8',{mathvariant: MML.VARIANT.NORMAL}],
bigstar: '2605',
// angle: '2220', // in MathJax_Main
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',{variantForm: true}],
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',
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',
shortmid: ['2223',{variantForm: true}],
smallfrown: '2322',
shortparallel: ['2225',{variantForm: true}],
bumpeq: '224F',
between: '226C',
Bumpeq: '224E',
pitchfork: '22D4',
varpropto: '221D',
backepsilon: '220D',
blacktriangleleft: '25C0',
blacktriangleright: '25B6',
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.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
var VARIANT = HTMLCSS.FONTDATA.VARIANT;
if (HTMLCSS.fontInUse === "TeX") {
VARIANT["-TeX-variant"] = {
fonts: ["MathJax_AMS","MathJax_Main","MathJax_Size1"],
remap: {0x2268: 0xE00C, 0x2269: 0xE00D, 0x2270: 0xE011, 0x2271: 0xE00E,
0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2224: 0xE006, 0x2226: 0xE007,
0x2288: 0xE016, 0x2289: 0xE018, 0x228A: 0xE01A, 0x228B: 0xE01B,
0x2ACB: 0xE017, 0x2ACC: 0xE019, 0x03DC: 0xE008, 0x03F0: 0xE009}
};
if (HTMLCSS.msieIE6) {
MathJax.Hub.Insert(VARIANT["-TeX-variant"].remap,{
0x2190:[0xE2C1,"-WinIE6"], 0x2192:[0xE2C0,"-WinIE6"],
0x2223:[0xE2C2,"-WinIE6"], 0x2225:[0xE2C3,"-WinIE6"],
0x223C:[0xE2C4,"-WinIE6"], 0x25B3:[0xE2D3,"-WinIE6"]
});
}
}
if (HTMLCSS.fontInUse === "STIX") {
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEXDEF = MathJax.InputJax.TeX.Definitions;
TEXDEF.mathchar0mi.varnothing = '2205';
TEXDEF.mathchar0mi.hslash = '210F';
TEXDEF.mathchar0mi.blacktriangle = '25B4';
TEXDEF.mathchar0mi.blacktriangledown = '25BE';
TEXDEF.mathchar0mi.square = '25FB';
TEXDEF.mathchar0mi.blacksquare = '25FC';
TEXDEF.mathchar0mi.vartriangle = ['25B3',{mathsize:"71%"}];
TEXDEF.mathchar0mi.triangledown = ['25BD',{mathsize:"71%"}];
TEXDEF.mathchar0mo.blacktriangleleft = '25C2';
TEXDEF.mathchar0mo.blacktriangleright = '25B8';
TEXDEF.mathchar0mo.smallsetminus = '2216';
MathJax.Hub.Insert(VARIANT["-STIX-variant"],{
remap: {0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2270: 0xE011, 0x2271: 0xE00E,
0x22E0: 0xE04B, 0x22E1: 0xE04F, 0x2288: 0xE016, 0x2289: 0xE018}
});
});
}
});
MathJax.Hub.Register.StartupHook("SVG Jax Ready",function () {
var SVG = MathJax.OutputJax.SVG;
var VARIANT = SVG.FONTDATA.VARIANT;
VARIANT["-TeX-variant"] = {
fonts: ["MathJax_AMS","MathJax_Main","MathJax_Size1"],
remap: {0x2268: 0xE00C, 0x2269: 0xE00D, 0x2270: 0xE011, 0x2271: 0xE00E,
0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2224: 0xE006, 0x2226: 0xE007,
0x2288: 0xE016, 0x2289: 0xE018, 0x228A: 0xE01A, 0x228B: 0xE01B,
0x2ACB: 0xE017, 0x2ACC: 0xE019, 0x03DC: 0xE008, 0x03F0: 0xE009}
};
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSsymbols.js");

View File

@ -0,0 +1,103 @@
/*************************************************************
*
* MathJax/extensions/TeX/HTML.js
*
* Implements the \href, \class, \style, \cssId macros.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2010-2012 Design Science, Inc.
*
* 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.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'
}
});
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");

View File

@ -0,0 +1,76 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.0"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml;
//
// Set up control sequenecs
//
TEX.Definitions.macros.toggle = 'Toggle';
TEX.Definitions.macros.mathtip = 'Mathtip';
TEX.Definitions.macros.texttip = ['Macro','\\mathtip{#1}{\\text{#2}}',2];
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");

View File

@ -0,0 +1,45 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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");

View File

@ -0,0 +1,71 @@
/*************************************************************
*
* 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) 2012 Design Science, Inc.
*
* 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.0"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MACROS = TEX.Definitions.macros,
ENVS = TEX.Definitions.environment;
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","colorbox","fcolorbox","DefineColor"],
enclose: ["enclose"],
extpfeil: ["Newextarrow","xlongequal","xmapsto","xtofrom",
"xtwoheadleftarrow","xtwoheadrightarrow"],
mhchem: ["ce","cee","cf"]
};
for (var name in EXTENSIONS) {if (EXTENSIONS.hasOwnProperty(name)) {
var macros = EXTENSIONS[name];
for (var i = 0, m = macros.length; i < m; i++) {
MACROS[macros[i]] = ["Extension",name];
}
}}
ENVS["subarray"] = ['ExtensionEnv',null,'AMSmath'];
ENVS["smallmatrix"] = ['ExtensionEnv',null,'AMSmath'];
ENVS["equation"] = ['ExtensionEnv',null,'AMSmath'];
ENVS["equation*"] = ['ExtensionEnv',null,'AMSmath'];
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"]
);

View File

@ -0,0 +1,90 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.0"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MML = MathJax.ElementJax.mml;
TEX.Definitions.macros.bbox = "BBox";
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 in parts) {
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) {
var pad = match[1]+match[3];
if (def) {TEX.Error("Padding specified twice in "+name)}
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("Background specified twice in "+name)}
background = part;
} else if (part.match(/^[-a-z]+:/i)) {
if (style) {TEX.Error("Style specified twice in "+name)}
style = part;
} else if (part !== "") {
TEX.Error("'"+part+"' doesn't look like a color, a padding dimension, or a style");
}
}
if (def) {math = MML.mpadded(math).With(def)}
if (background || style) {
math = MML.mstyle(math).With({mathbackground:background, style:style});
}
this.Push(math);
}
});
MathJax.Hub.Startup.signal.Post("TeX bbox Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/bbox.js");

View File

@ -0,0 +1,296 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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.environments))}
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.macros.begingroup = "BeginGroup";
TEXDEF.macros.endgroup = "EndGroup";
TEXDEF.macros.global = ["Extension","newcommand"];
TEXDEF.macros.gdef = ["Extension","newcommand"];
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("Extra "+name+" or missing \\begingroup");
} 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.macros.global = "Global";
TEXDEF.macros.gdef = ["Macro","\\global\\def"];
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(name+" not followed by \\let, \\def, or \\newcommand")}
this.stack.env.isGlobal = true;
}
});
});
MathJax.Hub.Startup.signal.Post("TeX begingroup Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/begingroup.js");

View File

@ -0,0 +1,126 @@
/*************************************************************
*
* MathJax/extensions/TeX/boldsymbol.js
*
* Implements the \boldsymbol{...} command to make bold
* versions of all math characters (not just variables).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* 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.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.macros.boldsymbol = 'Boldsymbol';
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.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
var FONTS = HTMLCSS.FONTDATA.FONTS;
var VARIANT = HTMLCSS.FONTDATA.VARIANT;
if (HTMLCSS.fontInUse === "TeX") {
FONTS["MathJax_Caligraphic-bold"] = "Caligraphic/Bold/Main.js";
VARIANT["-tex-caligraphic-bold"] =
{fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"],
offsetA: 0x41, variantA: "bold-italic"};
VARIANT["-tex-oldstyle-bold"] =
{fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"]};
if (HTMLCSS.msieCheckGreek && HTMLCSS.Font.testFont({
family:"MathJax_Greek", weight:"bold", style:"italic", testString: HTMLCSS.msieCheckGreek
})) {
VARIANT["bold-italic"].offsetG = 0x391; VARIANT["bold-italic"].variantG = "-Greek-Bold-Italic";
VARIANT["-Greek-Bold-Italic"] = {fonts:["MathJax_Greek-bold-italic"]};
FONTS["MathJax_Greek-bold-italic"] = "Greek/BoldItalic/Main.js";
}
if (MathJax.Hub.Browser.isChrome && !MathJax.Hub.Browser.versionAtLeast("5.0")) {
VARIANT["-tex-caligraphic-bold"].remap = {0x54: [0xE2F0,"-WinChrome"]};
}
} else if (HTMLCSS.fontInUse === "STIX") {
VARIANT["-tex-caligraphic-bold"] = {
fonts:["STIXGeneral-bold-italic","STIXNonUnicode-bold-italic","STIXNonUnicode","STIXGeneral","STIXSizeOneSym"],
offsetA: 0xE247, noLowerCase: 1
};
VARIANT["-tex-oldstyle-bold"] = {
fonts:["STIXGeneral-bold","STIXNonUnicode-bold","STIXGeneral","STIXSizeOneSym"], offsetN: 0xE263,
remap: {0xE264: 0xE267, 0xE265: 0xE26B, 0xE266: 0xE26F, 0xE267: 0xE273,
0xE268: 0xE277, 0xE269: 0xE27B, 0xE26A: 0xE27F, 0xE26B: 0xE283,
0xE26C: 0xE287}
};
}
});
MathJax.Hub.Register.StartupHook("SVG Jax Ready",function () {
var SVG = MathJax.OutputJax.SVG;
var FONTS = SVG.FONTDATA.FONTS;
var VARIANT = SVG.FONTDATA.VARIANT;
FONTS["MathJax_Caligraphic-bold"] = "Caligraphic/Bold/Main.js";
VARIANT["-tex-caligraphic-bold"] =
{fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"],
offsetA: 0x41, variantA: "bold-italic"};
VARIANT["-tex-oldstyle-bold"] =
{fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"]};
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/boldsymbol.js");

View File

@ -0,0 +1,105 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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,
MACROS = TEX.Definitions.macros,
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 macro
//
MACROS.cancel = ['Cancel',MML.NOTATION.UPDIAGONALSTRIKE];
MACROS.bcancel = ['Cancel',MML.NOTATION.DOWNDIAGONALSTRIKE];
MACROS.xcancel = ['Cancel',MML.NOTATION.UPDIAGONALSTRIKE+" "+MML.NOTATION.DOWNDIAGONALSTRIKE];
MACROS.cancelto = 'CancelTo';
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, arrow:true},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");

View File

@ -0,0 +1,229 @@
/*************************************************************
*
* MathJax/extensions/TeX/color.js
*
* Implements LaTeX-compatible \color macro rather than MathJax's
* original (non-standard) version. It includes the rgb, gray, and
* named color models, and the \definecolor macro.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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.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("Color model '"+model+"' not defined")}
return fn.call(this,def);
},
/*
* Get an RGB color
*/
get_rgb: function (rgb) {
rgb = rgb.split(/,/); var RGB = "#";
if (rgb.length !== 3) {this.TEX.Error("RGB colors require 3 decimal numbers")}
for (var i = 0; i < 3; i++) {
if (!rgb[i].match(/^(\d+(\.\d*)?|\.\d+)$/)) {this.TEX.Error("Invalid decimal number")}
var n = parseFloat(rgb[i]);
if (n < 0 || n > 1) {this.TEX.Error("RGB values must be between 0 and 1")}
n = Math.floor(n*255).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(/^(\d+(\.\d*)?|\.\d+)$/)) {this.TEX.Error("Invalid decimal number")}
var n = parseFloat(gray);
if (n < 0 || n > 1) {this.TEX.Error("Grey-scale values must be between 0 and 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.macros.color = "Color";
TEX.Definitions.macros.definecolor = "DefineColor";
TEX.Definitions.macros.colorbox = "ColorBox";
TEX.Definitions.macros.fcolorbox = "fColorBox";
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);
},
//
// 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");

View File

@ -0,0 +1,86 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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.macros.enclose = 'Enclose';
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}
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");

View File

@ -0,0 +1,87 @@
/*************************************************************
*
* MathJax/extensions/TeX/extpfeil.js
*
* Implements additional stretchy arrow macros.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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.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)
//
MathJax.Hub.Insert(TEXDEF,{
macros: {
xtwoheadrightarrow: ['Extension','AMSmath'],
xtwoheadleftarrow: ['Extension','AMSmath'],
xmapsto: ['Extension','AMSmath'],
xlongequal: ['Extension','AMSmath'],
xtofrom: ['Extension','AMSmath'],
Newextarrow: ['Extension','AMSmath']
}
});
//
// 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("First argument to "+name+" must be a control sequence name")}
if (!space.match(/^(\d+),(\d+)$/))
{TEX.Error("Second argument to "+name+" must be two integers separated by a comma")}
if (!chr.match(/^(\d+|0x[0-9A-F]+)$/i))
{TEX.Error("Third argument to "+name+" must be a unicode character number")}
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");

View File

@ -0,0 +1,78 @@
/*************************************************************
*
* MathJax/extensions/TeX/mathchoice.js
*
* Implements the \mathchoice macro (rarely used)
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* 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.0";
var MML = MathJax.ElementJax.mml;
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEXDEF.macros.mathchoice = 'MathChoice';
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",
choice: function () {
var values = this.getValues("displaystyle","scriptlevel");
if (values.scriptlevel > 0) {return Math.min(3,values.scriptlevel + 1)}
return (values.displaystyle ? 0 : 1);
},
setTeXclass: function (prev) {return this.Core().setTeXclass(prev)},
isSpacelike: function () {return this.Core().isSpacelike()},
isEmbellished: function () {return this.Core().isEmbellished()},
Core: function () {return this.data[this.choice()]},
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 () {return this.Core().toSVG()}
});
MathJax.Hub.Startup.signal.Post("TeX mathchoice Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mathchoice.js");

View File

@ -0,0 +1,413 @@
/*************************************************************
*
* MathJax/extensions/TeX/mhchem.js
*
* Implements the \ce command for handling chemical formulas
* from the mhchem LaTeX package.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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.0"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var TEX = MathJax.InputJax.TeX,
MACROS = TEX.Definitions.macros;
/*
* 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 processed TeX result
atom: false, // last processed token is an atom
sup: "", // pending superscript
sub: "", // pending 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",
'^': "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();
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 of 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()}
} 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();
} 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 () {
if (this.sup || this.sub) {
if (this.sup && this.sub && !this.atom) {
//
// right-justify super- and subscripts when they are before the atom
//
var n = Math.abs(this.sup.length-this.sub.length);
if (n) {
var zeros = "0000000000".substr(0,n);
var script = (this.sup.length > this.sub.length ? "sub" : "sup");
this[script] = "\\phantom{"+zeros+"}" + this[script];
}
}
if (!this.sup) {this.sup = "\\Space{0pt}{0pt}{.2em}"} // forces subscripts to align properly
this.tex += "^{"+this.sup+"}_{"+this.sub+"}";
this.sup = this.sub = "";
}
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("Extra close brace or missing open brace")}
}
}
if (braces) {TEX.Error("Missing close brace")};
TEX.Error("Can't find closing "+c);
}
});
/***************************************************************************/
//
// Set up the macros for chemistry
//
MACROS.ce = 'CE';
MACROS.cf = 'CE';
MACROS.cee = 'CE';
//
// Include some missing arrows (some are hacks)
//
MACROS.xleftrightarrow = ['xArrow',0x2194,6,6];
MACROS.xrightleftharpoons = ['xArrow',0x21CC,5,7]; // FIXME: doesn't stretch in HTML-CSS output
MACROS.xRightleftharpoons = ['xArrow',0x21CC,5,7]; // FIXME: how should this be handled?
// FIXME: These don't work well in FF NativeMML mode
MACROS.longrightleftharpoons = ["Macro","\\stackrel{\\textstyle{{-}\\!\\!{\\rightharpoonup}}}{\\smash{{\\leftharpoondown}\\!\\!{-}}}"];
MACROS.longRightleftharpoons = ["Macro","\\stackrel{\\textstyle{-}\\!\\!{\\rightharpoonup}}{\\small\\smash\\leftharpoondown}"];
//
// Needed for \bond for the ~ forms
//
MACROS.tripledash = ["Macro","\\raise3mu{\\tiny\\text{-}\\kern2mu\\text{-}\\kern2mu\\text{-}}"];
TEX.Definitions.environment.CEstack = ['Array',null,null,null,'r',null,"0.001em",'T',1]
//
// Add \hyphen used in some mhchem examples
//
MACROS.hyphen = ["Macro","\\text{-}"];
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;
}
});
//
// Indicate that the extension is ready
//
MathJax.Hub.Startup.signal.Post("TeX mhchem Ready");
});
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mhchem.js");

View File

@ -0,0 +1,237 @@
/*************************************************************
*
* MathJax/extensions/TeX/newcommand.js
*
* Implements the \newcommand, \newenvironment and \def
* macros, and is loaded automatically when needed.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* 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.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]{...}
*/
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("Illegal control sequence name for "+name)}
if (n) {
n = this.trimSpaces(n);
if (!n.match(/^[0-9]+$/)) {TEX.Error("Illegal number of parameters specified in "+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),
bdef = this.GetArgument(name),
edef = this.GetArgument(name);
if (n) {
n = this.trimSpaces(n);
if (!n.match(/^[0-9]+$/)) {TEX.Error("Illegal number of parameters specified in "+name)}
}
this.setEnv(env,['BeginEnv','EndEnv',bdef,edef,n]);
},
/*
* 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("\\ must be followed by a control sequence")}
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("Illegal use of # in template for "+cs)}
if (parseInt(c) != ++n) {TEX.Error("Parameters for "+cs+" must be numbered sequentially")}
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("Missing replacement string for definition of "+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("Use of "+name+" doesn't match its definition")}
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("MathJax maximum macro substitution count exceeded; is there a recursive macro call?")}
},
/*
* Process a user-defined environment
*/
BeginEnv: function (begin,bdef,edef,n) {
if (n) {
var args = [];
for (var i = 0; i < n; i++) {args.push(this.GetArgument("\\begin{"+name+"}"))}
bdef = this.SubstituteArgs(args,bdef);
edef = this.SubstituteArgs(args,edef);
}
begin.edef = edef;
this.string = this.AddArgs(bdef,this.string.slice(this.i)); this.i = 0;
return begin;
},
EndEnv: function (begin,row) {
this.string = this.AddArgs(begin.edef,this.string.slice(this.i)); this.i = 0
return row;
},
/*
* 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("Runaway argument for "+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");

View File

@ -0,0 +1,306 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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.call(this,span,node);
}
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.call(this,span)}
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.call(this,span,node)}
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.call(this,span)}
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.call(this,span)}
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.call(this,span)}
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;
}
});
});
/*******************************************************************/
HUB.Startup.signal.Post("TeX noErrors Ready");
})(MathJax.Hub,MathJax.HTML);
MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/noErrors.js");

View File

@ -0,0 +1,69 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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");

View File

@ -0,0 +1,164 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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.macros.unicode = 'Unicode';
//
// 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.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.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");

View File

@ -0,0 +1,58 @@
/*************************************************************
*
* MathJax/extensions/TeX/verb.js
*
* Implements the \verb|...| command for including text verbatim
* (with no processing of macros or special characters).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* 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.0"
};
MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
var MML = MathJax.ElementJax.mml;
var TEX = MathJax.InputJax.TeX;
var TEXDEF = TEX.Definitions;
TEXDEF.macros.verb = 'Verb';
TEX.Parse.Augment({
/*
* Implement \verb|...|
*/
Verb: function (name) {
var c = this.GetNext(); var start = ++this.i;
if (c == "" ) {TEX.Error(name+" requires an argument")}
while (this.i < this.string.length && this.string.charAt(this.i) != c) {this.i++}
if (this.i == this.string.length)
{TEX.Error("Can't find closing delimiter for "+name)}
var text = this.string.slice(start,this.i); 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");

View File

@ -0,0 +1,228 @@
/*************************************************************
*
* 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 Design Science, Inc.
*
* 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.0",
config: {
delimiters: [['`','`']], // The star/stop delimiter pairs for asciimath code
skipTags: ["script","noscript","style","textarea","pre","code"],
// 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");
this.ignoreClass = new RegExp("(^| )("+config.ignoreClass+")( |$)");
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;
if (this.config.preview === "AsciiMath") {preview = [this.filterPreview(asciimath)]}
else if (this.config.preview instanceof Array) {preview = this.config.preview}
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)
};
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.asciimath2jax]);
MathJax.Ajax.loadComplete("[MathJax]/extensions/asciimath2jax.js");

View File

@ -0,0 +1,95 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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;
if (this.config.preview === "TeX") {preview = [this.filterPreview(node.innerHTML)]}
else if (this.config.preview instanceof Array) {preview = this.config.preview}
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}
};
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.jsMath2jax]);
MathJax.Ajax.loadComplete("[MathJax]/extensions/jsMath2jax.js");

View File

@ -0,0 +1,205 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.0",
config: {
preview: "alttext" // Use the <math> element's alttext as the
// preview. Set to "none" for no preview,
// 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}
//
// Handle all math tags with no namespaces
//
this.ProcessMathArray(element.getElementsByTagName("math"));
//
// Handle math with namespaces in XHTML
//
if (element.getElementsByTagNameNS)
{this.ProcessMathArray(element.getElementsByTagNameNS(this.MMLnamespace,"math"))}
//
// Handle math with namespaces in HTML
//
var i, m;
if (document.namespaces) {
//
// IE namespaces are listed in document.namespaces
//
for (i = 0, m = document.namespaces.length; i < m; i++) {
var ns = document.namespaces[i];
if (ns.urn === this.MMLnamespace)
{this.ProcessMathArray(element.getElementsByTagName(ns.name+":math"))}
}
} 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.ProcessMathArray(element.getElementsByTagName(attr.nodeName.substr(6)+":math"))}
}
}
}
},
ProcessMathArray: function (math) {
var i;
if (math.length) {
if (this.MathTagBug) {
for (i = math.length-1; i >= 0; i--) {
if (math[i].nodeName === "MATH") {this.ProcessMathFlattened(math[i])}
else {this.ProcessMath(math[i])}
}
} else {
for (i = math.length-1; i >= 0; i--) {this.ProcessMath(math[i])}
}
}
},
ProcessMath: function (math) {
var parent = math.parentNode;
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;
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) {
// 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;
if (this.config.preview === "alttext") {
var text = math.getAttribute("alttext");
if (text != null) {preview = [this.filterPreview(text)]}
} else if (this.config.preview instanceof Array) {preview = this.config.preview}
if (preview) {
preview = MathJax.HTML.Element("span",{className:MathJax.Hub.config.preRemoveClass},preview);
script.parentNode.insertBefore(preview,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
}
};
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.mml2jax]);
MathJax.Ajax.loadComplete("[MathJax]/extensions/mml2jax.js");

View File

@ -0,0 +1,298 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.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"],
// 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");
this.ignoreClass = new RegExp("(^| )("+config.ignoreClass+")( |$)");
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;
if (this.config.preview === "TeX") {preview = [this.filterPreview(tex)]}
else if (this.config.preview instanceof Array) {preview = this.config.preview}
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)
};
MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.tex2jax]);
MathJax.Ajax.loadComplete("[MathJax]/extensions/tex2jax.js");

View File

@ -0,0 +1,178 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.0";
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 = []; var 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) {data.push(SPACE+"<mrow />")}
}
if (this.isToken) {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 attr = [], defaults = this.defaults;
var copy = (this.attrNames||MML.copyAttributeNames), skip = MML.skipAttributes;
if (this.type === "math") {attr.push('xmlns="http://www.w3.org/1998/Math/MathML"')}
if (!this.attrNames) {
if (this.type === "mstyle") {defaults = MML.math.prototype.defaults}
for (var id in defaults) {if (!skip[id] && defaults.hasOwnProperty(id)) {
var force = (id === "open" || id === "close");
if (this[id] != null && (force || this[id] !== defaults[id])) {
var value = this[id]; delete this[id];
if (force || this.Get(id) !== value)
{attr.push(id+'="'+this.toMathMLattribute(value)+'"')}
this[id] = value;
}
}}
}
for (var i = 0, m = copy.length; i < m; i++) {
if (copy[i] === "class") continue; // this is handled separately below
value = (this.attr||{})[copy[i]]; if (value == null) {value = this[copy[i]]}
if (value != null) {attr.push(copy[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 (this.mathvariant && this.toMathMLvariants[this.mathvariant])
{CLASS.push("MJX"+this.mathvariant)}
if (this.arrow) {CLASS.push("MJX-arrow")}
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 ((1/18)*RegExp.$1).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 < 0x20 || n > 0x7E) {
string[i] = "&#x"+n.toString(16).toUpperCase()+";";
} else {
var c = {'&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;'}[string[i]];
if (c) {string[i] = c}
}
}
return string.join("");
}
});
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;
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");

View File

@ -0,0 +1,92 @@
/*************************************************************
*
* MathJax/extensions/v1.0-warning.js
*
* This extension file is loaded when no jax are configured
* as a backward-compatible measure to help people convert to the
* new configuration process.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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.0";
var CONFIG = {
style: {
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
}
};
if (HUB.Browser.isIE9 && document.documentMode >= 9) {delete CONFIG.style.filter}
var DIV;
HUB.Register.StartupHook("onLoad",function () {
var frame = document.body;
if (HUB.Browser.isMSIE) {
MathJax.Message.Init(); // make sure MathJax_MSIE_frame exists
frame = document.getElementById("MathJax_MSIE_frame") || frame; // in IE8 and 9 it may not anyway
CONFIG.style.position = "absolute";
} else {delete CONFIG.style.filter}
CONFIG.style.maxWidth = (document.body.clientWidth-75) + "px";
DIV = HTML.addElement(frame,"div",{id:"MathJax_ConfigWarning",style:CONFIG.style},[
[
"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 () {DIV.style.display = "none"}
},
[["span",{style:{position:"relative", bottom:".2em"}},["x"]]]
],
"MathJax no longer loads a default configuration file; " +
"you must specify such files explicitly. " +
"This page seems to use the older default ",["code",{},["config/MathJax.js"]],
" file, and so needs to be updated. This is explained further at",
["p",{style:{"text-align":"center"}},[
["a",
{href:"http://www.mathjax.org/help/configuration"},
["http://www.mathjax.org/help/configuration"]
]
]]
]);
});
})(MathJax.Hub,MathJax.HTML);
MathJax.Ajax.loadComplete("[MathJax]/extensions/v1.0-warning.js");

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,122 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Arrows.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,65 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/CombDiactForSymbols.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,38 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Dingbats.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,66 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,35 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,37 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/Latin1Supplement.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,228 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MathOperators.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,42 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,168 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsB.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,36 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscSymbolsAndArrows.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,40 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,38 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,289 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SuppMathOperators.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,40 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsA.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,162 @@
/*************************************************************
*
* MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js
*
* Copyright (c) 2010 Design Science, Inc.
*
* 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);

View File

@ -0,0 +1,41 @@
/*************************************************************
*
* 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 Design Science, Inc.
*
* 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.0",
directory: MathJax.InputJax.directory + "/AsciiMath",
extensionDir: MathJax.InputJax.extensionDir + "/AsciiMath",
config: {
displaystyle: true, // put limits above and below operators
decimal: "." // can change to "," but watch out for "(1,2)"
}
});
MathJax.InputJax.AsciiMath.Register("math/asciimath");
MathJax.InputJax.AsciiMath.loadComplete("config.js");

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,38 @@
/*************************************************************
*
* 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-2012 Design Science, Inc.
*
* 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.0",
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");

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -0,0 +1,49 @@
/*************************************************************
*
* MathJax/jax/input/TeX/config.js
*
* Initializes the TeX InputJax (the main definition is in
* MathJax/jax/input/TeX/jax.js, which is loaded when needed).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-2012 Design Science, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.InputJax.TeX = MathJax.InputJax({
id: "TeX",
version: "2.0",
directory: MathJax.InputJax.directory + "/TeX",
extensionDir: MathJax.InputJax.extensionDir + "/TeX",
config: {
TagSide: "right",
TagIndent: "0.8em",
MultLineWidth: "85%",
equationNumbers: {
autoNumber: "none", // "AMS" for standard AMS numbering,
// or "all" for all displayed equations
formatNumber: function (n) {return n},
formatTag: function (n) {return '('+n+')'},
formatID: function (n) {return 'mjx-eqn-'+String(n).replace(/[:"'<>&]/g,"")},
formatURL: function (id) {return '#'+escape(id)},
useLabelIds: true
}
}
});
MathJax.InputJax.TeX.Register("math/tex");
MathJax.InputJax.TeX.loadComplete("config.js");

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,89 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/annotation-xml.js
*
* Implements the SVG output for <annotation-xml> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG;
var BBOX = SVG.BBOX;
BBOX.FOREIGN = BBOX.Subclass({type: "foreignObject", removeable: false});
MML["annotation-xml"].Augment({
toSVG: function () {
var svg = this.SVG(); this.SVGhandleSpace(svg);
var encoding = this.Get("encoding");
for (var i = 0, m = this.data.length; i < m; i++)
{svg.Add(this.data[i].toSVG(encoding),svg.w,0)}
svg.Clean();
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
}
});
MML.xml.Augment({
toSVG: function (encoding) {
//
// Get size of xml content
//
var span = SVG.textSVG.parentNode;
SVG.mathDiv.style.width = "auto"; // Firefox returns offsetWidth = 0 without this
span.insertBefore(this.div,SVG.textSVG);
var w = this.div.offsetWidth, h = this.div.offsetHeight;
var strut = MathJax.HTML.addElement(this.div,"span",{
style:{display:"inline-block", overflow:"hidden", height:h+"px",
width:"1px", marginRight:"-1px"}
});
var d = this.div.offsetHeight - h; h -= d;
this.div.removeChild(strut);
span.removeChild(this.div); SVG.mathDiv.style.width = "";
//
// Create foreignObject element for the content
//
var scale = 1000/SVG.em;
var svg = BBOX.FOREIGN({
y:(-h)+"px", width:w+"px", height:(h+d)+"px",
transform:"scale("+scale+") matrix(1 0 0 -1 0 0)"
});
//
// Add the children to the foreignObject
//
for (var i = 0, m = this.data.length; i < m; i++)
{svg.element.appendChild(this.data[i].cloneNode(true))}
//
// Set the scale and finish up
//
svg.w = w*scale; svg.h = h*scale; svg.d = d*scale;
svg.r = svg.w; svg.l = 0;
svg.Clean();
this.SVGsaveData(svg);
return svg;
}
});
MathJax.Hub.Startup.signal.Post("SVG annotation-xml Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/annotation-xml.js");
});

View File

@ -0,0 +1,193 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/maction.js
*
* Implements the SVG output for <maction> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax["SVG"];
var currentTip, hover, clear;
//
// Add configuration for tooltips
//
var CONFIG = SVG.config.tooltip = MathJax.Hub.Insert({
delayPost: 600, delayClear: 600,
offsetX: 10, offsetY: 5
},SVG.config.tooltip||{});
MML.maction.Augment({
SVGtooltip: MathJax.HTML.addElement(document.body,"div",{id:"MathJax_SVG_Tooltip"}),
toSVG: function (HW,D) {
this.SVGgetStyles();
var svg = this.SVG();
var selected = this.selected();
if (selected) {
svg.Add(this.SVGdataStretched(this.Get("selection")-1,HW,D));
this.SVGhandleHitBox(svg);
}
this.SVGhandleSpace(svg);
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
},
SVGhandleHitBox: function (svg) {
var frame = SVG.addElement(svg.element,"rect",
{width:svg.w, height:svg.h+svg.d, y:-svg.d, fill:"none", "pointer-events":"all"});
var type = this.Get("actiontype");
if (this.SVGaction[type]) {this.SVGaction[type].call(this,svg,frame,this.Get("selection"))}
},
SVGstretchH: MML.mbase.prototype.SVGstretchH,
SVGstretchV: MML.mbase.prototype.SVGstretchV,
//
// Implementations for the various actions
//
SVGaction: {
toggle: function (svg,frame,selection) {
this.selection = selection;
SVG.Element(frame,{cursor:"pointer"});
frame.onclick = MathJax.Callback(["SVGclick",this]);
},
statusline: function (svg,frame,selection) {
frame.onmouseover = MathJax.Callback(["SVGsetStatus",this]),
frame.onmouseout = MathJax.Callback(["SVGclearStatus",this]);
frame.onmouseover.autoReset = frame.onmouseout.autoReset = true;
},
tooltip: function(svg,frame,selection) {
frame.onmouseover = MathJax.Callback(["SVGtooltipOver",this]),
frame.onmouseout = MathJax.Callback(["SVGtooltipOut",this]);
frame.onmouseover.autoReset = frame.onmouseout.autoReset = true;
}
},
//
// Handle a click on the maction element
// (remove the original rendering and rerender)
//
SVGclick: function (event) {
this.selection++;
if (this.selection > this.data.length) {this.selection = 1}
var math = this; while (math.type !== "math") {math = math.inherit}
var jax = MathJax.Hub.getJaxFor(math.inputID); //, hover = !!jax.hover;
jax.Update();
/*
* if (hover) {
* var span = document.getElementById(jax.inputID+"-Span");
* MathJax.Extension.MathEvents.Hover.Hover(jax,span);
* }
*/
return MathJax.Extension.MathEvents.Event.False(event);
},
//
// Set/Clear the window status message
//
SVGsetStatus: function (event) {
// FIXME: Do something better with non-token elements
window.status =
((this.data[1] && this.data[1].isToken) ?
this.data[1].data.join("") : this.data[1].toString());
},
SVGclearStatus: function (event) {window.status = ""},
//
// Handle tooltips
//
SVGtooltipOver: function (event) {
if (!event) {event = window.event}
if (clear) {clearTimeout(clear); clear = null}
if (hover) {clearTimeout(hover)}
var x = event.pageX; var y = event.pageY;
if (x == null) {
x = event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
y = event.clientY + document.body.scrollTop + document.documentElement.scrollTop;
}
var callback = MathJax.Callback(["SVGtooltipPost",this,x+CONFIG.offsetX,y+CONFIG.offsetY])
hover = setTimeout(callback,CONFIG.delayPost);
},
SVGtooltipOut: function (event) {
if (hover) {clearTimeout(hover); hover = null}
if (clear) {clearTimeout(clear)}
var callback = MathJax.Callback(["SVGtooltipClear",this,80]);
clear = setTimeout(callback,CONFIG.delayClear);
},
SVGtooltipPost: function (x,y) {
hover = null; if (clear) {clearTimeout(clear); clear = null}
//
// Get the tip div and show it at the right location, then clear its contents
//
var tip = this.SVGtooltip;
tip.style.display = "block"; tip.style.opacity = "";
if (this === currentTip) return;
tip.style.left = x+"px"; tip.style.top = y+"px";
tip.innerHTML = ''; var span = MathJax.HTML.addElement(tip,"span");
//
// Get the sizes from the jax (FIXME: should calculate again?)
//
var math = this; while (math.type !== "math") {math = math.inherit}
var jax = MathJax.Hub.getJaxFor(math.inputID);
this.em = MML.mbase.prototype.em = jax.SVG.em; this.ex = jax.SVG.ex;
this.linebreakWidth = jax.SVG.lineWidth * 1000; this.cwidth = jax.SVG.cwidth;
//
// Make a new math element and temporarily move the tooltip to it
// Display the math containing the tip, but check for errors
// Then put the tip back into the maction element
//
var mml = this.data[1];
math = MML.math(mml);
try {math.toSVG(span,tip)} catch(err) {
this.SetData(1,mml); tip.style.display = "none";
if (!err.restart) {throw err}
MathJax.Callback.After(["SVGtooltipPost",this,x,y],err.restart);
return;
}
this.SetData(1,mml);
currentTip = this;
},
SVGtooltipClear: function (n) {
var tip = this.SVGtooltip;
if (n <= 0) {
tip.style.display = "none";
tip.style.opacity = "";
clear = null;
} else {
tip.style.opacity = n/100;
clear = setTimeout(MathJax.Callback(["SVGtooltipClear",this,n-20]),50);
}
}
});
MathJax.Hub.Startup.signal.Post("SVG maction Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/maction.js");
});

View File

@ -0,0 +1,220 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/menclose.js
*
* Implements the SVG output for <menclose> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG,
BBOX = SVG.BBOX;
BBOX.ELLIPSE = BBOX.Subclass({
type: "ellipse", removeable: false,
Init: function (h,d,w,t,color,def) {
if (def == null) {def = {}}; def.fill = "none";
if (color) {def.stroke = color}
def["stroke-width"] = t.toFixed(2).replace(/\.?0+$/,"");
def.cx = Math.floor(w/2); def.cy = Math.floor((h+d)/2-d);
def.rx = Math.floor((w-t)/2); def.ry = Math.floor((h+d-t)/2);
this.SUPER(arguments).Init.call(this,def);
this.w = this.r = w; this.h = this.H = h;
this.d = this.D = d; this.l = 0;
}
});
BBOX.DLINE = BBOX.Subclass({
type: "line", removeable: false,
Init: function (h,d,w,t,color,updown,def) {
if (def == null) {def = {}}; def.fill = "none";
if (color) {def.stroke = color}
def["stroke-width"] = t.toFixed(2).replace(/\.?0+$/,"");
if (updown == "up") {
def.x1 = Math.floor(t/2); def.y1 = Math.floor(t/2-d);
def.x2 = Math.floor(w-t/2); def.y2 = Math.floor(h-t/2);
} else {
def.x1 = Math.floor(t/2); def.y1 = Math.floor(h-t/2);
def.x2 = Math.floor(w-t/2); def.y2 = Math.floor(t/2-d);
}
this.SUPER(arguments).Init.call(this,def);
this.w = this.r = w; this.h = this.H = h;
this.d = this.D = d; this.l = 0;
}
});
BBOX.FPOLY = BBOX.Subclass({
type: "polygon", removeable: false,
Init: function (points,color,def) {
if (def == null) {def = {}}
if (color) {def.fill = color}
var P = [], mx = 100000000, my = mx, Mx = -mx, My = Mx;
for (var i = 0, m = points.length; i < m; i++) {
var x = points[i][0], y = points[i][1];
if (x > Mx) {Mx = x}; if (x < mx) {mx = x}
if (y > My) {My = y}; if (y < my) {my = y}
P.push(Math.floor(x)+","+Math.floor(y));
}
def.points = P.join(" ");
this.SUPER(arguments).Init.call(this,def);
this.w = this.r = Mx; this.h = this.H = My;
this.d = this.D = -my; this.l = -mx;
}
});
BBOX.PPATH = BBOX.Subclass({
type: "path", removeable: false,
Init: function (h,d,w,p,t,color,def) {
if (def == null) {def = {}}; def.fill = "none";
if (color) {def.stroke = color}
def["stroke-width"] = t.toFixed(2).replace(/\.?0+$/,"");
def.d = p;
this.SUPER(arguments).Init.call(this,def);
this.w = this.r = w; this.h = this.H = h+d;
this.d = this.D = this.l = 0; this.y = -d;
}
});
MML.menclose.Augment({
toSVG: function (HW,DD) {
this.SVGgetStyles();
var svg = this.SVG();
this.SVGhandleSpace(svg);
var base = this.SVGdataStretched(0,HW,DD);
var values = this.getValues("notation","thickness","padding","mathcolor","color");
if (values.color && !this.mathcolor) {values.mathcolor = values.color}
if (values.thickness == null) {values.thickness = ".075em"}
if (values.padding == null) {values.padding = ".2em"}
var mu = this.SVGgetMu(svg), scale = this.SVGgetScale();
var p = SVG.length2em(values.padding,mu,1/SVG.em) * scale;
var t = SVG.length2em(values.thickness,mu,1/SVG.em) * scale;
var H = base.h+p+t, D = base.d+p+t, W = base.w+2*(p+t);
var notation = values.notation.split(/ /);
var dx = 0, w, h, i, m, borders = [false,false,false,false];
if (!values.mathcolor) {values.mathcolor = "black"}
for (i = 0, m = notation.length; i < m; i++) {
switch (notation[i]) {
case MML.NOTATION.BOX:
borders = [true,true,true,true];
break;
case MML.NOTATION.ROUNDEDBOX:
svg.Add(BBOX.FRAME(H,D,W,t,"solid",values.mathcolor,
{rx:Math.floor(Math.min(H+D-t,W-t)/4)}));
break;
case MML.NOTATION.CIRCLE:
svg.Add(BBOX.ELLIPSE(H,D,W,t,values.mathcolor));
break;
case MML.NOTATION.ACTUARIAL:
borders[0] = true;
case MML.NOTATION.RIGHT:
borders[1] = true;
break;
case MML.NOTATION.LEFT:
borders[3] = true;
break;
case MML.NOTATION.TOP:
borders[0] = true;
break;
case MML.NOTATION.BOTTOM:
borders[2] = true;
break;
case MML.NOTATION.VERTICALSTRIKE:
svg.Add(BBOX.VLINE(H+D,t,"solid",values.mathcolor),(W-t)/2,-D);
break;
case MML.NOTATION.HORIZONTALSTRIKE:
svg.Add(BBOX.HLINE(W,t,"solid",values.mathcolor),0,(H+D-t)/2-D);
break;
case MML.NOTATION.UPDIAGONALSTRIKE:
if (this.arrow) {
var l = Math.sqrt(W*W + (H+D)*(H+D)), f = 1/l * 10/SVG.em * t/.075;
w = W * f; h = (H+D) * f; var x = .4*h;
svg.Add(BBOX.DLINE(H-.5*h,D,W-.5*w,t,values.mathcolor,"up"));
svg.Add(BBOX.FPOLY(
[[x+w,h], [x-.4*h,.4*w], [x+.3*w,.3*h], [x+.4*h,-.4*w], [x+w,h]],
values.mathcolor),W-w-x,H-h);
} else {
svg.Add(BBOX.DLINE(H,D,W,t,values.mathcolor,"up"));
}
break;
case MML.NOTATION.DOWNDIAGONALSTRIKE:
svg.Add(BBOX.DLINE(H,D,W,t,values.mathcolor,"down"));
break;
case MML.NOTATION.MADRUWB:
borders[1] = borders[2] = true;
break;
case MML.NOTATION.RADICAL:
svg.Add(BBOX.PPATH(H,D,W,
"M "+this.SVGxy(t/2,.4*(H+D)) +
" L "+this.SVGxy(p,t/2) +
" L "+this.SVGxy(2*p,H+D-t/2) +
" L "+this.SVGxy(W,H+D-t/2),
t,values.mathcolor),0,t);
dx = p;
break;
case MML.NOTATION.LONGDIV:
svg.Add(BBOX.PPATH(H,D,W,
"M "+this.SVGxy(t/2,t/2) +
" a "+this.SVGxy(p,(H+D)/2-2*t) + " 0 0,1 " + this.SVGxy(t/2,H+D-t) +
" L "+this.SVGxy(W,H+D-t/2),
t,values.mathcolor),0,t/2);
dx = p;
break;
}
}
var sides = [["H",W,0,H-t],["V",H+D,W-t,-D],["H",W,0,-D],["V",H+D,0,-D]];
for (i = 0; i < 4; i++) {
if (borders[i]) {
var side = sides[i];
svg.Add(BBOX[side[0]+"LINE"](side[1],t,"solid",values.mathcolor),side[2],side[3]);
}
}
svg.Add(base,dx+p+t,0,false,true);
svg.Clean();
this.SVGhandleSpace(svg);
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
},
SVGxy: function (x,y) {return Math.floor(x)+","+Math.floor(y)}
});
MathJax.Hub.Startup.signal.Post("SVG menclose Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/menclose.js");
});

View File

@ -0,0 +1,99 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/mglyph.js
*
* Implements the SVG output for <mglyph> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG,
BBOX = SVG.BBOX;
var XLINKNS = "http://www.w3.org/1999/xlink";
BBOX.MGLYPH = BBOX.Subclass({
type: "image", removeable: false,
Init: function (img,w,h,align,mu,def) {
if (def == null) {def = {}}
var W = img.width*1000/SVG.em, H = img.height*1000/SVG.em, y = 0;
if (w !== "") {W = SVG.length2em(w,mu,W)}
if (h !== "") {H = SVG.length2em(h,mu,H)}
if (align !== "" && align.match(/\d/)) {y = SVG.length2em(align,mu); def.y = -y}
def.height = Math.floor(H); def.width = Math.floor(W);
def.transform = "translate(0,"+H+") matrix(1 0 0 -1 0 0)";
def.preserveAspectRatio = "none";
this.SUPER(arguments).Init.call(this,def);
this.element.setAttributeNS(XLINKNS,"href",img.src);
this.w = this.r = W; this.h = this.H = H + y;
this.d = this.D = -y; this.l = 0;
}
});
MML.mglyph.Augment({
toSVG: function (variant,scale) {
this.SVGgetStyles(); var svg = this.SVG(), img, err;
this.SVGhandleSpace(svg);
var values = this.getValues("src","width","height","valign","alt");
if (values.src === "") {
values = this.getValues("index","fontfamily");
if (values.index) {
if (!scale) {scale = this.SVGgetScale()}
var def = {}; if (values.fontfamily) {def["font-family"] = values.fontfamily}
svg.Add(BBOX.TEXT(scale,String.fromCharCode(values.index),def));
}
} else {
if (!this.img) {this.img = MML.mglyph.GLYPH[values.src]}
if (!this.img) {
this.img = MML.mglyph.GLYPH[values.src] = {img: new Image(), status: "pending"};
img = this.img.img;
img.onload = MathJax.Callback(["SVGimgLoaded",this]);
img.onerror = MathJax.Callback(["SVGimgError",this]);
img.src = values.src;
MathJax.Hub.RestartAfter(img.onload);
}
if (this.img.status !== "OK") {
err = MML.merror("Bad mglyph: "+values.src).With({mathsize:"75%"});
this.Append(err); svg = err.toSVG(); this.data.pop();
} else {
var mu = this.SVGgetMu(svg);
svg.Add(BBOX.MGLYPH(this.img.img,values.width,values.height,values.valign,mu,
{src:values.src, alt:values.alt, title:values.alt}));
}
}
svg.Clean();
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
},
SVGimgLoaded: function (event,status) {
if (typeof(event) === "string") {status = event}
this.img.status = (status || "OK")
},
SVGimgError: function () {this.img.img.onload("error")}
},{
GLYPH: {} // global list of all loaded glyphs
});
MathJax.Hub.Startup.signal.Post("SVG mglyph Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/mglyph.js");
});

View File

@ -0,0 +1,120 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/mmultiscripts.js
*
* Implements the SVG output for <mmultiscripts> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG;
MML.mmultiscripts.Augment({
toSVG: function (HW,D) {
var svg = this.SVG(); this.SVGhandleSpace();
var scale = this.SVGgetScale();
var base = (this.data[this.base] ? this.SVGdataStretched(this.base,HW,D) : SVG.BBOX.G().Clean());
var x_height = SVG.TeX.x_height * scale,
s = SVG.TeX.scriptspace * scale * .75; // FIXME: .75 can be removed when IC is right?
var BOX = this.SVGgetScripts(s);
var sub = BOX[0], sup = BOX[1], presub = BOX[2], presup = BOX[3];
var sscale = (this.data[1]||this).SVGgetScale();
var q = SVG.TeX.sup_drop * sscale, r = SVG.TeX.sub_drop * sscale;
var u = base.h - q, v = base.d + r, delta = 0, p;
if (base.ic) {delta = base.ic}
if (this.data[this.base] &&
(this.data[this.base].type === "mi" || this.data[this.base].type === "mo")) {
if (this.data[this.base].data.join("").length === 1 && base.scale === 1 &&
!base.stretched && !this.data[this.base].Get("largeop")) {u = v = 0}
}
var min = this.getValues("subscriptshift","superscriptshift"), mu = this.SVGgetMu(svg);
min.subscriptshift = (min.subscriptshift === "" ? 0 : SVG.length2em(min.subscriptshift,mu));
min.superscriptshift = (min.superscriptshift === "" ? 0 : SVG.length2em(min.superscriptshift,mu));
var dx = 0;
if (presub) {dx = presub.w+delta} else if (presup) {dx = presup.w-delta}
svg.Add(base,Math.max(0,dx),0);
if (!sup && !presup) {
v = Math.max(v,SVG.TeX.sub1*scale,min.subscriptshift);
if (sub) {v = Math.max(v,sub.h-(4/5)*x_height)}
if (presub) {v = Math.max(v,presub.h-(4/5)*x_height)}
if (sub) {svg.Add(sub,dx+base.w+s-delta,-v)}
if (presub) {svg.Add(presub,0,-v)}
} else {
if (!sub && !presub) {
var values = this.getValues("displaystyle","texprimestyle");
p = SVG.TeX[(values.displaystyle ? "sup1" : (values.texprimestyle ? "sup3" : "sup2"))];
u = Math.max(u,p*scale,min.superscriptshift);
if (sup) {u = Math.max(u,sup.d+(1/4)*x_height)}
if (presup) {u = Math.max(u,presup.d+(1/4)*x_height)}
if (sup) {svg.Add(sup,dx+base.w+s,u)}
if (presup) {svg.Add(presup,0,u)}
} else {
v = Math.max(v,SVG.TeX.sub2*scale);
var t = SVG.TeX.rule_thickness * scale;
var h = (sub||presub).h, d = (sup||presup).d;
if (presub) {h = Math.max(h,presub.h)}
if (presup) {d = Math.max(d,presup.d)}
if ((u - d) - (h - v) < 3*t) {
v = 3*t - u + d + h; q = (4/5)*x_height - (u - d);
if (q > 0) {u += q; v -= q}
}
u = Math.max(u,min.superscriptshift); v = Math.max(v,min.subscriptshift);
if (sup) {svg.Add(sup,dx+base.w+s,u)}
if (presup) {svg.Add(presup,dx+delta-presup.w,u)}
if (sub) {svg.Add(sub,dx+base.w+s-delta,-v)}
if (presub) {svg.Add(presub,dx-presub.w,-v)}
}
}
svg.Clean();
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
},
SVGgetScripts: function (s) {
var sup, sub, BOX = [];
var i = 1, m = this.data.length, W = 0;
for (var k = 0; k < 4; k += 2) {
while (i < m && this.data[i].type !== "mprescripts") {
for (var j = k; j < k+2; j++) {
if (this.data[i] && this.data[i].type !== "none") {
if (!BOX[j]) {BOX[j] = SVG.BBOX.G()}
BOX[j].Add(this.data[i].toSVG().With({x:W}));
}
i++;
}
sub = BOX[k]||{w:0}; sup = BOX[k+1]||{w:0};
sub.w = sup.w = W = Math.max(sub.w,sup.w);
}
i++; W = 0;
}
for (j = 0; j < 4; j++) {if (BOX[j]) {BOX[j].w += s; BOX[j].Clean()}}
return BOX;
}
});
MathJax.Hub.Startup.signal.Post("SVG mmultiscripts Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/mmultiscripts.js");
});

View File

@ -0,0 +1,55 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/ms.js
*
* Implements the SVG output for <ms> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG;
MML.ms.Augment({
toSVG: function () {
var svg = this.SVG(); this.SVGhandleSpace(svg);
var values = this.getValues("lquote","rquote");
var variant = this.SVGgetVariant(), scale = this.SVGgetScale();
var text = this.data.join(""); // FIXME: handle mglyph?
var pattern = [];
if (values.lquote.length === 1) {pattern.push(this.SVGquoteRegExp(values.lquote))}
if (values.rquote.length === 1) {pattern.push(this.SVGquoteRegExp(values.rquote))}
if (pattern.length) {text = text.replace(RegExp("("+pattern.join("|")+")","g"),"\\$1")}
svg.Add(this.SVGhandleVariant(variant,scale,values.lquote+text+values.rquote));
svg.Clean();
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
},
SVGquoteRegExp: function (string) {
return string.replace(/([.*+?|{}()\[\]\\])/g,"\\$1");
}
});
MML.ms.prototype.defaults.mathvariant = 'monospace';
MathJax.Hub.Startup.signal.Post("SVG ms Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/ms.js");
});

View File

@ -0,0 +1,346 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/mtable.js
*
* Implements the SVG output for <mtable> elements.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG,
BBOX = SVG.BBOX;
MML.mtable.Augment({
toSVG: function (span) {
var svg = this.SVG();
if (this.data.length === 0) {return svg}
var values = this.getValues("columnalign","rowalign","columnspacing","rowspacing",
"columnwidth","equalcolumns","equalrows",
"columnlines","rowlines","frame","framespacing",
"align","useHeight","width","side","minlabelspacing");
// Handle relative width as fixed width in relation to container
if (values.width.match(/%$/))
{svg.width = values.width = Math.floor(SVG.cwidth*parseFloat(values.width)/100)+"px"}
var scale = this.SVGgetScale(), mu = this.SVGgetMu(svg);
var LABEL = -1;
var H = [], D = [], W = [], A = [], C = [], i, j, J = -1, m, M, s, row;
var LHD = SVG.FONTDATA.baselineskip * scale * values.useHeight,
LH = SVG.FONTDATA.lineH * scale, LD = SVG.FONTDATA.lineD * scale;
//
// Create cells and measure columns and rows
//
for (i = 0, m = this.data.length; i < m; i++) {
row = this.data[i]; s = (row.type === "mlabeledtr" ? LABEL : 0);
A[i] = []; H[i] = D[i] = 0;
for (j = s, M = row.data.length + s; j < M; j++) {
if (W[j] == null) {
if (j > J) {J = j}
C[j] = BBOX.G();
W[j] = -SVG.BIGDIMEN;
}
A[i][j] = row.data[j-s].toSVG();
// if (row.data[j-s].isMultiline) {A[i][j].style.width = "100%"}
if (A[i][j].h > H[i]) {H[i] = A[i][j].h}
if (A[i][j].d > D[i]) {D[i] = A[i][j].d}
if (A[i][j].w > W[j]) {W[j] = A[i][j].w}
}
}
if (H[0]+D[0]) {H[0] = Math.max(H[0],LH)}
if (H[A.length-1]+D[A.length-1]) {D[A.length-1] = Math.max(D[A.length-1],LD)}
//
// Determine spacing and alignment
//
var CSPACE = values.columnspacing.split(/ /),
RSPACE = values.rowspacing.split(/ /),
CALIGN = values.columnalign.split(/ /),
RALIGN = values.rowalign.split(/ /),
CLINES = values.columnlines.split(/ /),
RLINES = values.rowlines.split(/ /),
CWIDTH = values.columnwidth.split(/ /),
RCALIGN = [];
for (i = 0, m = CSPACE.length; i < m; i++) {CSPACE[i] = SVG.length2em(CSPACE[i],mu)}
for (i = 0, m = RSPACE.length; i < m; i++) {RSPACE[i] = SVG.length2em(RSPACE[i],mu)}
while (CSPACE.length < J) {CSPACE.push(CSPACE[CSPACE.length-1])}
while (CALIGN.length <= J) {CALIGN.push(CALIGN[CALIGN.length-1])}
while (CLINES.length < J) {CLINES.push(CLINES[CLINES.length-1])}
while (CWIDTH.length <= J) {CWIDTH.push(CWIDTH[CWIDTH.length-1])}
while (RSPACE.length < A.length) {RSPACE.push(RSPACE[RSPACE.length-1])}
while (RALIGN.length <= A.length) {RALIGN.push(RALIGN[RALIGN.length-1])}
while (RLINES.length < A.length) {RLINES.push(RLINES[RLINES.length-1])}
if (C[LABEL]) {
CALIGN[LABEL] = (values.side.substr(0,1) === "l" ? "left" : "right");
CSPACE[LABEL] = -W[LABEL];
}
//
// Override row data
//
for (i = 0, m = A.length; i < m; i++) {
row = this.data[i]; RCALIGN[i] = [];
if (row.rowalign) {RALIGN[i] = row.rowalign}
if (row.columnalign) {
RCALIGN[i] = row.columnalign.split(/ /);
while (RCALIGN[i].length <= J) {RCALIGN[i].push(RCALIGN[i][RCALIGN[i].length-1])}
}
}
//
// Handle equal heights
//
if (values.equalrows) {
// FIXME: should really be based on row align (below is for baseline)
var Hm = Math.max.apply(Math,H), Dm = Math.max.apply(Math,D);
for (i = 0, m = A.length; i < m; i++)
{s = ((Hm + Dm) - (H[i] + D[i])) / 2; H[i] += s; D[i] += s}
}
// FIXME: do background colors for entire cell (include half the intercolumn space?)
//
// Determine array total height
//
var HD = H[0] + D[A.length-1];
for (i = 0, m = A.length-1; i < m; i++)
{HD += Math.max((H[i]+D[i] ? LHD : 0),D[i]+H[i+1]+RSPACE[i])}
//
// Determine frame and line sizes
//
var fx = 0, fy = 0, fW, fH = HD;
if (values.frame !== "none" ||
(values.columnlines+values.rowlines).match(/solid|dashed/)) {
fx = SVG.length2em(values.framespacing.split(/[, ]+/)[0],mu);
fy = SVG.length2em(values.framespacing.split(/[, ]+/)[1],mu);
fH = HD + 2*fy; // fW waits until svg.w is determined
}
//
// Compute alignment
//
var Y, fY, n = "";
if (typeof(values.align) !== "string") {values.align = String(values.align)}
if (values.align.match(/(top|bottom|center|baseline|axis)( +(-?\d+))?/))
{n = RegExp.$3; values.align = RegExp.$1} else {values.align = this.defaults.align}
if (n !== "") {
//
// Find the height of the given row
//
n = parseInt(n);
if (n < 0) {n = A.length + 1 + n}
if (n < 1) {n = 1} else if (n > A.length) {n = A.length}
Y = 0; fY = -(HD + fy) + H[0];
for (i = 0, m = n-1; i < m; i++) {
// FIXME: Should handle values.align for final row
var dY = Math.max((H[i]+D[i] ? LHD : 0),D[i]+H[i+1]+RSPACE[i]);
Y += dY; fY += dY;
}
} else {
Y = ({
top: -(H[0] + fy),
bottom: HD + fy - H[0],
center: HD/2 - H[0],
baseline: HD/2 - H[0],
axis: HD/2 + SVG.TeX.axis_height*scale - H[0]
})[values.align];
fY = ({
top: -(HD + 2*fy),
bottom: 0,
center: -(HD/2 + fy),
baseline: -(HD/2 + fy),
axis: SVG.TeX.axis_height*scale - HD/2 - fy
})[values.align];
}
var WW, WP = 0, Wt = 0, Wp = 0, p = 0, f = 0, P = [], F = [], Wf = 1;
//
if (values.equalcolumns && values.width !== "auto") {
//
// Handle equalcolumns for percent-width and fixed-width tables
//
// Get total width minus column spacing
WW = SVG.length2em(values.width,mu);
for (i = 0, m = Math.min(J+1,CSPACE.length); i < m; i++) {WW -= CSPACE[i]}
// Determine individual column widths
WW /= J+1;
for (i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {W[i] = WW}
} else {
//
// Get column widths for fit and percentage columns
//
// Calculate the natural widths and percentage widths,
// while keeping track of the fit and percentage columns
for(i = 0, m = Math.min(J+1,CWIDTH.length); i < m; i++) {
if (CWIDTH[i] === "auto") {Wt += W[i]}
else if (CWIDTH[i] === "fit") {F[f] = i; f++; Wt += W[i]}
else if (CWIDTH[i].match(/%$/))
{P[p] = i; p++; Wp += W[i]; WP += SVG.length2em(CWIDTH[i],mu,1)}
else {W[i] = SVG.length2em(CWIDTH[i],mu); Wt += W[i]}
}
// Get the full width (excluding inter-column spacing)
if (values.width === "auto") {
if (WP > .98) {Wf = Wp/(Wt+Wp); WW = Wt + Wp} else {WW = Wt / (1-WP)}
} else {
WW = SVG.length2em(values.width,mu);
for (i = 0, m = Math.min(J+1,CSPACE.length); i < m; i++) {WW -= CSPACE[i]}
}
// Determine the relative column widths
for (i = 0, m = P.length; i < m; i++) {
W[P[i]] = SVG.length2em(CWIDTH[P[i]],mu,WW*Wf); Wt += W[P[i]];
}
// Stretch fit columns, if any, otherwise stretch (or shrink) everything
if (Math.abs(WW - Wt) > .01) {
if (f && WW > Wt) {
WW = (WW - Wt) / f; for (i = 0, m = F.length; i < m; i++) {W[F[i]] += WW}
} else {WW = WW/Wt; for (j = 0; j <= J; j++) {W[j] *= WW}}
}
//
// Handle equal columns
//
if (values.equalcolumns) {
var Wm = Math.max.apply(Math,W);
for (j = 0; j <= J; j++) {W[j] = Wm}
}
}
//
// Lay out array columns
//
var y = Y, dy, align; s = (C[LABEL] ? LABEL : 0);
for (j = s; j <= J; j++) {
C[j].w = W[j];
for (i = 0, m = A.length; i < m; i++) {
if (A[i][j]) {
s = (this.data[i].type === "mlabeledtr" ? LABEL : 0);
var cell = this.data[i].data[j-s];
if (cell.SVGcanStretch("Horizontal")) {
A[i][j] = cell.SVGstretchH(W[j]);
} else if (cell.SVGcanStretch("Vertical")) {
var mo = cell.CoreMO();
var symmetric = mo.symmetric; mo.symmetric = false;
A[i][j] = cell.SVGstretchV(H[i],D[i]);
mo.symmetric = symmetric;
}
align = cell.rowalign||this.data[i].rowalign||RALIGN[i];
dy = ({top: H[i] - A[i][j].h,
bottom: A[i][j].d - D[i],
center: ((H[i]-D[i]) - (A[i][j].h-A[i][j].d))/2,
baseline: 0, axis: 0})[align]; // FIXME: handle axis better?
align = (cell.columnalign||RCALIGN[i][j]||CALIGN[j])
C[j].Align(A[i][j],align,0,y+dy);
}
if (i < A.length-1) {y -= Math.max((H[i]+D[i] ? LHD : 0),D[i]+H[i+1]+RSPACE[i])}
}
y = Y;
}
//
// Place the columns and add column lines
//
var lw = 1.5*SVG.em;
var x = fx - lw/2;
for (j = 0; j <= J; j++) {
svg.Add(C[j],x,0); x += W[j] + CSPACE[j];
if (CLINES[j] !== "none" && j < J && j !== LABEL)
{svg.Add(BBOX.VLINE(fH,lw,CLINES[j]),x-CSPACE[j]/2,fY)}
}
svg.w += fx; svg.d = -fY; svg.h = fH+fY;
fW = svg.w;
//
// Add frame
//
if (values.frame !== "none") {
svg.Add(BBOX.HLINE(fW,lw,values.frame),0,fY+fH-lw);
svg.Add(BBOX.HLINE(fW,lw,values.frame),0,fY);
svg.Add(BBOX.VLINE(fH,lw,values.frame),0,fY);
svg.Add(BBOX.VLINE(fH,lw,values.frame),fW-lw,fY);
}
//
// Add row lines
//
y = Y - lw/2;
for (i = 0, m = A.length-1; i < m; i++) {
dy = Math.max(LHD,D[i]+H[i+1]+RSPACE[i]);
if (RLINES[i] !== "none")
{svg.Add(BBOX.HLINE(fW,lw,RLINES[i]),0,y-D[i]-(dy-D[i]-H[i+1])/2)}
y -= dy;
}
//
// Finish the table
//
svg.Clean();
this.SVGhandleSpace(svg);
this.SVGhandleColor(svg);
//
// Place the labels, if any
//
if (C[LABEL]) {
var indent = this.getValues("indentalignfirst","indentshiftfirst","indentalign","indentshift");
if (indent.indentalignfirst !== MML.INDENTALIGN.INDENTALIGN) {indent.indentalign = indent.indentalignfirst}
if (indent.indentalign === MML.INDENTALIGN.AUTO) {indent.indentalign = this.displayAlign}
if (indent.indentshiftfirst !== MML.INDENTSHIFT.INDENTSHIFT) {indent.indentshift = indent.indentshiftfirst}
if (indent.indentshift === "auto") {indent.indentshift = this.displayIndent}
var shift = (indent.indentshift ? SVG.length2em(indent.indentshift,mu) : 0);
var labelshift = SVG.length2em(values.minlabelspacing,mu);
var eqn = svg; svg = this.SVG();
if (indent.indentalign === MML.INDENTALIGN.CENTER) {
svg.w = svg.r = SVG.length2em(SVG.cwidth+"px"); shift = 0; svg.hasIndent = true;
} else if (CALIGN[LABEL] !== indent.indentalign) {
svg.w = svg.r = SVG.length2em(SVG.cwidth+"px") - shift - labelshift;
shift = labelshift = 0;
} else {
svg.w = svg.r = eqn.w + shift;
svg.hasIndent = true;
}
svg.Align(eqn,indent.indentalign,shift,0);
svg.Align(C[LABEL],CALIGN[LABEL],labelshift,0);
}
this.SVGsaveData(svg);
return svg;
},
SVGhandleSpace: function (svg) {
if (!this.hasFrame && !svg.width) {svg.x = svg.X = 167}
this.SUPER(arguments).SVGhandleSpace.call(this,svg);
}
});
MML.mtd.Augment({
toSVG: function (HW,D) {
var svg = this.svg = this.SVG();
if (this.data[0]) {
svg.Add(this.SVGdataStretched(0,HW,D));
svg.Clean();
}
this.SVGhandleColor(svg);
this.SVGsaveData(svg);
return svg;
}
});
MathJax.Hub.Startup.signal.Post("SVG mtable Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/mtable.js");
});

View File

@ -0,0 +1,497 @@
/*************************************************************
*
* MathJax/jax/output/SVG/autoload/multiline.js
*
* Implements the SVG output for <mrow>'s that contain line breaks.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* 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("SVG Jax Ready",function () {
var VERSION = "2.0";
var MML = MathJax.ElementJax.mml,
SVG = MathJax.OutputJax.SVG,
BBOX = SVG.BBOX;
//
// Penalties for the various line breaks
//
var PENALTY = {
newline: 0,
nobreak: 1000000,
goodbreak: [-200],
badbreak: [+200],
auto: [0],
toobig: 500,
nestfactor: 400,
spacefactor: -100,
spaceoffset: 2,
spacelimit: 1, // spaces larger than this get a penalty boost
fence: 500,
close: 500
};
var ENDVALUES = {linebreakstyle: "after"};
/**************************************************************************/
MML.mrow.Augment({
//
// Handle breaking an mrow into separate lines
//
SVGmultiline: function (svg) {
//
// Find the parent element and mark it as multiline
//
var parent = this;
while (parent.inferred || (parent.parent && parent.parent.type === "mrow" &&
parent.parent.data.length === 1)) {parent = parent.parent}
var isTop = ((parent.type === "math" && parent.Get("display") === "block") ||
parent.type === "mtd");
parent.isMultiline = true;
//
// Default values for the line-breaking parameters
//
var VALUES = this.getValues(
"linebreak","linebreakstyle","lineleading","linebreakmultchar",
"indentalign","indentshift",
"indentalignfirst","indentshiftfirst",
"indentalignlast","indentshiftlast"
);
if (VALUES.linebreakstyle === MML.LINEBREAKSTYLE.INFIXLINEBREAKSTYLE)
{VALUES.linebreakstyle = this.Get("infixlinebreakstyle")}
VALUES.lineleading = SVG.length2em(VALUES.lineleading,1,0.5);
//
// Start with a fresh SVG element
// and make it full width if we are breaking to a specific width
//
svg = this.SVG();
if (SVG.linebreakWidth < SVG.BIGDIMEN) {svg.w = SVG.linebreakWidth}
else {svg.w = SVG.cwidth/SVG.em * 1000}
var state = {
n: 0, Y: 0,
scale: this.SVGgetScale(),
isTop: isTop,
values: {},
VALUES: VALUES
},
align = this.SVGgetAlign(state,{}),
shift = this.SVGgetShift(state,{},align),
start = [],
end = {
index:[], penalty:PENALTY.nobreak,
w:0, W:shift, shift:shift, scanW:shift,
nest: 0
},
broken = false;
//
// Break the expression at its best line breaks
//
while (this.SVGbetterBreak(end,state) &&
(end.scanW >= SVG.linebreakWidth || end.penalty == PENALTY.newline)) {
this.SVGaddLine(svg,start,end.index,state,end.values,broken);
start = end.index.slice(0); broken = true;
align = this.SVGgetAlign(state,end.values);
shift = this.SVGgetShift(state,end.values,align);
if (align === MML.INDENTALIGN.CENTER) {shift = 0}
end.W = end.shift = end.scanW = shift; end.penalty = PENALTY.nobreak;
}
state.isLast = true;
this.SVGaddLine(svg,start,[],state,ENDVALUES,broken);
this.SVGhandleSpace(svg);
this.SVGhandleColor(svg);
svg.isMultiline = true;
this.SVGsaveData(svg);
return svg;
}
});
/**************************************************************************/
MML.mbase.Augment({
SVGlinebreakPenalty: PENALTY,
/****************************************************************/
//
// Locate the next linebreak that is better than the current one
//
SVGbetterBreak: function (info,state) {
if (this.isToken) {return false} // FIXME: handle breaking of token elements
if (this.isEmbellished()) {
info.embellished = this;
return this.CoreMO().SVGbetterBreak(info,state);
}
if (this.linebreakContainer) {return false}
//
// Get the current breakpoint position and other data
//
var index = info.index.slice(0), i = info.index.shift(),
m = this.data.length, W, scanW = info.W,
broken = (info.index.length > 0), better = false;
if (i == null) {i = -1}; if (!broken) {i++; info.W += info.w};
info.w = 0; info.nest++;
//
// Look through the line for breakpoints,
// (as long as we are not too far past the breaking width)
//
while (i < m && info.W < 1.33*SVG.linebreakWidth) {
if (this.data[i]) {
if (this.data[i].SVGbetterBreak(info,state)) {
better = true; index = [i].concat(info.index); W = info.W;
if (info.penalty === PENALTY.newline) {info.index = index; info.nest--; return true}
}
if (!broken) {
var svg = this.data[i].SVGdata;
scanW += svg.w + svg.x; if (svg.X) {scanW += svg.X}
info.W = info.scanW = scanW;
}
}
info.index = []; i++; broken = false;
}
info.nest--; info.index = index;
if (better) {info.W = W}
return better;
},
/****************************************************************/
//
// Create a new line and move the required elements into it
// Position it using proper alignment and indenting
//
SVGaddLine: function (svg,start,end,state,values,broken) {
//
// Create a box for the line, with empty BBox
// fill it with the proper elements,
// and clean up the bbox
//
line = BBOX();
state.first = broken; state.last = true;
this.SVGmoveLine(start,end,line,state,values);
line.Clean();
//
// Get the alignment and shift values
//
var align = this.SVGgetAlign(state,values),
shift = this.SVGgetShift(state,values,align);
//
// Add in space for the shift
//
if (shift) {
if (align === MML.INDENTALIGN.LEFT) {line.x = shift} else
if (align === MML.INDENTALIGN.RIGHT) {line.w += shift; line.r = line.w}
}
//
// Set the Y offset based on previous depth, leading, and current height
//
if (state.n > 0) {
var LHD = SVG.FONTDATA.baselineskip * state.scale;
var leading = (state.values.lineleading == null ? state.VALUES : state.values).lineleading;
state.Y -= Math.max(LHD,state.d + line.h + leading);
}
//
// Place the new line
//
svg.Align(line,align,0,state.Y);
//
// Save the values needed for the future
//
state.d = line.d; state.values = values; state.n++;
},
/****************************************************************/
//
// Get alignment and shift values from the given data
//
SVGgetAlign: function (state,values) {
var cur = values, prev = state.values, def = state.VALUES, align;
if (state.n === 0) {align = cur.indentalignfirst || prev.indentalignfirst || def.indentalignfirst}
else if (state.isLast) {align = prev.indentalignlast || def.indentalignlast}
else {align = prev.indentalign || def.indentalign}
if (align === MML.INDENTALIGN.INDENTALIGN) {align = prev.indentalign || def.indentalign}
if (align === MML.INDENTALIGN.AUTO) {align = (state.isTop ? this.displayAlign : MML.INDENTALIGN.LEFT)}
return align;
},
SVGgetShift: function (state,values,align) {
if (align === MML.INDENTALIGN.CENTER) {return 0}
var cur = values, prev = state.values, def = state.VALUES, shift;
if (state.n === 0) {shift = cur.indentshiftfirst || prev.indentshiftfirst || def.indentshiftfirst}
else if (state.isLast) {shift = prev.indentshiftlast || def.indentshiftlast}
else {shift = prev.indentshift || def.indentshift}
if (shift === MML.INDENTSHIFT.INDENTSHIFT) {shift = prev.indentshift || def.indentshift}
if (shift === "auto" || shift === "") {shift = (state.isTSop ? this.displayIndent : "0")}
return SVG.length2em(shift,0);
},
/****************************************************************/
//
// Move the selected elements into the new line,
// moving whole items when possible, and parts of ones
// that are split by a line break.
//
SVGmoveLine: function (start,end,svg,state,values) {
var i = start[0], j = end[0];
if (i == null) {i = -1}; if (j == null) {j = this.data.length-1}
if (i === j && start.length > 1) {
//
// If starting and ending in the same element move the subpiece to the new line
//
this.data[i].SVGmoveSlice(start.slice(1),end.slice(1),svg,state,values,"paddingLeft");
} else {
//
// Otherwise, move the remainder of the initial item
// and any others up to the last one
//
var last = state.last; state.last = false;
while (i < j) {
if (this.data[i]) {
if (start.length <= 1) {this.data[i].SVGmove(svg,state,values)}
else {this.data[i].SVGmoveSlice(start.slice(1),[],svg,state,values,"paddingLeft")}
}
i++; state.first = false; start = [];
}
//
// If the last item is complete, move it,
// otherwise move the first part of it up to the split
//
state.last = last;
if (this.data[i]) {
if (end.length <= 1) {this.data[i].SVGmove(svg,state,values)}
else {this.data[i].SVGmoveSlice([],end.slice(1),svg,state,values,"paddingRight")}
}
}
},
/****************************************************************/
//
// Split an element and copy the selected items into the new part
//
SVGmoveSlice: function (start,end,svg,state,values,padding) {
//
// Create a new container for the slice of the element
// Move the selected portion into the slice
//
var slice = BBOX();
this.SVGmoveLine(start,end,slice,state,values);
slice.Clean();
this.SVGhandleColor(slice);
svg.Add(slice,svg.w,0,true);
return slice;
},
/****************************************************************/
//
// Move an element from its original span to its new location in
// a split element or the new line's span
//
SVGmove: function (line,state,values) {
// FIXME: handle linebreakstyle === "duplicate"
// FIXME: handle linebreakmultchar
if (!(state.first || state.last) ||
(state.first && state.values.linebreakstyle === MML.LINEBREAKSTYLE.BEFORE) ||
(state.last && values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER)) {
//
// Recreate output
// Remove padding (if first, remove at right, if last remove at left)
// Add to line
//
var svg = this.toSVG(this.SVGdata.HW,this.SVGdata.D);
if (state.last) {svg.x = 0}
if (state.first || state.nextIsFirst) {delete state.nextIsFirst; if (svg.X) {svg.X = 0}}
line.Add(svg,line.w,0,true);
} else if (state.first) {state.nextIsFirst = true} else {delete state.nextIsFirst}
}
});
/**************************************************************************/
MML.mo.Augment({
//
// Override the method for checking line breaks to properly handle <mo>
//
SVGbetterBreak: function (info,state) {
var values = this.getValues(
"linebreak","linebreakstyle","lineleading","linebreakmultchar",
"indentalign","indentshift",
"indentalignfirst","indentshiftfirst",
"indentalignlast","indentshiftlast",
"texClass", "fence"
);
if (values.linebreakstyle === MML.LINEBREAKSTYLE.INFIXLINEBREAKSTYLE)
{values.linebreakstyle = this.Get("infixlinebreakstyle")}
//
// Adjust nesting by TeX class (helps output that does not include
// mrows for nesting, but can leave these unbalanced.
//
if (values.texClass === MML.TEXCLASS.OPEN) {info.nest++}
if (values.texClass === MML.TEXCLASS.CLOSE) {info.nest--}
//
// Get the default penalty for this location
//
var W = info.W, mo = (info.embellished||this); delete info.embellished;
var svg = mo.SVGdata, w = svg.w + svg.x;
if (values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER) {W += w; w = 0}
if (W - info.shift === 0) {return false} // don't break at zero width (FIXME?)
var offset = SVG.linebreakWidth - W;
// adjust offest for explicit first-line indent and align
if (state.n === 0 && (values.indentshiftfirst !== state.VALUES.indentshiftfirst ||
values.indentalignfirst !== state.VALUES.indentalignfirst)) {
var align = this.SVGgetAlign(state,values),
shift = this.SVGgetShift(state,values,align);
offset += (info.shift - shift);
}
//
var penalty = Math.floor(offset / SVG.linebreakWidth * 1000);
if (penalty < 0) {penalty = PENALTY.toobig - 3*penalty}
if (values.fence) {penalty += PENALTY.fence}
if ((values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER &&
values.texClass === MML.TEXCLASS.OPEN) ||
values.texClass === MML.TEXCLASS.CLOSE) {penalty += PENALTY.close}
penalty += info.nest * PENALTY.nestfactor;
//
// Get the penalty for this type of break and
// use it to modify the default penalty
//
var linebreak = PENALTY[values.linebreak||MML.LINEBREAK.AUTO];
if (!(linebreak instanceof Array)) {
// for breaks past the width, don't modify penalty
if (offset >= 0) {penalty = linebreak * info.nest}
} else {penalty = Math.max(1,penalty + linebreak[0] * info.nest)}
//
// If the penalty is no better than the current one, return false
// Otherwise save the data for this breakpoint and return true
//
if (penalty >= info.penalty) {return false}
info.penalty = penalty; info.values = values; info.W = W; info.w = w;
values.lineleading = SVG.length2em(values.lineleading,state.VALUES.lineleading);
return true;
}
});
/**************************************************************************/
MML.mspace.Augment({
//
// Override the method for checking line breaks to properly handle <mspace>
//
SVGbetterBreak: function (info,state) {
var values = this.getValues("linebreak");
//
// Get the default penalty for this location
//
var W = info.W, svg = this.SVGdata, w = svg.w + svg.x;
if (values.linebreakstyle === MML.LINEBREAKSTYLE.AFTER) {W += w; w = 0}
if (W - info.shift === 0) {return false} // don't break at zero width (FIXME?)
var offset = SVG.linebreakWidth - W;
//
var penalty = Math.floor(offset / SVG.linebreakWidth * 1000);
if (penalty < 0) {penalty = PENALTY.toobig - 3*penalty}
penalty += info.nest * PENALTY.nestfactor;
//
// Get the penalty for this type of break and
// use it to modify the default penalty
//
var linebreak = PENALTY[values.linebreak||MML.LINEBREAK.AUTO];
if (values.linebreak === MML.LINEBREAK.AUTO && w >= PENALTY.spacelimit*1000)
{linebreak = [(w+PENALTY.spaceoffset)*PENALTY.spacefactor]}
if (!(linebreak instanceof Array)) {
// for breaks past the width, don't modify penalty
if (offset >= 0) {penalty = linebreak * info.nest}
} else {penalty = Math.max(1,penalty + linebreak[0] * info.nest)}
//
// If the penalty is no better than the current one, return false
// Otherwise save the data for this breakpoint and return true
//
if (penalty >= info.penalty) {return false}
info.penalty = penalty; info.values = values; info.W = W; info.w = w;
values.lineleading = state.VALUES.lineleading; values.linebreakstyle = "before";
return true;
}
});
//
// Hook into the mathchoice extension
//
MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () {
MML.TeXmathchoice.Augment({
SVGbetterBreak: function (info,state) {
return this.Core().SVGbetterBreak(info,state);
},
SVGmoveLine: function (start,end,svg,state,values) {
return this.Core().SVGmoveSlice(start,end,svg,state,values);
}
});
});
//
// Have maction process only the selected item
//
MML.maction.Augment({
SVGbetterBreak: function (info,state) {
return this.Core().SVGbetterBreak(info,state);
},
SVGmoveLine: function (start,end,svg,state,values) {
return this.Core().SVGmoveSlice(start,end,svg,state,values);
},
/*
* //
* // Split and move the hit boxes as well
* //
* SVGmoveSlice: function (start,end,svg,state,values,padding) {
* var hitbox = document.getElementById("MathJax-HitBox-"+this.spanID+SVG.idPostfix);
* if (hitbox) {hitbox.parentNode.removeChild(hitbox)}
* var slice = this.SUPER(arguments).SVGmoveSlice.apply(this,arguments);
* if (end.length === 0) {
* span = this.SVGspanElement(); var n = 0;
* while (span) {
* hitbox = this.SVGhandleHitBox(span,"-Continue-"+n);
* span = span.nextMathJaxSpan; n++;
* }
* }
* return slice;
* }
*/
});
//
// Have semantics only do the first element
// (FIXME: do we need to do anything special about annotation-xml?)
//
MML.semantics.Augment({
SVGbetterBreak: function (info,state) {
return (this.data[0] ? this.data[0].SVGbetterBreak(info,state) : false);
},
SVGmoveLine: function (start,end,svg,state,values) {
return (this.data[0] ? this.data[0].SVGmoveSlice(start,end,svg,state,values) : null);
}
});
/**************************************************************************/
MathJax.Hub.Startup.signal.Post("SVG multiline Ready");
MathJax.Ajax.loadComplete(SVG.autoloadDir+"/multiline.js");
});

View File

@ -0,0 +1,79 @@
/*************************************************************
*
* MathJax/jax/output/SVG/config.js
*
* Initializes the SVG OutputJax (the main definition is in
* MathJax/jax/input/SVG/jax.js, which is loaded when needed).
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2011-2012 Design Science, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
MathJax.OutputJax.SVG = MathJax.OutputJax({
id: "SVG",
version: "2.0",
directory: MathJax.OutputJax.directory + "/SVG",
extensionDir: MathJax.OutputJax.extensionDir + "/SVG",
autoloadDir: MathJax.OutputJax.directory + "/SVG/autoload",
fontDir: MathJax.OutputJax.directory + "/SVG/fonts", // font name added later
config: {
scale: 100, minScaleAdjust: 50, // global math scaling factor, and minimum adjusted scale factor
font: "TeX", // currently the only font available
blacker: 10, // stroke-width to make fonts blacker
mtextFontInherit: false, // to make <mtext> be in page font rather than MathJax font
undefinedFamily: "STIXGeneral,'Arial Unicode MS',serif", // fonts to use for missing characters
addMMLclasses: false, // keep MathML structure and use CSS classes to mark elements
EqnChunk: (MathJax.Hub.Browser.isMobile ? 10: 50),
// number of equations to process before showing them
EqnChunkFactor: 1.5, // chunk size is multiplied by this after each chunk
EqnChunkDelay: 100, // milliseconds to delay between chunks (to let browser
// respond to other events)
linebreaks: {
automatic: false, // when false, only process linebreak="newline",
// when true, insert line breaks automatically in long expressions.
width: "container" // maximum width of a line for automatic line breaks (e.g. "30em").
// use "container" to compute size from containing element,
// use "nn% container" for a portion of the container,
// use "nn%" for a portion of the window size
},
styles: {
".MathJax_SVG_Display": {
"text-align": "center",
margin: "1em 0em"
},
"#MathJax_SVG_Tooltip": {
"background-color": "InfoBackground", color: "InfoText",
border: "1px solid black",
"box-shadow": "2px 2px 5px #AAAAAA", // Opera 10.5
"-webkit-box-shadow": "2px 2px 5px #AAAAAA", // Safari 3 and Chrome
"-moz-box-shadow": "2px 2px 5px #AAAAAA", // Forefox 3.5
"-khtml-box-shadow": "2px 2px 5px #AAAAAA", // Konqueror
padding: "3px 4px"
}
}
}
});
if (!MathJax.Hub.config.delayJaxRegistration) {MathJax.OutputJax.SVG.Register("jax/mml")}
MathJax.OutputJax.SVG.loadComplete("config.js");

View File

@ -0,0 +1,140 @@
/*************************************************************
*
* MathJax/jax/output/SVG/fonts/TeX/svg/AMS/Regular/Arrows.js
*
* Copyright (c) 2011 Design Science, Inc.
*
* 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.Insert(
MathJax.OutputJax.SVG.FONTDATA.FONTS['MathJax_AMS'],
{
// LEFTWARDS ARROW
0x2190: [437,-64,500,64,423,'292 419Q292 400 261 347T211 275H306Q319 275 338 275T364 276Q399 276 410 271T422 250T411 230T366 225H306H211Q214 222 232 197T271 136T292 82Q292 71 285 68T262 64H250H241Q221 64 216 67T205 83Q186 127 153 167T78 230Q64 238 64 250Q64 258 69 263T82 272T106 288T139 318Q162 342 177 365T198 402T209 425T223 436Q224 437 252 437H258Q292 437 292 419'],
// RIGHTWARDS ARROW
0x2192: [437,-64,500,58,417,'188 417Q188 437 221 437H233Q256 437 263 434T275 417Q294 373 327 333T402 270Q417 261 417 250Q417 241 410 236T382 217T341 182Q315 155 299 128T275 85T263 66Q259 64 231 64H219Q197 64 191 72T193 100Q202 124 215 147T239 185T257 210T267 223L269 225H174H116Q80 225 69 229T58 250T70 271T114 276Q121 276 140 276T174 275H269L267 277Q266 280 257 291T233 325T205 374Q188 408 188 417'],
// LEFTWARDS ARROW WITH STROKE
0x219A: [437,-60,1000,56,942,'942 250Q942 244 928 230H511L457 148Q440 124 420 93Q404 68 400 64T389 60Q381 60 375 66T368 81Q368 88 415 159L462 230H175L188 214Q210 188 235 145T264 85Q264 75 260 74T231 72L206 74L191 103Q169 142 164 150Q130 195 64 239Q56 244 56 250T64 261Q115 294 142 323T191 397L206 428H231Q255 428 259 426T264 414Q260 397 235 355T188 288L175 272L331 270Q488 270 491 272Q491 275 542 352T597 432Q602 437 609 437Q617 437 622 432T628 417T582 341L537 272L735 270H931Q942 257 942 250'],
// RIGHTWARDS ARROW WITH STROKE
0x219B: [437,-60,1000,54,942,'54 250Q54 258 66 270H277L488 272L542 350Q596 431 602 435Q604 437 609 437Q617 437 622 432T628 417T582 341L537 272L608 270H751L822 272L808 288Q786 313 761 355T733 414Q733 424 737 426T766 428H793L806 397Q829 354 864 314Q896 284 928 263Q942 257 942 250T928 237Q887 208 864 185Q829 147 806 103L793 74L766 72Q742 72 738 73T733 85Q735 102 756 137T797 198L817 225L822 230H511L457 148Q440 124 420 93Q404 68 400 64T389 60Q381 60 375 66T368 81Q368 88 415 159L462 230H264L66 232Q54 239 54 250'],
// LEFTWARDS TWO HEADED ARROW
0x219E: [417,-83,1000,56,944,'56 250Q103 277 142 322T199 417H221Q244 417 244 416Q244 414 237 397T208 344T158 278L151 270H276L285 277Q322 306 349 345T388 417H434Q434 413 424 392T393 338T349 279L340 270H634Q933 270 937 266L938 265Q944 259 944 250T938 235L937 234Q933 230 634 230H340L349 221Q372 196 393 163T424 108T434 83H388Q377 116 350 155T285 223L276 230H151L158 222Q186 191 207 156T236 104T244 84Q244 83 221 83H199Q181 133 142 178T56 250'],
// RIGHTWARDS TWO HEADED ARROW
0x21A0: [417,-83,1000,55,943,'943 250Q895 221 856 177T801 83H778Q755 83 755 84Q755 86 762 103T791 156T841 222L848 230H723L714 223Q677 194 650 155T611 83H565Q565 87 575 108T606 162T650 221L659 230H365Q66 230 62 234L61 235Q55 241 55 250T61 265L62 266Q66 270 365 270H659L650 279Q627 304 606 337T575 392T565 417H611Q622 384 649 345T714 277L723 270H848L841 278Q813 309 792 344T763 396T755 416Q755 417 778 417H801Q817 367 856 323T943 250'],
// LEFTWARDS ARROW WITH TAIL
0x21A2: [417,-83,1111,56,1031,'56 250Q103 277 142 322T199 417H221Q244 417 244 416Q244 414 237 397T208 344T158 278L151 270H873L882 277Q919 306 946 345T985 417H1031Q1031 413 1021 392T990 338T946 279L937 270V230L946 221Q969 196 990 163T1021 108T1031 83H985Q974 116 947 155T882 223L873 230H151L158 222Q186 191 207 156T236 104T244 84Q244 83 221 83H199Q181 133 142 178T56 250'],
// RIGHTWARDS ARROW WITH TAIL
0x21A3: [417,-83,1111,79,1054,'1054 250Q1006 221 967 177T912 83H889Q866 83 866 84Q866 86 873 103T902 156T952 222L959 230H237L228 223Q191 194 164 155T125 83H79Q79 87 89 108T120 162T164 221L173 230V270L164 279Q141 304 120 337T89 392T79 417H125Q136 384 163 345T228 277L237 270H959L952 278Q924 309 903 344T874 396T866 416Q866 417 889 417H912Q928 367 967 323T1054 250'],
// LEFTWARDS ARROW WITH LOOP
0x21AB: [576,41,1000,56,965,'56 250Q103 277 142 322T199 417H221Q244 417 244 416Q244 414 237 397T208 344T158 278L151 270H622V305Q622 356 624 388T635 460T661 521T709 559T785 575Q813 575 833 573T880 561T923 534T952 483T964 405Q964 374 959 350T942 307T918 276T884 255T847 242T804 235T760 231T713 230H662V-27Q654 -41 644 -41H642H640Q628 -41 622 -27V230H151L158 222Q186 191 207 156T236 104T244 84Q244 83 221 83H199Q181 133 142 178T56 250ZM924 403Q924 474 894 505T794 536Q758 536 734 526T696 500T675 453T665 395T662 319V270H699Q826 270 875 295T924 403'],
// RIGHTWARDS ARROW WITH LOOP
0x21AC: [575,41,1000,35,943,'35 405Q35 454 48 489T86 542T137 567T195 575Q229 575 251 571T301 554T345 510T370 429Q377 384 377 305V270H848L841 278Q813 309 792 344T763 396T755 416Q755 417 778 417H801Q817 367 856 323T943 250Q896 221 857 177T801 83H778Q755 83 755 84Q755 86 762 103T791 156T841 222L848 230H377V-27Q369 -41 359 -41H357Q342 -41 337 -25V230H286Q247 231 225 232T169 238T115 255T75 284T45 333T35 405ZM75 406Q75 322 123 296T300 270H337V319Q335 432 317 477T240 534Q232 535 197 535Q140 535 108 507T75 406'],
// LEFT RIGHT WAVE ARROW
0x21AD: [417,-83,1389,57,1331,'57 250Q159 311 200 417H246L242 407Q215 340 159 278L152 270H276L315 310Q354 349 358 351Q366 356 376 351Q378 350 455 273L530 196L606 273Q683 350 686 351Q694 354 703 351Q705 350 782 273L858 196L933 273Q1010 350 1012 351Q1022 356 1030 351Q1034 349 1073 310L1112 270H1236L1229 278Q1173 340 1146 407L1142 417H1188Q1233 306 1331 250Q1231 192 1188 83H1142L1146 93Q1173 160 1229 222L1236 230H1168Q1155 230 1139 230T1119 229Q1112 229 1108 229T1099 231T1092 233T1085 238T1078 245T1068 256T1056 269L1021 304L984 267Q948 230 910 191T867 149Q857 144 848 150Q844 151 770 227T694 304T618 228T540 150Q531 144 521 149Q517 152 479 191T404 267L367 304L332 269Q328 264 320 256T310 246T303 239T296 234T289 231T280 229T269 229Q265 229 249 229T220 230H152L159 222Q215 160 242 93L246 83H223L200 84L195 96Q152 190 57 250'],
// LEFT RIGHT ARROW WITH STROKE
0x21AE: [437,-60,1000,56,942,'491 272Q491 275 542 352T597 432Q602 437 609 437Q617 437 622 432T628 417T582 341L537 272L608 270H751L822 272L808 288Q786 313 761 355T733 414Q733 424 737 426T766 428H793L806 397Q829 354 864 314Q896 284 928 263Q942 257 942 250T928 237Q887 208 864 185Q829 147 806 103L793 74L766 72Q742 72 738 73T733 85Q735 102 756 137T797 198L817 225L822 230H511L457 148Q440 124 420 93Q404 68 400 64T389 60Q381 60 375 66T368 81Q368 88 415 159L462 230H175L188 214Q210 188 235 145T264 85Q264 75 260 74T231 72L206 74L191 103Q169 142 164 150Q130 195 64 239Q56 244 56 250T64 261Q115 294 142 323T191 397L206 428H231Q255 428 259 426T264 414Q260 397 235 355T188 288L175 272L331 270Q488 270 491 272'],
// UPWARDS ARROW WITH TIP LEFTWARDS
0x21B0: [722,0,500,56,444,'56 555Q74 567 79 570T107 592T141 625T170 667T198 722H221Q244 722 244 721Q244 718 236 699T207 647T161 587L151 576L291 575H292H293H294H296H297H298H299H300H301H302H304H305H306H307H308H309H310H311H312H314H315H316H317H318H319H320H321H322H323H324H325H327H328H329H330H331H332H333H334H335H336H337H338H339H340H341H342H343H345Q435 574 438 570L439 569L440 568Q444 564 444 287Q444 15 442 12Q436 0 424 0T406 12Q404 15 404 275V535H151L162 523Q187 495 207 462T236 410T244 389H198L193 402Q171 457 131 497T56 555'],
// UPWARDS ARROW WITH TIP RIGHTWARDS
0x21B1: [722,0,500,55,443,'301 722Q339 618 443 555L437 551Q431 547 422 541T401 526T377 504T352 477T327 443T306 402L301 389H255Q255 392 263 410T291 461T337 523L348 535H95V275Q95 15 93 12Q87 0 75 0T57 12Q55 15 55 287Q55 564 59 568L60 569Q64 573 76 573T208 575L348 576L338 587Q314 613 294 646T264 698T255 721Q255 722 278 722H301'],
// ANTICLOCKWISE TOP SEMICIRCLE ARROW
0x21B6: [461,1,1000,17,950,'361 210Q373 210 373 182V177Q373 155 370 151T348 139Q303 118 267 84T216 28T201 1Q197 -1 196 -1Q189 -1 184 8Q166 39 143 64T99 104T61 129T32 144T19 150Q17 152 17 179Q17 203 21 208Q28 210 39 206Q106 178 157 135L175 119V126Q179 130 179 155Q182 173 193 201Q228 305 312 374T510 459Q532 461 551 461H567Q678 461 784 386Q835 344 861 301Q902 245 926 173T950 32Q950 15 944 8Q930 -6 917 8Q910 12 910 43Q901 208 801 314T561 421Q453 421 359 359Q300 319 263 258T217 126L216 125Q216 124 216 123T217 122Q219 122 229 131T260 156T301 181Q314 189 336 199T361 210'],
// CLOCKWISE TOP SEMICIRCLE ARROW
0x21B7: [460,1,1000,46,982,'972 209Q980 209 981 204T982 179Q982 155 979 151T957 139Q915 121 878 86T815 8Q808 -1 803 -1Q801 -1 797 1Q797 6 783 28T732 84T650 139L628 150Q626 152 626 177Q626 201 630 206Q636 210 637 210Q650 210 697 181Q727 166 764 137L784 119L782 132Q767 239 689 318T499 417Q474 421 442 421Q343 421 261 369T130 219Q86 121 86 28Q86 15 79 8Q73 1 66 1T53 8Q46 15 46 30Q46 102 77 192T186 361Q274 443 386 459Q396 460 426 460Q515 460 588 431T703 361T773 271T812 187T822 132Q822 123 825 123Q936 209 972 209'],
// ANTICLOCKWISE OPEN CIRCLE ARROW
0x21BA: [650,83,778,56,722,'369 543T369 563T397 583Q408 583 440 579L454 577L464 581Q492 592 516 609T552 638T565 650Q604 638 607 637Q606 636 598 628T585 614T570 601T548 584T523 568L510 560L516 558Q522 555 527 553T541 546T559 536T580 523T603 506T626 485Q722 384 722 250Q722 106 622 12T387 -83Q253 -83 155 12T56 250Q56 357 110 433T235 545Q244 550 252 550Q270 550 270 531Q270 522 261 515T238 501T202 477T159 433Q95 352 95 250Q95 131 178 45T388 -42Q511 -42 596 43T682 250Q682 340 636 408T522 511Q495 526 488 526Q488 525 488 525T487 522T485 515L490 506Q505 481 516 451T531 404T535 384L532 385Q529 386 524 387T513 390L491 397L488 408Q472 483 413 542L399 543Q369 543 369 563'],
// CLOCKWISE OPEN CIRCLE ARROW
0x21BB: [650,83,778,56,721,'170 637L213 650Q270 597 313 581L323 577L337 579Q369 583 380 583Q408 583 408 563T380 543H378L364 542Q305 483 289 408L286 397L264 390Q259 389 254 388T245 385L242 384Q242 387 246 403T261 450T287 506L292 515Q291 519 291 521T290 524T289 526Q284 526 265 517T216 486T160 434T114 354T95 249Q95 132 178 45T388 -42Q513 -42 597 44T682 250Q682 337 638 404T532 506Q529 508 525 510T519 514T515 516T511 519T509 522T508 526T507 531Q507 550 525 550Q533 550 542 545Q569 532 596 511T653 454T702 366T721 250Q721 151 672 74T547 -43T388 -83Q254 -83 155 12T56 250Q56 385 151 485Q164 498 179 509T205 528T228 542T247 551T260 558L267 560L254 568Q215 590 170 637'],
// UPWARDS HARPOON WITH BARB RIGHTWARDS
0x21BE: [694,194,417,188,375,'188 258V694H208L215 682Q246 628 293 594T375 551V528Q375 505 374 505Q369 505 351 510T299 534T237 578L228 587V205Q228 -178 226 -182Q221 -194 208 -194T190 -182Q188 -178 188 258'],
// UPWARDS HARPOON WITH BARB LEFTWARDS
0x21BF: [694,194,417,41,228,'41 551Q76 559 123 592T201 682L208 694H228V258Q228 -178 226 -182Q221 -194 208 -194T190 -182Q188 -178 188 205V587L179 578Q151 552 117 534T65 511T42 505Q41 505 41 528V551'],
// DOWNWARDS HARPOON WITH BARB RIGHTWARDS
0x21C2: [694,194,417,188,375,'190 682Q195 694 208 694T226 683Q228 679 228 296V-87L237 -78Q265 -52 299 -34T351 -11T374 -5Q375 -5 375 -28V-51Q340 -60 293 -92T215 -182L208 -194H188V242Q188 678 190 682'],
// DOWNWARDS HARPOON WITH BARB LEFTWARDS
0x21C3: [694,194,417,41,228,'188 295V573Q188 657 189 672T200 692Q206 694 208 694Q221 694 226 683Q228 679 228 242V-194H208L201 -182Q170 -128 123 -94T41 -51V-28Q41 -5 42 -5Q47 -5 65 -10T117 -34T179 -78L188 -87V295'],
// RIGHTWARDS ARROW OVER LEFTWARDS ARROW
0x21C4: [667,0,1000,55,944,'943 500Q895 471 856 427T801 333H778Q755 333 755 334Q755 336 762 353T791 406T841 472L848 480H459Q70 480 67 482Q55 488 55 500T67 518Q70 520 459 520H848L841 528Q813 559 792 594T763 646T755 666Q755 667 778 667H801Q817 617 856 573T943 500ZM56 167Q102 194 141 238T198 333H221Q244 333 244 332Q221 265 161 198L151 187H539Q928 187 930 186Q944 182 944 167Q944 155 934 149Q930 147 541 147H151L160 137Q185 110 205 77T235 24T244 1Q244 0 221 0H199Q158 106 56 167'],
// LEFTWARDS ARROW OVER RIGHTWARDS ARROW
0x21C6: [667,0,1000,55,944,'56 500Q103 527 142 572T199 667H221Q244 667 244 666Q244 664 237 647T208 594T158 528L151 520H539Q928 520 932 518Q944 513 944 500T932 482Q928 480 539 480H151L158 472Q186 441 207 406T236 354T244 334Q244 333 221 333H199Q181 383 142 428T56 500ZM943 167Q835 101 801 0H778Q755 0 755 1T758 9T765 25T771 39Q800 94 839 137L848 147H458Q68 147 66 149Q55 154 55 167Q55 182 69 186Q71 187 460 187H848L838 198Q811 228 791 261T762 314L755 332Q755 333 778 333H801Q841 227 943 167'],
// LEFTWARDS PAIRED ARROWS
0x21C7: [583,83,1000,55,944,'930 437Q944 426 944 416T934 399Q930 397 540 397H150L159 387Q185 360 205 328T234 277T243 252Q243 237 217 191T159 113L150 103H540Q930 103 934 101Q944 94 944 84Q944 71 930 64L540 63H151Q180 34 203 -2T236 -61L244 -83H198Q178 -31 142 11T66 77L55 83L65 89Q157 145 197 246Q199 250 190 269Q150 359 65 411L55 417L66 423Q106 447 142 489T198 583H244Q202 488 151 437H930'],
// UPWARDS PAIRED ARROWS
0x21C8: [694,193,833,83,749,'83 551Q190 590 250 694Q251 689 263 671T307 621T380 567Q409 551 416 551Q422 551 447 563T511 608T577 684L582 694Q642 591 749 551V528Q749 505 748 505Q745 505 724 515T669 546T612 590L602 599V-181Q595 -193 585 -193H582H581Q568 -193 565 -183L563 -179L562 209V598L552 589Q517 556 473 531T414 506H412Q411 506 393 514T361 530T324 553T280 589L270 598V-179Q255 -192 250 -193H247Q237 -193 230 -181V599L220 590Q197 567 164 546T110 515T84 505Q83 505 83 528V551'],
// RIGHTWARDS PAIRED ARROWS
0x21C9: [583,83,1000,55,944,'55 416Q55 427 70 437H848Q819 466 796 502T764 561L755 583H801Q821 531 857 489T933 423L944 417L934 411Q843 355 802 254Q800 250 809 231Q849 141 934 89L944 83L933 77Q893 53 857 11T801 -83H755Q797 12 848 63H459L70 64Q55 70 55 84Q55 94 65 101Q69 103 459 103H849L840 113Q806 148 779 196T756 254Q756 255 760 264T770 286T786 315T809 351T840 387L849 397H459Q69 397 65 399Q55 406 55 416'],
// DOWNWARDS PAIRED ARROWS
0x21CA: [694,194,833,83,749,'230 681Q240 694 251 694Q260 693 270 680V-98L280 -89Q297 -73 314 -60T348 -38T374 -24T397 -13T412 -6H414Q428 -6 473 -32T552 -89L562 -98V291L563 680Q570 693 582 693Q593 694 602 681V-99L612 -90Q635 -68 668 -47T723 -15T748 -5Q749 -5 749 -28V-51Q642 -91 582 -194L577 -184Q551 -141 512 -108T447 -63T416 -51T385 -63T321 -108T255 -184L250 -194Q189 -89 83 -51V-28Q83 -5 84 -5Q88 -5 109 -15T164 -46T220 -90L230 -99V681'],
// LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
0x21CB: [514,14,1000,55,944,'195 504L198 514H221Q244 514 244 512Q244 508 239 490T215 437T171 376L162 367H545Q928 367 932 365Q944 360 944 347T932 329Q928 327 492 327H55V347L67 354Q113 379 146 420T195 504ZM67 171Q70 173 507 173H944V153L932 146Q839 95 804 -4L801 -14H778Q755 -14 755 -12Q768 59 828 124L837 133H454Q71 133 67 135Q55 140 55 153Q55 165 67 171'],
// RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
0x21CC: [514,14,1000,55,944,'755 512Q755 514 778 514H801L804 503Q805 501 812 486T824 462T839 437T862 408T892 381T932 354L944 347V327H507Q70 327 67 329Q55 335 55 347T67 365Q70 367 454 367H837L828 376Q803 403 785 437T761 489T755 512ZM55 153V173H492Q928 173 932 171Q944 166 944 153T932 135Q928 133 545 133H162L171 124Q198 95 216 61T239 8L244 -12Q244 -14 221 -14H198L195 -4Q160 95 67 146L55 153'],
// LEFTWARDS DOUBLE ARROW WITH STROKE
0x21CD: [535,35,1000,54,942,'397 525Q410 525 414 524T418 516Q418 506 394 467T331 381L319 367H473L624 369L657 445Q674 487 684 507T699 531T709 534Q717 534 722 528T728 516Q728 510 695 434Q689 418 683 402T672 377T668 367H928Q942 355 942 347Q942 341 928 327H791Q651 327 651 325Q649 324 620 251T586 174Q586 172 757 172H928Q942 158 942 152Q942 143 928 132H568L537 54Q510 -9 503 -22T486 -35Q479 -35 473 -29T466 -17T495 61L526 132H319L331 118Q364 81 391 37T418 -17Q418 -23 415 -24T401 -26Q398 -26 397 -26L384 -24L377 -13Q344 49 301 97T218 170T143 210T84 233T55 245Q54 253 59 256T86 267Q281 327 377 512L384 525H397ZM606 325Q606 327 439 327H275Q258 312 179 265L148 249Q228 206 262 181L275 172H544L575 247L606 325'],
// LEFT RIGHT DOUBLE ARROW WITH STROKE
0x21CE: [534,37,1000,32,965,'395 -24T395 -19T417 57T440 132H255L266 116Q308 64 340 -6Q342 -17 337 -21Q335 -26 320 -26T302 -19Q302 -15 294 4T265 54T217 117T145 182T49 236Q30 243 33 254Q40 261 49 263Q98 283 142 315T214 379T263 442T293 493T302 519Q305 525 320 525T337 521Q342 516 340 505Q308 435 266 383L255 370L384 367H515Q561 522 569 530Q574 534 580 534Q587 534 594 528T602 516Q602 512 580 441T557 367H651L742 370L731 383Q689 435 657 505Q655 516 660 521Q662 525 677 525T695 519Q695 515 703 496T732 446T780 383T853 317T949 263Q967 258 964 245Q959 240 949 236Q897 215 852 182T779 116T731 52T703 3T695 -19Q692 -26 677 -26T660 -21Q655 -17 657 -6Q670 21 682 42T702 77T717 99T728 114T735 122T739 126T740 130T613 132H482L460 54Q440 -9 433 -23T415 -37Q408 -37 402 -31ZM502 325Q502 327 360 327H217L195 310Q173 291 120 256L111 250Q114 248 143 229T195 190L217 172H335L453 174L502 325ZM886 250Q885 251 865 263T831 286T802 310L780 327H544L535 299Q531 283 511 223L495 174L637 172H780L802 190Q843 225 877 243L886 250'],
// RIGHTWARDS DOUBLE ARROW WITH STROKE
0x21CF: [534,36,1000,55,943,'346 174Q348 176 378 249T411 325Q411 327 239 327H68Q55 342 55 347Q55 354 68 367H428L459 445Q487 509 494 521T510 534Q517 534 524 527T531 516Q531 515 502 438L471 367H677L666 381Q631 421 605 463T578 516Q578 522 582 523T599 525H615L619 512Q659 437 714 383T812 309T896 272T942 254Q943 246 938 243T911 232Q718 172 619 -13L615 -24L599 -26Q578 -26 578 -17Q578 -11 587 6T617 53T666 118L677 132H373L339 54Q323 12 313 -8T298 -32T288 -35Q280 -35 275 -29T269 -17Q269 -14 298 57T328 132H68Q55 145 55 152Q55 156 56 158T62 165T68 172H206Q346 172 346 174ZM848 249Q763 297 735 318L722 327H455L422 252L391 174Q391 172 557 172H722L735 181Q773 210 819 234L848 249'],
// LEFTWARDS TRIPLE ARROW
0x21DA: [611,111,1000,76,945,'944 54Q942 44 929 36H372Q372 34 377 26T395 -4T422 -58Q442 -109 442 -110T408 -111H374L370 -100Q282 124 87 243L76 250L87 257Q284 377 370 600L374 611H408Q442 611 442 610Q423 550 381 480Q380 478 379 475T376 471T374 468T372 465V464H929Q942 456 944 446Q944 442 943 439T941 434T938 430T935 428T931 426T928 424H344L336 414Q277 336 200 277L191 270H560Q929 270 933 268Q944 262 944 250Q944 237 933 232Q929 230 560 230H191L200 223Q279 162 336 86L344 76H928Q929 76 931 75T934 73T938 70T941 66T943 61T944 54'],
// RIGHTWARDS TRIPLE ARROW
0x21DB: [611,111,1000,55,923,'56 250Q56 260 68 270H808L799 277Q720 338 663 414L655 424H363Q71 424 68 426Q55 432 55 444T68 462Q71 464 349 464H627Q627 466 622 474T604 504T577 558Q557 609 557 610T591 611H626L629 600Q717 376 912 257L923 250L912 243Q715 123 629 -100L626 -111H591Q557 -111 557 -110Q576 -50 618 20Q619 22 620 25T623 29T625 32T626 35L627 36H349Q71 36 68 38Q55 44 55 56T68 74Q71 76 363 76H655L663 86Q722 164 799 223L808 230H438L68 231Q56 236 56 250'],
// RIGHTWARDS SQUIGGLE ARROW
0x21DD: [417,-83,1000,56,943,'76 230Q68 230 62 237T56 250Q56 257 63 264T91 291Q102 300 108 306L159 351Q168 356 177 351L218 316L303 239L353 195Q376 214 403 239L488 316L529 351Q538 356 546 351Q548 350 594 310L638 270H848L841 278Q813 309 792 344T763 396T755 416Q755 417 778 417H801Q817 367 856 323T943 250Q895 221 856 177T801 83H778Q755 83 755 84Q755 86 762 103T791 156T841 222L848 230H737Q625 230 622 232Q620 233 599 251T558 288L537 306Q537 305 451 228T362 149Q353 146 345 149Q341 150 255 227T169 306Q167 306 129 270Q123 265 115 257T102 245T93 237T84 232T76 230'],
// LEFTWARDS DASHED ARROW
0x21E0: [437,-64,1334,64,1251,'292 419Q292 400 261 347T211 275H306H364Q400 275 411 271T422 250T411 230T366 225H306H211Q214 222 232 197T271 136T292 82Q292 71 285 68T262 64H250H241Q221 64 216 67T205 83Q186 127 153 167T78 230Q64 238 64 250Q64 258 69 263T82 272T106 288T139 318Q162 342 177 365T198 402T209 425T223 436Q224 437 252 437H258Q292 437 292 419ZM501 237T501 250T515 270H819Q834 262 834 250T819 230H515Q501 237 501 250ZM918 237T918 250T932 270H1236Q1251 262 1251 250T1236 230H932Q918 237 918 250'],
// RIGHTWARDS DASHED ARROW
0x21E2: [437,-64,1334,84,1251,'84 237T84 250T98 270H402Q417 262 417 250T402 230H98Q84 237 84 250ZM501 237T501 250T515 270H819Q834 262 834 250T819 230H515Q501 237 501 250ZM1022 417Q1022 437 1055 437H1067Q1090 437 1097 434T1109 417Q1128 373 1161 333T1236 270Q1251 261 1251 250Q1251 241 1244 236T1216 217T1175 182Q1149 155 1133 128T1109 85T1097 66Q1093 64 1065 64H1053Q1031 64 1025 72T1027 100Q1036 124 1049 147T1073 185T1091 210T1101 223L1103 225H1008H950Q914 225 903 229T892 250T903 270T948 275H1008H1103L1101 277Q1100 280 1091 291T1067 325T1039 374Q1022 408 1022 417']
}
);
MathJax.Ajax.loadComplete(MathJax.OutputJax.SVG.fontDir+"/AMS/Regular/Arrows.js");

View File

@ -0,0 +1,44 @@
/*************************************************************
*
* MathJax/jax/output/SVG/fonts/TeX/svg/AMS/Regular/BoxDrawing.js
*
* Copyright (c) 2011 Design Science, Inc.
*
* 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.Insert(
MathJax.OutputJax.SVG.FONTDATA.FONTS['MathJax_AMS'],
{
// BOX DRAWINGS LIGHT DOWN AND RIGHT
0x250C: [694,-306,500,55,444,'76 306Q62 306 59 319T55 386V500V596Q55 664 57 676T68 692Q71 694 250 694Q428 694 432 692Q444 685 444 674Q444 665 432 656Q428 654 261 654H95V487Q95 355 95 336T90 312Q84 306 76 306'],
// BOX DRAWINGS LIGHT DOWN AND LEFT
0x2510: [694,-306,500,55,445,'424 306Q418 306 413 310T406 318L404 321V654H238Q71 654 68 656Q55 662 55 674T68 692Q71 694 250 694H379Q432 694 438 688Q443 683 443 662T444 500T444 338T438 312Q432 306 424 306'],
// BOX DRAWINGS LIGHT UP AND RIGHT
0x2514: [366,22,500,55,444,'55 172V287Q55 341 58 353T76 366Q88 366 95 351V18H261Q428 18 432 16Q444 9 444 -2Q444 -11 432 -20Q428 -22 250 -22H120Q67 -22 61 -16Q56 -11 56 10T55 172'],
// BOX DRAWINGS LIGHT UP AND LEFT
0x2518: [366,22,500,55,444,'404 351Q410 366 424 366Q437 366 440 353T444 288V172V72Q444 8 443 -4T432 -20Q428 -22 250 -22Q71 -22 68 -20Q55 -14 55 -2T68 16Q71 18 238 18H404V351'],
// BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT
0x2571: [694,195,889,0,860,'19 -195Q13 -195 7 -188T0 -176Q0 -169 18 -151L822 683Q835 694 840 694T852 688T860 674Q860 667 810 614T460 252Q57 -167 44 -179Q27 -195 19 -195'],
// BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT
0x2572: [694,195,889,0,860,'0 675Q0 681 6 687T19 694Q27 694 44 678L460 247Q759 -62 809 -115T860 -175Q860 -183 852 -189T840 -195Q835 -195 822 -184L18 649Q0 667 0 675']
}
);
MathJax.Ajax.loadComplete(MathJax.OutputJax.SVG.fontDir+"/AMS/Regular/BoxDrawing.js");

View File

@ -0,0 +1,32 @@
/*************************************************************
*
* MathJax/jax/output/SVG/fonts/TeX/svg/AMS/Regular/CombDiacritMarks.js
*
* Copyright (c) 2011 Design Science, Inc.
*
* 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.Insert(
MathJax.OutputJax.SVG.FONTDATA.FONTS['MathJax_AMS'],
{
// COMBINING CIRCUMFLEX ACCENT
0x302: [845,-561,0,-2347,13,'-2332 561Q-2336 563 -2340 577T-2346 604L-2347 618Q-2347 625 -2340 628T-2310 635Q-2302 636 -2297 637Q-2270 641 -1712 745Q-1185 845 -1168 845Q-1166 845 -581 739L5 630Q13 630 13 618Q7 565 -1 561Q-4 561 -584 654Q-716 675 -867 699T-1092 736T-1166 748Q-1168 748 -1240 737T-1466 700T-1750 654Q-2330 561 -2332 561'],
// COMBINING TILDE
0x303: [899,-628,0,-2332,-3,'-1529 788Q-1616 788 -1727 772T-1936 732T-2120 685T-2258 645T-2315 628Q-2322 628 -2322 632Q-2325 637 -2329 668T-2331 704Q-2331 713 -2297 732Q-2278 739 -2091 795Q-1711 898 -1507 898Q-1440 898 -1386 895Q-1324 887 -1277 872T-1146 819Q-1047 776 -977 758T-806 739Q-719 739 -608 755T-399 795T-215 842T-77 882T-20 899Q-13 899 -13 895Q-10 890 -6 860T-4 824Q-4 818 -37 795Q-60 787 -244 732Q-523 657 -735 632Q-771 629 -841 629Q-944 629 -1013 644T-1189 708Q-1285 751 -1356 769T-1529 788']
}
);
MathJax.Ajax.loadComplete(MathJax.OutputJax.SVG.fontDir+"/AMS/Regular/CombDiacritMarks.js");

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