Debian Codegraph @

unpacked/jax/input/MathML/jax.js

raw
1 /* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
2 /* vim: set ts=2 et sw=2 tw=80: */
3
4 /*************************************************************
5 *
6 * MathJax/jax/input/MathML/jax.js
7 *
8 * Implements the MathML InputJax that reads mathematics in
9 * MathML format and converts it to the MML ElementJax
10 * internal format.
11 *
12 * ---------------------------------------------------------------------
13 *
14 * Copyright (c) 2010-2020 The MathJax Consortium
15 *
16 * Licensed under the Apache License, Version 2.0 (the "License");
17 * you may not use this file except in compliance with the License.
18 * You may obtain a copy of the License at
19 *
20 * http://www.apache.org/licenses/LICENSE-2.0
21 *
22 * Unless required by applicable law or agreed to in writing, software
23 * distributed under the License is distributed on an "AS IS" BASIS,
24 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25 * See the License for the specific language governing permissions and
26 * limitations under the License.
27 */
28
29 (function (MATHML,BROWSER) {
30 var MML;
31
32 var _ = function (id) {
33 return MathJax.Localization._.apply(MathJax.Localization,
34 [["MathML",id]].concat([].slice.call(arguments,1)))
35 };
36
37 MATHML.Parse = MathJax.Object.Subclass({
38
39 Init: function (string,script) {this.Parse(string,script)},
40
41 //
42 // Parse the MathML and check for errors
43 //
44 Parse: function (math,script) {
45 var doc;
46 if (typeof math !== "string") {doc = math.parentNode} else {
47 doc = MATHML.ParseXML(this.preProcessMath.call(this,math));
48 if (doc == null) {MATHML.Error(["ErrorParsingMathML","Error parsing MathML"])}
49 }
50 var err = doc.getElementsByTagName("parsererror")[0];
51 if (err) MATHML.Error(["ParsingError","Error parsing MathML: %1",
52 err.textContent.replace(/This page.*?errors:|XML Parsing Error: |Below is a rendering of the page.*/g,"")]);
53 if (doc.childNodes.length !== 1)
54 {MATHML.Error(["MathMLSingleElement","MathML must be formed by a single element"])}
55 if (doc.firstChild.nodeName.toLowerCase() === "html") {
56 var h1 = doc.getElementsByTagName("h1")[0];
57 if (h1 && h1.textContent === "XML parsing error" && h1.nextSibling)
58 MATHML.Error(["ParsingError","Error parsing MathML: %1",
59 String(h1.nextSibling.nodeValue).replace(/fatal parsing error: /,"")]);
60 }
61 if (doc.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") !== "math") {
62 MATHML.Error(["MathMLRootElement",
63 "MathML must be formed by a <math> element, not %1",
64 "<"+doc.firstChild.nodeName+">"]);
65 }
66 var data = {math:doc.firstChild, script:script};
67 MATHML.DOMfilterHooks.Execute(data);
68 this.mml = this.MakeMML(data.math);
69 },
70
71 //
72 // Convert the MathML structure to the MathJax Element jax structure
73 //
74 MakeMML: function (node) {
75 var CLASS = String(node.getAttribute("class")||""); // make sure CLASS is a string
76 var mml, type = node.nodeName.toLowerCase().replace(/^[a-z]+:/,"");
77 var match = (CLASS.match(/(^| )MJX-TeXAtom-([^ ]*)/));
78 if (match) {
79 mml = this.TeXAtom(match[2],match[2] === "OP" && !CLASS.match(/MJX-fixedlimits/));
80 } else if (!(MML[type] && MML[type].isa && MML[type].isa(MML.mbase))) {
81 MathJax.Hub.signal.Post(["MathML Jax - unknown node type",type]);
82 return MML.Error(_("UnknownNodeType","Unknown node type: %1",type));
83 } else {
84 mml = MML[type]();
85 }
86 this.AddAttributes(mml,node); this.CheckClass(mml,mml["class"]);
87 this.AddChildren(mml,node);
88 if (MATHML.config.useMathMLspacing) {mml.useMMLspacing = 0x08}
89 return mml;
90 },
91 TeXAtom: function (mclass,movablelimits) {
92 var mml = MML.TeXAtom().With({texClass:MML.TEXCLASS[mclass]});
93 if (movablelimits) {mml.movesupsub = mml.movablelimits = true}
94 return mml;
95 },
96 CheckClass: function (mml,CLASS) {
97 CLASS = (CLASS||"").split(/ /); var NCLASS = [];
98 for (var i = 0, m = CLASS.length; i < m; i++) {
99 if (CLASS[i].substr(0,4) === "MJX-") {
100 if (CLASS[i] === "MJX-arrow") {
101 // This class was used in former versions of MathJax to attach an
102 // arrow to the updiagonalstrike notation. For backward
103 // compatibility, let's continue to accept this case. See issue 481.
104 if (!mml.notation.match("/"+MML.NOTATION.UPDIAGONALARROW+"/"))
105 mml.notation += " "+MML.NOTATION.UPDIAGONALARROW;
106 } else if (CLASS[i] === "MJX-variant") {
107 mml.variantForm = true;
108 //
109 // Variant forms come from AMSsymbols, and it sets up the
110 // character mappings, so load that if needed.
111 //
112 if (!MathJax.Extension["TeX/AMSsymbols"])
113 {MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/AMSsymbols.js"))}
114 } else if (CLASS[i].substr(0,11) !== "MJX-TeXAtom") {
115 mml.mathvariant = CLASS[i].substr(3);
116 //
117 // Caligraphic and oldstyle bold are set up in the boldsymbol
118 // extension, so load it if it isn't already loaded.
119 //
120 if (mml.mathvariant === "-tex-caligraphic-bold" ||
121 mml.mathvariant === "-tex-oldstyle-bold") {
122 if (!MathJax.Extension["TeX/boldsymbol"])
123 {MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/boldsymbol.js"))}
124 }
125 }
126 } else {NCLASS.push(CLASS[i])}
127 }
128 if (NCLASS.length) {mml["class"] = NCLASS.join(" ")} else {delete mml["class"]}
129 },
130
131 //
132 // Add the attributes to the mml node
133 //
134 AddAttributes: function (mml,node) {
135 mml.attr = {}; mml.attrNames = [];
136 for (var i = 0, m = node.attributes.length; i < m; i++) {
137 var name = node.attributes[i].name;
138 if (name == "xlink:href") {name = "href"}
139 if (name.match(/:/)) continue;
140 if (name.match(/^_moz-math-((column|row)(align|line)|font-style)$/)) continue;
141 var value = node.attributes[i].value;
142 value = this.filterAttribute(name,value);
143 var defaults = (mml.type === "mstyle" ? MML.math.prototype.defaults : mml.defaults);
144 if (value != null) {
145 var val = value.toLowerCase();
146 if (val === "true" || val === "false") {
147 if (typeof (defaults[name]) === "boolean" || defaults[name] === MML.INHERIT ||
148 mml.type === "math" || mml.type === "mstyle" ||
149 (defaults[name] === MML.AUTO &&
150 (mml.defaultDef == null || typeof(mml.defaultDef[name]) === "boolean"))) {
151 value = (val === "true");
152 }
153 }
154 if (defaults[name] != null || MML.copyAttributes[name])
155 {mml[name] = value} else {mml.attr[name] = value}
156 mml.attrNames.push(name);
157 }
158 }
159 },
160 filterAttribute: function (name,value) {return value}, // safe mode overrides this
161
162 //
163 // Create the children for the mml node
164 //
165 AddChildren: function (mml,node) {
166 for (var i = 0, m = node.childNodes.length; i < m; i++) {
167 var child = node.childNodes[i];
168 if (child.nodeName === "#comment") continue;
169 if (child.nodeName === "#text") {
170 if ((mml.isToken || mml.isChars) && !mml.mmlSelfClosing) {
171 var text = child.nodeValue;
172 if (mml.isToken) {
173 text = text.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity);
174 text = this.trimSpace(text);
175 }
176 mml.Append(MML.chars(text));
177 } else if (child.nodeValue.match(/\S/)) {
178 MATHML.Error(["UnexpectedTextNode",
179 "Unexpected text node: %1","'"+child.nodeValue+"'"]);
180 }
181 } else if (mml.type === "annotation-xml") {
182 mml.Append(MML.xml(child));
183 } else {
184 var cmml = this.MakeMML(child); mml.Append(cmml);
185 if (cmml.mmlSelfClosing && cmml.data.length)
186 {mml.Append.apply(mml,cmml.data); cmml.data = []}
187 }
188 }
189 if (mml.type === "mrow" && mml.data.length >= 2) {
190 var first = mml.data[0], last = mml.data[mml.data.length-1];
191 if (first.type === "mo" && first.Get("fence") &&
192 last.type === "mo" && last.Get("fence")) {
193 if (first.data[0]) {mml.open = first.data.join("")}
194 if (last.data[0]) {mml.close = last.data.join("")}
195 }
196 }
197 },
198
199 //
200 // Clean Up the <math> source to prepare for XML parsing
201 //
202 preProcessMath: function (math) {
203 if (math.match(/^<[a-z]+:/i) && !math.match(/^<[^<>]* xmlns:/)) {
204 math = math.replace(/^<([a-z]+)(:math)/i,'<$1$2 xmlns:$1="http://www.w3.org/1998/Math/MathML"')
205 }
206 // HTML5 removes xmlns: namespaces, so put them back for XML
207 var match = math.match(/^(<math( ('.*?'|".*?"|[^>])+)>)/i);
208 if (match && match[2].match(/ (?!xmlns=)[a-z]+=\"http:/i)) {
209 math = match[1].replace(/ (?!xmlns=)([a-z]+=(['"])http:.*?\2)/ig," xmlns:$1 $1") +
210 math.substr(match[0].length);
211 }
212 if (math.match(/^<math[ >]/i) && !math.match(/^<[^<>]* xmlns=/)) {
213 // append the MathML namespace
214 math = math.replace(/^<(math)/i,'<math xmlns="http://www.w3.org/1998/Math/MathML"')
215 }
216 math = math.replace(/^\s*(?:\/\/)?<!(--)?\[CDATA\[((.|\n)*)(\/\/)?\]\]\1>\s*$/,"$2");
217 return math.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity);
218 },
219
220 //
221 // Remove attribute whitespace
222 //
223 trimSpace: function (string) {
224 return string.replace(/[\t\n\r]/g," ") // whitespace to spaces
225 .replace(/^ +/,"") // initial whitespace
226 .replace(/ +$/,"") // trailing whitespace
227 .replace(/ +/g," "); // internal multiple whitespace
228 },
229
230 //
231 // Replace a named entity by its value
232 // (look up from external files if necessary)
233 //
234 replaceEntity: function (match,entity) {
235 if (entity.match(/^(lt|amp|quot)$/)) {return match} // these mess up attribute parsing
236 if (MATHML.Parse.Entity[entity]) {return MATHML.Parse.Entity[entity]}
237 var file = entity.charAt(0).toLowerCase();
238 var font = entity.match(/^[a-zA-Z](fr|scr|opf)$/);
239 if (font) {file = font[1]}
240 if (!MATHML.Parse.loaded[file]) {
241 MATHML.Parse.loaded[file] = true;
242 MathJax.Hub.RestartAfter(MathJax.Ajax.Require(MATHML.entityDir+"/"+file+".js"));
243 }
244 return match;
245 }
246 }, {
247 loaded: [] // the entity files that are loaded
248 });
249
250 /************************************************************************/
251
252 MATHML.Augment({
253 sourceMenuTitle: /*_(MathMenu)*/ ["OriginalMathML","Original MathML"],
254
255 prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML string before processing MathML
256 DOMfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML DOM before processing
257 postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on internal jax format after processing MathML
258
259 Translate: function (script) {
260 if (!this.ParseXML) {this.ParseXML = this.createParser()}
261 var mml, math, data = {script:script};
262 if (script.firstChild &&
263 script.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") === "math") {
264 data.math = script.firstChild;
265 } else {
266 math = MathJax.HTML.getScript(script);
267 if (BROWSER.isMSIE) {math = math.replace(/(&nbsp;)+$/,"")}
268 data.math = math;
269 }
270 var callback = this.prefilterHooks.Execute(data); if (callback) return callback;
271 math = data.math;
272 try {
273 mml = MATHML.Parse(math,script).mml;
274 } catch(err) {
275 if (!err.mathmlError) {throw err}
276 mml = this.formatError(err,math,script);
277 }
278 data.math = MML(mml);
279 return this.postfilterHooks.Execute(data) || data.math;
280 },
281 prefilterMath: function (math,script) {return math},
282 prefilterMathML: function (math,script) {return math},
283 formatError: function (err,math,script) {
284 var message = err.message.replace(/\n.*/,"");
285 MathJax.Hub.signal.Post(["MathML Jax - parse error",message,math,script]);
286 return MML.Error(message);
287 },
288 Error: function (message) {
289 //
290 // Translate message if it is ["id","message",args]
291 //
292 if (MathJax.Object.isArray(message)) {message = _.apply(_,message)}
293 throw MathJax.Hub.Insert(Error(message),{mathmlError: true});
294 },
295 //
296 // Parsers for various forms (DOMParser, Windows ActiveX object, other)
297 //
298 parseDOM: function (string) {return this.parser.parseFromString(string,"text/xml")},
299 parseMS: function (string) {return (this.parser.loadXML(string) ? this.parser : null)},
300 parseDIV: function (string) {
301 this.div.innerHTML =
302 "<div>"+string.replace(/<([a-z]+)([^>]*)\/>/g,"<$1$2></$1>")+"</div>";
303 var doc = this.div.firstChild;
304 this.div.innerHTML = "";
305 return doc;
306 },
307 parseError: function (string) {return null},
308 createMSParser: function() {
309 var parser = null;
310 var xml = ["MSXML2.DOMDocument.6.0","MSXML2.DOMDocument.5.0",
311 "MSXML2.DOMDocument.4.0","MSXML2.DOMDocument.3.0",
312 "MSXML2.DOMDocument.2.0","Microsoft.XMLDOM"];
313 for (var i = 0, m = xml.length; i < m && !parser; i++) {
314 try {
315 parser = new ActiveXObject(xml[i])
316 } catch (err) {}
317 }
318 return parser;
319 },
320 //
321 // Create the parser using a DOMParser, or other fallback method
322 //
323 createParser: function () {
324 if (window.DOMParser) {
325 this.parser = new DOMParser();
326 return(this.parseDOM);
327 } else if (window.ActiveXObject) {
328 this.parser = this.createMSParser();
329 if (!this.parser) {
330 MathJax.Localization.Try(this.parserCreationError);
331 return(this.parseError);
332 }
333 this.parser.async = false;
334 return(this.parseMS);
335 }
336 this.div = MathJax.Hub.Insert(document.createElement("div"),{
337 style:{visibility:"hidden", overflow:"hidden", height:"1px",
338 position:"absolute", top:0}
339 });
340 if (!document.body.firstChild) {document.body.appendChild(this.div)}
341 else {document.body.insertBefore(this.div,document.body.firstChild)}
342 return(this.parseDIV);
343 },
344 parserCreationError: function () {
345 alert(_("CantCreateXMLParser",
346 "MathJax can't create an XML parser for MathML. Check that\n"+
347 "the 'Script ActiveX controls marked safe for scripting' security\n"+
348 "setting is enabled (use the Internet Options item in the Tools\n"+
349 "menu, and select the Security panel, then press the Custom Level\n"+
350 "button to check this).\n\n"+
351 "MathML equations will not be able to be processed by MathJax."));
352 },
353 //
354 // Initialize the parser object (whichever type is used)
355 //
356 Startup: function () {
357 MML = MathJax.ElementJax.mml;
358 MML.mspace.Augment({mmlSelfClosing: true});
359 MML.none.Augment({mmlSelfClosing: true});
360 MML.mprescripts.Augment({mmlSelfClosing:true});
361 MML.maligngroup.Augment({mmlSelfClosing:true});
362 MML.malignmark.Augment({mmlSelfClosing:true});
363 }
364 });
365
366 //
367 // Add the default pre-filter (for backward compatibility)
368 //
369 MATHML.prefilterHooks.Add(function (data) {
370 data.math = (typeof(data.math) === "string" ?
371 MATHML.prefilterMath(data.math,data.script) :
372 MATHML.prefilterMathML(data.math,data.script));
373 });
374
375 MATHML.Parse.Entity = {
376 ApplyFunction: '\u2061',
377 Backslash: '\u2216',
378 Because: '\u2235',
379 Breve: '\u02D8',
380 Cap: '\u22D2',
381 CenterDot: '\u00B7',
382 CircleDot: '\u2299',
383 CircleMinus: '\u2296',
384 CirclePlus: '\u2295',
385 CircleTimes: '\u2297',
386 Congruent: '\u2261',
387 ContourIntegral: '\u222E',
388 Coproduct: '\u2210',
389 Cross: '\u2A2F',
390 Cup: '\u22D3',
391 CupCap: '\u224D',
392 Dagger: '\u2021',
393 Del: '\u2207',
394 Delta: '\u0394',
395 Diamond: '\u22C4',
396 DifferentialD: '\u2146',
397 DotEqual: '\u2250',
398 DoubleDot: '\u00A8',
399 DoubleRightTee: '\u22A8',
400 DoubleVerticalBar: '\u2225',
401 DownArrow: '\u2193',
402 DownLeftVector: '\u21BD',
403 DownRightVector: '\u21C1',
404 DownTee: '\u22A4',
405 Downarrow: '\u21D3',
406 Element: '\u2208',
407 EqualTilde: '\u2242',
408 Equilibrium: '\u21CC',
409 Exists: '\u2203',
410 ExponentialE: '\u2147',
411 FilledVerySmallSquare: '\u25AA',
412 ForAll: '\u2200',
413 Gamma: '\u0393',
414 Gg: '\u22D9',
415 GreaterEqual: '\u2265',
416 GreaterEqualLess: '\u22DB',
417 GreaterFullEqual: '\u2267',
418 GreaterLess: '\u2277',
419 GreaterSlantEqual: '\u2A7E',
420 GreaterTilde: '\u2273',
421 Hacek: '\u02C7',
422 Hat: '\u005E',
423 HumpDownHump: '\u224E',
424 HumpEqual: '\u224F',
425 Im: '\u2111',
426 ImaginaryI: '\u2148',
427 Integral: '\u222B',
428 Intersection: '\u22C2',
429 InvisibleComma: '\u2063',
430 InvisibleTimes: '\u2062',
431 Lambda: '\u039B',
432 Larr: '\u219E',
433 LeftAngleBracket: '\u27E8',
434 LeftArrow: '\u2190',
435 LeftArrowRightArrow: '\u21C6',
436 LeftCeiling: '\u2308',
437 LeftDownVector: '\u21C3',
438 LeftFloor: '\u230A',
439 LeftRightArrow: '\u2194',
440 LeftTee: '\u22A3',
441 LeftTriangle: '\u22B2',
442 LeftTriangleEqual: '\u22B4',
443 LeftUpVector: '\u21BF',
444 LeftVector: '\u21BC',
445 Leftarrow: '\u21D0',
446 Leftrightarrow: '\u21D4',
447 LessEqualGreater: '\u22DA',
448 LessFullEqual: '\u2266',
449 LessGreater: '\u2276',
450 LessSlantEqual: '\u2A7D',
451 LessTilde: '\u2272',
452 Ll: '\u22D8',
453 Lleftarrow: '\u21DA',
454 LongLeftArrow: '\u27F5',
455 LongLeftRightArrow: '\u27F7',
456 LongRightArrow: '\u27F6',
457 Longleftarrow: '\u27F8',
458 Longleftrightarrow: '\u27FA',
459 Longrightarrow: '\u27F9',
460 Lsh: '\u21B0',
461 MinusPlus: '\u2213',
462 NestedGreaterGreater: '\u226B',
463 NestedLessLess: '\u226A',
464 NotDoubleVerticalBar: '\u2226',
465 NotElement: '\u2209',
466 NotEqual: '\u2260',
467 NotExists: '\u2204',
468 NotGreater: '\u226F',
469 NotGreaterEqual: '\u2271',
470 NotLeftTriangle: '\u22EA',
471 NotLeftTriangleEqual: '\u22EC',
472 NotLess: '\u226E',
473 NotLessEqual: '\u2270',
474 NotPrecedes: '\u2280',
475 NotPrecedesSlantEqual: '\u22E0',
476 NotRightTriangle: '\u22EB',
477 NotRightTriangleEqual: '\u22ED',
478 NotSubsetEqual: '\u2288',
479 NotSucceeds: '\u2281',
480 NotSucceedsSlantEqual: '\u22E1',
481 NotSupersetEqual: '\u2289',
482 NotTilde: '\u2241',
483 NotVerticalBar: '\u2224',
484 Omega: '\u03A9',
485 OverBar: '\u203E',
486 OverBrace: '\u23DE',
487 PartialD: '\u2202',
488 Phi: '\u03A6',
489 Pi: '\u03A0',
490 PlusMinus: '\u00B1',
491 Precedes: '\u227A',
492 PrecedesEqual: '\u2AAF',
493 PrecedesSlantEqual: '\u227C',
494 PrecedesTilde: '\u227E',
495 Product: '\u220F',
496 Proportional: '\u221D',
497 Psi: '\u03A8',
498 Rarr: '\u21A0',
499 Re: '\u211C',
500 ReverseEquilibrium: '\u21CB',
501 RightAngleBracket: '\u27E9',
502 RightArrow: '\u2192',
503 RightArrowLeftArrow: '\u21C4',
504 RightCeiling: '\u2309',
505 RightDownVector: '\u21C2',
506 RightFloor: '\u230B',
507 RightTee: '\u22A2',
508 RightTeeArrow: '\u21A6',
509 RightTriangle: '\u22B3',
510 RightTriangleEqual: '\u22B5',
511 RightUpVector: '\u21BE',
512 RightVector: '\u21C0',
513 Rightarrow: '\u21D2',
514 Rrightarrow: '\u21DB',
515 Rsh: '\u21B1',
516 Sigma: '\u03A3',
517 SmallCircle: '\u2218',
518 Sqrt: '\u221A',
519 Square: '\u25A1',
520 SquareIntersection: '\u2293',
521 SquareSubset: '\u228F',
522 SquareSubsetEqual: '\u2291',
523 SquareSuperset: '\u2290',
524 SquareSupersetEqual: '\u2292',
525 SquareUnion: '\u2294',
526 Star: '\u22C6',
527 Subset: '\u22D0',
528 SubsetEqual: '\u2286',
529 Succeeds: '\u227B',
530 SucceedsEqual: '\u2AB0',
531 SucceedsSlantEqual: '\u227D',
532 SucceedsTilde: '\u227F',
533 SuchThat: '\u220B',
534 Sum: '\u2211',
535 Superset: '\u2283',
536 SupersetEqual: '\u2287',
537 Supset: '\u22D1',
538 Therefore: '\u2234',
539 Theta: '\u0398',
540 Tilde: '\u223C',
541 TildeEqual: '\u2243',
542 TildeFullEqual: '\u2245',
543 TildeTilde: '\u2248',
544 UnderBar: '\u005F',
545 UnderBrace: '\u23DF',
546 Union: '\u22C3',
547 UnionPlus: '\u228E',
548 UpArrow: '\u2191',
549 UpDownArrow: '\u2195',
550 UpTee: '\u22A5',
551 Uparrow: '\u21D1',
552 Updownarrow: '\u21D5',
553 Upsilon: '\u03A5',
554 Vdash: '\u22A9',
555 Vee: '\u22C1',
556 VerticalBar: '\u2223',
557 VerticalTilde: '\u2240',
558 Vvdash: '\u22AA',
559 Wedge: '\u22C0',
560 Xi: '\u039E',
561 acute: '\u00B4',
562 aleph: '\u2135',
563 alpha: '\u03B1',
564 amalg: '\u2A3F',
565 and: '\u2227',
566 ang: '\u2220',
567 angmsd: '\u2221',
568 angsph: '\u2222',
569 ape: '\u224A',
570 backprime: '\u2035',
571 backsim: '\u223D',
572 backsimeq: '\u22CD',
573 beta: '\u03B2',
574 beth: '\u2136',
575 between: '\u226C',
576 bigcirc: '\u25EF',
577 bigodot: '\u2A00',
578 bigoplus: '\u2A01',
579 bigotimes: '\u2A02',
580 bigsqcup: '\u2A06',
581 bigstar: '\u2605',
582 bigtriangledown: '\u25BD',
583 bigtriangleup: '\u25B3',
584 biguplus: '\u2A04',
585 blacklozenge: '\u29EB',
586 blacktriangle: '\u25B4',
587 blacktriangledown: '\u25BE',
588 blacktriangleleft: '\u25C2',
589 bowtie: '\u22C8',
590 boxdl: '\u2510',
591 boxdr: '\u250C',
592 boxminus: '\u229F',
593 boxplus: '\u229E',
594 boxtimes: '\u22A0',
595 boxul: '\u2518',
596 boxur: '\u2514',
597 bsol: '\u005C',
598 bull: '\u2022',
599 cap: '\u2229',
600 check: '\u2713',
601 chi: '\u03C7',
602 circ: '\u02C6',
603 circeq: '\u2257',
604 circlearrowleft: '\u21BA',
605 circlearrowright: '\u21BB',
606 circledR: '\u00AE',
607 circledS: '\u24C8',
608 circledast: '\u229B',
609 circledcirc: '\u229A',
610 circleddash: '\u229D',
611 clubs: '\u2663',
612 colon: '\u003A',
613 comp: '\u2201',
614 ctdot: '\u22EF',
615 cuepr: '\u22DE',
616 cuesc: '\u22DF',
617 cularr: '\u21B6',
618 cup: '\u222A',
619 curarr: '\u21B7',
620 curlyvee: '\u22CE',
621 curlywedge: '\u22CF',
622 dagger: '\u2020',
623 daleth: '\u2138',
624 ddarr: '\u21CA',
625 deg: '\u00B0',
626 delta: '\u03B4',
627 digamma: '\u03DD',
628 div: '\u00F7',
629 divideontimes: '\u22C7',
630 dot: '\u02D9',
631 doteqdot: '\u2251',
632 dotplus: '\u2214',
633 dotsquare: '\u22A1',
634 dtdot: '\u22F1',
635 ecir: '\u2256',
636 efDot: '\u2252',
637 egs: '\u2A96',
638 ell: '\u2113',
639 els: '\u2A95',
640 empty: '\u2205',
641 epsi: '\u03B5',
642 epsiv: '\u03F5',
643 erDot: '\u2253',
644 eta: '\u03B7',
645 eth: '\u00F0',
646 flat: '\u266D',
647 fork: '\u22D4',
648 frown: '\u2322',
649 gEl: '\u2A8C',
650 gamma: '\u03B3',
651 gap: '\u2A86',
652 gimel: '\u2137',
653 gnE: '\u2269',
654 gnap: '\u2A8A',
655 gne: '\u2A88',
656 gnsim: '\u22E7',
657 gt: '\u003E',
658 gtdot: '\u22D7',
659 harrw: '\u21AD',
660 hbar: '\u210F',
661 hellip: '\u2026',
662 hookleftarrow: '\u21A9',
663 hookrightarrow: '\u21AA',
664 imath: '\u0131',
665 infin: '\u221E',
666 intcal: '\u22BA',
667 iota: '\u03B9',
668 jmath: '\u0237',
669 kappa: '\u03BA',
670 kappav: '\u03F0',
671 lEg: '\u2A8B',
672 lambda: '\u03BB',
673 lap: '\u2A85',
674 larrlp: '\u21AB',
675 larrtl: '\u21A2',
676 lbrace: '\u007B',
677 lbrack: '\u005B',
678 le: '\u2264',
679 leftleftarrows: '\u21C7',
680 leftthreetimes: '\u22CB',
681 lessdot: '\u22D6',
682 lmoust: '\u23B0',
683 lnE: '\u2268',
684 lnap: '\u2A89',
685 lne: '\u2A87',
686 lnsim: '\u22E6',
687 longmapsto: '\u27FC',
688 looparrowright: '\u21AC',
689 lowast: '\u2217',
690 loz: '\u25CA',
691 lt: '\u003C',
692 ltimes: '\u22C9',
693 ltri: '\u25C3',
694 macr: '\u00AF',
695 malt: '\u2720',
696 mho: '\u2127',
697 mu: '\u03BC',
698 multimap: '\u22B8',
699 nLeftarrow: '\u21CD',
700 nLeftrightarrow: '\u21CE',
701 nRightarrow: '\u21CF',
702 nVDash: '\u22AF',
703 nVdash: '\u22AE',
704 natur: '\u266E',
705 nearr: '\u2197',
706 nharr: '\u21AE',
707 nlarr: '\u219A',
708 not: '\u00AC',
709 nrarr: '\u219B',
710 nu: '\u03BD',
711 nvDash: '\u22AD',
712 nvdash: '\u22AC',
713 nwarr: '\u2196',
714 omega: '\u03C9',
715 omicron: '\u03BF',
716 or: '\u2228',
717 osol: '\u2298',
718 period: '\u002E',
719 phi: '\u03C6',
720 phiv: '\u03D5',
721 pi: '\u03C0',
722 piv: '\u03D6',
723 prap: '\u2AB7',
724 precnapprox: '\u2AB9',
725 precneqq: '\u2AB5',
726 precnsim: '\u22E8',
727 prime: '\u2032',
728 psi: '\u03C8',
729 rarrtl: '\u21A3',
730 rbrace: '\u007D',
731 rbrack: '\u005D',
732 rho: '\u03C1',
733 rhov: '\u03F1',
734 rightrightarrows: '\u21C9',
735 rightthreetimes: '\u22CC',
736 ring: '\u02DA',
737 rmoust: '\u23B1',
738 rtimes: '\u22CA',
739 rtri: '\u25B9',
740 scap: '\u2AB8',
741 scnE: '\u2AB6',
742 scnap: '\u2ABA',
743 scnsim: '\u22E9',
744 sdot: '\u22C5',
745 searr: '\u2198',
746 sect: '\u00A7',
747 sharp: '\u266F',
748 sigma: '\u03C3',
749 sigmav: '\u03C2',
750 simne: '\u2246',
751 smile: '\u2323',
752 spades: '\u2660',
753 sub: '\u2282',
754 subE: '\u2AC5',
755 subnE: '\u2ACB',
756 subne: '\u228A',
757 supE: '\u2AC6',
758 supnE: '\u2ACC',
759 supne: '\u228B',
760 swarr: '\u2199',
761 tau: '\u03C4',
762 theta: '\u03B8',
763 thetav: '\u03D1',
764 tilde: '\u02DC',
765 times: '\u00D7',
766 triangle: '\u25B5',
767 triangleq: '\u225C',
768 upsi: '\u03C5',
769 upuparrows: '\u21C8',
770 veebar: '\u22BB',
771 vellip: '\u22EE',
772 weierp: '\u2118',
773 xi: '\u03BE',
774 yen: '\u00A5',
775 zeta: '\u03B6',
776 zigrarr: '\u21DD'
777 };
778
779 MATHML.loadComplete("jax.js");
780
781 })(MathJax.InputJax.MathML,MathJax.Hub.Browser);