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