PEG
/
PEG-Wiki
10
1
Fork 0
Code Releases Wiki Activity
PEG-Wiki/javascript/MathJax/jax/element/mml/jax.js

1475 lines
50 KiB
JavaScript
Raw Blame History

/*************************************************************
*
* MathJax/jax/element/mml/jax.js
*
* Implements the MML ElementJax that holds the internal represetation
* of the mathematics on the page. Various InputJax will produce this
* format, and the OutputJax will display it in various formats.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009 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.ElementJax.mml = MathJax.ElementJax.Subclass({
mimeType: "jax/mml"
},{
name: "mml",
version: 1.0,
directory: MathJax.ElementJax.directory + "/mml",
extensionDir: MathJax.ElementJax.extensionDir + "/mml",
optableDir: MathJax.ElementJax.directory + "/mml/optable"
});
MathJax.ElementJax.mml.Augment({
Init: function () {
if (arguments.length === 1 && arguments[0].type === "math") {this.root = arguments[0]}
else {this.root = MathJax.ElementJax.mml.math.apply(this,arguments)}
if (this.root.mode) {
if (!this.root.display && this.root.mode === "display") {this.root.display = "block"}
delete this.root.mode;
}
}
},{
INHERIT: "_inherit_",
AUTO: "_auto_",
SIZE: {
INFINITY: "infinity",
SMALL: "small",
NORMAL: "normal",
BIG: "big"
},
COLOR: {
TRANSPARENT: "transparent"
},
VARIANT: {
NORMAL: "normal",
BOLD: "bold",
ITALIC: "italic",
BOLDITALIC: "bold-italic",
DOUBLESTRUCK: "double-struck",
FRAKTUR: "fraktur",
BOLDFRAKTUR: "bold-fraktur",
SCRIPT: "script",
BOLDSCRIPT: "bold-script",
SANSSERIF: "sans-serif",
BOLDSANSSERIF: "bold-sans-serif",
SANSSERIFITALIC: "sans-serif-italic",
SANSSERIFBOLDITALIC: "sans-serif-bold-italic",
MONOSPACE: "monospace",
INITIAL: "inital",
TAILED: "tailed",
LOOPED: "looped",
STRETCHED: "stretched",
CALIGRAPHIC: "-tex-caligraphic",
OLDSTYLE: "-tex-oldstyle"
},
FORM: {
PREFIX: "prefix",
INFIX: "infix",
POSTFIX: "postfix"
},
LINEBREAK: {
AUTO: "auto",
NEWLINE: "newline",
NOBREAK: "nobreak",
GOODBREAK: "goodbreak",
BADBREAK: "badbreak"
},
LINEBREAKSTYLE: {
BEFORE: "before",
AFTER: "after",
DUPLICATE: "duplicate",
INFIXLINBREAKSTYLE: "infixlinebreakstyle"
},
INDENTSTYLE: {
LEFT: "left",
CENTER: "center",
RIGHT: "right",
AUTO: "auto",
ID: "id",
INDENTSTYLE: "indentstyle"
},
INDENTOFFSET: {
INDENTOFFSET: "indentoffset"
},
LINETHICKNESS: {
THIN: "thin",
MEDIUM: "medium",
THICK: "thick"
},
NOTATION: {
LONGDIV: "longdiv",
ACTUARIAL: "actuarial",
RADICAL: "radical",
BOX: "box",
ROUNDEDBOX: "roundedbox",
CIRCLE: "circle",
LEFT: "left",
RIGHT: "right",
TOP: "top",
BOTTOM: "bottom",
UPDIAGONALSTRIKE: "updiagonalstrike",
DOWNDIAGONALSTRIKE: "downdiagonalstrike",
VERTICALSTRIKE: "verticalstrike",
HORIZONTALSTRIKE: "horizontalstrike",
MADRUWB: "madruwb"
},
ALIGN: {
TOP: "top",
BOTTOM: "bottom",
CENTER: "center",
BASELINE: "baseline",
AXIS: "axis",
LEFT: "left",
RIGHT: "right"
},
LINES: {
NONE: "none",
SOLID: "solid",
DASHED: "dashed"
},
SIDE: {
LEFT: "left",
RIGHT: "right",
LEFTOVERLAP: "leftoverlap",
RIGHTOVERLAP: "rightoverlap"
},
WIDTH: {
AUTO: "auto",
FIT: "fit"
},
ACTIONTYPE: {
TOGGLE: "toggle",
STATUSLINE: "statusline",
TOOLTIP: "tooltip",
INPUT: "input"
},
LENGTH: {
VERYVERYTHINMATHSPACE: "veryverythinmathspace",
VERYTHINMATHSPACE: "verythinmathspace",
THINMATHSPACE: "thinmathspace",
MEDIUMMATHSPACE: "mediummathspace",
THICKMATHSPACE: "thickmathspace",
VERYTHICKMATHSPACE: "verythickmathspace",
VERYVERYTHICKMATHSPACE: "veryverythickmathspace",
NEGATIVEVERYVERYTHINMATHSPACE: "negativeveryverythinmathspace",
NEGATIVEVERYTHINMATHSPACE: "negativeverythinmathspace",
NEGATIVETHINMATHSPACE: "negativethinmathspace",
NEGATIVEMEDIUMMATHSPACE: "negativemediummathspace",
NEGATIVETHICKMATHSPACE: "negativethickmathspace",
NEGATIVEVERYTHICKMATHSPACE: "negativeverythickmathspace",
NEGATIVEVERYVERYTHICKMATHSPACE: "negativeveryverythickmathspace"
},
OVERFLOW: {
LINBREAK: "linebreak",
SCROLL: "scroll",
ELIDE: "elide",
TRUNCATE: "truncate",
SCALE: "scale"
},
UNIT: {
EM: "em",
EX: "ex",
PX: "px",
IN: "in",
CM: "cm",
MM: "mm",
PT: "pt",
PC: "pc"
},
TEXCLASS: {
ORD: 0,
OP: 1,
BIN: 2,
REL: 3,
OPEN: 4,
CLOSE: 5,
PUNCT: 6,
INNER: 7,
VCENTER: 8,
NONE: -1
},
PLANE1: String.fromCharCode(0xD835)
});
(function (MML) {
var FALSE = false; var TRUE = true;
MML.mbase = MathJax.Object.Subclass({
type: "base", isToken: FALSE,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT
},
noInherit: {},
Init: function () {
this.data = [];
if (this.inferRow && !(arguments.length === 1 && arguments[0].inferred))
{this.Append(MML.mrow().With({inferred: TRUE}))}
this.Append.apply(this,arguments);
},
With: function (def) {
for (var id in def) {if (def.hasOwnProperty(id)) {this[id] = def[id]}}
return this;
},
Append: function () {
if (this.inferRow && this.data.length) {
this.data[0].Append.apply(this.data[0],arguments);
} else {
for (var i = 0, m = arguments.length; i < m; i++)
{this.SetData(this.data.length,arguments[i])}
}
},
SetData: function (i,item) {
if (item != null) {
if (!(item instanceof MML.mbase))
{item = (this.isToken ? MML.chars(item) : MML.mtext(item))}
item.parent = this;
item.setInherit(this.inheritFromMe ? this : this.inherit);
}
this.data[i] = item;
},
Parent: function () {
var parent = this.parent;
while (parent && parent.inferred) {parent = parent.parent}
return parent;
},
Get: function (name,nodefault) {
if (typeof(this[name]) !== "undefined") {return this[name]}
// FIXME: should cache these values and get from cache
// (clear cache when appended to a new object?)
var parent = this.Parent();
if (parent && parent["adjustChild_"+name] != null)
{return (parent["adjustChild_"+name])(parent.childPosition(this))}
var obj = this.inherit; var root = obj;
while (obj) {
if (typeof(obj[name]) !== "undefined") {
var noInherit = obj.noInherit[this.type];
if (!(noInherit && noInherit[name])) {return obj[name]}
}
root = obj; obj = obj.inherit;
}
if (!nodefault) {
if (this.defaults[name] === MML.AUTO) {return this.autoDefault(name)}
if (this.defaults[name] !== MML.INHERIT && this.defaults[name] != null)
{return this.defaults[name]}
if (root) {return root.defaults[name]}
}
return null;
},
hasValue: function (name) {return (this.Get(name,true) != null)},
getValues: function () {
var values = {};
for (var i = 0, m = arguments.length; i < m; i++)
{values[arguments[i]] = this.Get(arguments[i])}
return values;
},
adjustChild_scriptlevel: function (i) {return this.Get("scriptlevel")}, // always inherit from parent
adjustChild_displaystyle: function (i) {return this.Get("displaystyle")}, // always inherit from parent
adjustChild_texprimestyle: function (i) {return this.Get("texprimestyle")}, // always inherit from parent
childPosition: function (child) {
if (child.parent.inferred) {child = child.parent}
for (var i = 0, m = this.data.length; i < m; i++) {if (this.data[i] === child) {return i}}
return null;
},
setInherit: function (obj) {
if (obj !== this.inherit && this.inherit == null) {
this.inherit = obj;
for (var i = 0, m = this.data.length; i < m; i++) {
if (this.data[i] && this.data[i].setInherit) {this.data[i].setInherit(obj)}
}
}
},
setTeXclass: function (prev) {
this.getPrevClass(prev);
return (typeof(this.texClass) !== "undefined" ? this : prev);
},
getPrevClass: function (prev) {
if (prev) {
this.prevClass = prev.Get("texClass");
this.prevLevel = prev.Get("scriptlevel");
}
},
updateTeXclass: function (core) {
if (core) {
this.prevClass = core.prevClass; delete core.prevClass;
this.prevLevel = core.prevLevel; delete core.prevLevel;
this.texClass = core.Get("texClass");
}
},
texSpacing: function () {
var prev = (this.prevClass != null ? this.prevClass : MML.TEXCLASS.NONE);
var tex = (this.Get("texClass") || MML.TEXCLASS.ORD);
if (prev === MML.TEXCLASS.NONE || tex === MML.TEXCLASS.NONE) {return ""}
if (prev === MML.TEXCLASS.VCENTER) {prev = MML.TEXCLASS.ORD}
if (tex === MML.TEXCLASS.VCENTER) {tex = MML.TEXCLASS.ORD}
var space = this.TEXSPACE[prev][tex];
if (this.prevLevel > 0 && this.Get("scriptlevel") > 0 && space >= 0) {return ""}
return this.TEXSPACELENGTH[Math.abs(space)];
},
TEXSPACELENGTH:[
"",
MML.LENGTH.THINMATHSPACE,
MML.LENGTH.MEDIUMMATHSPACE,
MML.LENGTH.THICKMATHSPACE
],
// See TeXBook Chapter 18 (p. 170)
TEXSPACE: [
[ 0,-1, 2, 3, 0, 0, 0, 1], // ORD
[-1,-1, 0, 3, 0, 0, 0, 1], // OP
[ 2, 2, 0, 0, 2, 0, 0, 2], // BIN
[ 3, 3, 0, 0, 3, 0, 0, 3], // REL
[ 0, 0, 0, 0, 0, 0, 0, 0], // OPEN
[ 0,-1, 2, 3, 0, 0, 0, 1], // CLOSE
[ 1, 1, 0, 1, 1, 1, 1, 1], // PUNCT
[ 1,-1, 2, 3, 1, 0, 1, 1] // INNER
],
autoDefault: function (name) {return ""},
isSpacelike: function () {return FALSE},
isEmbellished: function () {return FALSE},
Core: function () {return this},
CoreMO: function () {return this},
array: function () {if (this.inferred) {return this.data} else {return [this]}},
toString: function () {return this.type+"("+this.data.join(",")+")"}
},{
childrenSpacelike: function () {
for (var i = 0; i < this.data.length; i++) {
if (!this.data[i].isSpacelike()) {return FALSE}
}
return TRUE;
},
childEmbellished: function () {
if (this.data.length === 0) {return FALSE}
return this.data[0].isEmbellished();
},
childCore: function () {return this.data[0]},
childCoreMO: function () {return this.data[0].CoreMO()},
setChildTeXclass: function (prev) {
prev = this.data[0].setTeXclass(prev);
this.updateTeXclass(this.data[0]);
return prev;
},
setBaseTeXclasses: function (prev) {
this.getPrevClass(prev); this.texClass = null;
if (this.isEmbellished()) {
prev = this.data[0].setTeXclass(prev);
this.updateTeXclass(this.Core());
} else {this.data[0].setTeXclass(); prev = this}
for (var i = 1, m = this.data.length; i < m; i++)
{if (this.data[i]) {this.data[i].setTeXclass()}}
return prev;
},
setSeparateTeXclasses: function (prev) {
this.getPrevClass(prev);
for (var i = 0, m = this.data.length; i < m; i++)
{if (this.data[i]) {this.data[i].setTeXclass()}}
if (this.isEmbellished()) {this.updateTeXclass(this.Core())}
return this;
}
});
MML.mi = MML.mbase.Subclass({
type: "mi", isToken: TRUE,
texClass: MML.TEXCLASS.ORD,
defaults: {
mathvariant: MML.AUTO,
mathsize: MML.INHERIT,
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT
},
autoDefault: function (name) {
if (name === "mathvariant") {
var mi = (this.data[0]||"").toString();
return (mi.length === 1 || (mi.length === 2 && mi.charCodeAt(0) === this.PLANE1) ?
MML.VARIANT.ITALIC : MML.VARIANT.NORMAL);
}
return "";
}
});
MML.mn = MML.mbase.Subclass({
type: "mn", isToken: TRUE,
texClass: MML.TEXCLASS.ORD,
defaults: {
mathvariant: MML.INHERIT,
mathsize: MML.INHERIT,
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT
}
});
MML.mo = MML.mbase.Subclass({
type: "mo", isToken: TRUE,
defaults: {
mathvariant: MML.INHERIT,
mathsize: MML.INHERIT,
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
form: MML.AUTO,
fence: MML.AUTO,
separator: MML.AUTO,
lspace: MML.AUTO,
rspace: MML.AUTO,
stretchy: MML.AUTO,
symmetric: MML.AUTO,
maxsize: MML.AUTO,
minsize: MML.AUTO,
largeop: MML.AUTO,
movablelimits: MML.AUTO,
accent: MML.AUTO,
linebreak: MML.AUTO,
lineleading: MML.INHERIT,
linebreakstyle: MML.AUTO,
linebreakmultchar: MML.INHERIT,
indentstyle: MML.INHERIT,
indentoffset: MML.INHERIT,
indenttarget: MML.INHERIT,
indentstylefirst: MML.INHERIT,
indentoffsetfirst: MML.INHERIT,
indentstylelast: MML.INHERIT,
indentoffsetlast: MML.INHERIT,
texClass: MML.AUTO
},
defaultDef: {
form: MML.FORM.INFIX,
fence: FALSE,
separator: FALSE,
lspace: MML.LENGTH.THICKMATHSPACE,
rspace: MML.LENGTH.THICKMATHSPACE,
stretchy: FALSE,
symmetric: TRUE,
maxsize: MML.SIZE.INFINITY,
minsize: '0em', //'1em',
largeop: FALSE,
movablelimits: FALSE,
accent: FALSE,
texClass: MML.TEXCLASS.REL // for MML, but TeX sets ORD explicitly
},
SPACE_ATTR: {lspace: 0x01, rspace: 0x02, form: 0x04},
useMMLspacing: 0x07,
autoDefault: function (name,nodefault) {
var def = this.def;
if (!def) {
if (name === "form") {this.useMMLspacing &= ~this.SPACE_ATTR.form; return this.getForm()}
var mo = this.data.join("");
var forms = [this.Get("form"),MML.FORM.INFIX,MML.FORM.POSTFIX,MML.FORM.PREFIX];
for (var i = 0, m = forms.length; i < m; i++) {
var data = this.OPTABLE[forms[i]][mo];
if (data) {def = this.makeDef(data); break}
}
if (!def) {def = this.CheckRange(mo)}
if (!def && nodefault) {def = {}} else {
if (!def) {def = MathJax.Hub.Insert({},this.defaultDef)}
def.form = forms[0];
this.def = def;
}
}
this.useMMLspacing &= ~(this.SPACE_ATTR[name] || 0);
if (def[name] != null) {return def[name]}
else if (!nodefault) {return this.defaultDef[name]}
return "";
},
CheckRange: function (mo) {
var n = mo.charCodeAt(0);
if (mo.charAt(0) === MML.PLANE1) {n = mo.charCodeAt(1) + 0x1D400 - 0xDC00}
for (var i = 0, m = this.RANGES.length; i < m && this.RANGES[i][0] <= n; i++) {
if (n <= this.RANGES[i][1]) {
if (this.RANGES[i][3]) {
var file = MML.optableDir+"/"+this.RANGES[i][3]+".js";
this.RANGES[i][3] = null;
MathJax.Hub.RestartAfter(MathJax.Ajax.Require(file));
}
var data = (["ORD","OP","BIN","REL","OPEN","CLOSE","PUNCT","INNER"])[this.RANGES[i][2]];
data = this.OPTABLE.infix[mo] = MML.mo.OPTYPES[data === "BIN" ? "BIN3" : data];
return this.makeDef(data);
}
}
return null;
},
makeDef: function (data) {
if (data[2] == null) {data[2] = this.defaultDef.texClass}
if (!data[3]) {data[3] = {}}
var def = MathJax.Hub.Insert({},data[3]);
def.lspace = this.SPACE[data[0]]; def.rspace = this.SPACE[data[1]];
def.texClass = data[2];
return def;
},
getForm: function () {
var i, core = this, parent = this.parent, Parent = this.Parent();
while (Parent && Parent.isEmbellished())
{core = parent; parent = Parent.parent; Parent = Parent.Parent()}
if (parent && parent.type === "mrow" && parent.NonSpaceLength() !== 1) {
if (parent.FirstNonSpace() === core) {return MML.FORM.PREFIX}
if (parent.LastNonSpace() === core) {return MML.FORM.POSTFIX}
}
return MML.FORM.INFIX;
},
isEmbellished: function () {return TRUE},
setTeXclass: function (prev) {
this.getValues("lspace","rspace"); // sets useMMLspacing
if (this.useMMLspacing) {this.texClass = MML.TEXCLASS.NONE; return this}
this.texClass = this.Get("texClass");
if (prev) {this.prevClass = prev.texClass || MML.TEXCLASS.ORD; this.prevLevel = prev.Get("scriptlevel")}
else {this.prevClass = MML.TEXCLASS.NONE}
if (this.texClass === MML.TEXCLASS.BIN &&
(this.prevClass === MML.TEXCLASS.NONE ||
this.prevClass === MML.TEXCLASS.BIN ||
this.prevClass === MML.TEXCLASS.OP ||
this.prevClass === MML.TEXCLASS.REL ||
this.prevClass === MML.TEXCLASS.OPEN ||
this.prevClass === MML.TEXCLASS.PUNCT)) {
this.texClass = MML.TEXCLASS.ORD;
} else if (this.prevClass === MML.TEXCLASS.BIN &&
(this.texClass === MML.TEXCLASS.REL ||
this.texClass === MML.TEXCLASS.CLOSE ||
this.texClass === MML.TEXCLASS.PUNCT)) {
prev.texClass = this.prevClass = MML.TEXCLASS.ORD;
}
return this;
}
});
MML.mtext = MML.mbase.Subclass({
type: "mtext", isToken: TRUE,
texClass: MML.TEXCLASS.ORD,
defaults: {
mathvariant: MML.INHERIT,
mathsize: MML.INHERIT,
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT
}
});
MML.mspace = MML.mbase.Subclass({
type: "mspace", isToken: TRUE,
isSpacelike: function () {return TRUE},
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
width: "0em",
height: "0ex",
depth: "0ex",
linebreak: MML.LINEBREAK.AUTO
}
});
MML.ms = MML.mbase.Subclass({
type: "ms", isToken: TRUE,
texClass: MML.TEXCLASS.ORD,
defaults: {
mathvariant: MML.INHERIT,
mathsize: MML.INHERIT,
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
lquote: '"',
rquote: '"'
}
});
MML.mglyph = MML.mbase.Subclass({
type: "mglyph", isToken: TRUE,
texClass: MML.TEXCLASS.ORD,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
alt: "",
src: "",
width: MML.AUTO,
height: MML.AUTO,
valign: "0em"
}
});
MML.mrow = MML.mbase.Subclass({
type: "mrow",
isSpacelike: MML.mbase.childrenSpacelike,
inferred: FALSE,
isEmbellished: function () {
var isEmbellished = FALSE;
for (var i = 0, m = this.data.length; i < m; i++) {
if (this.data[i] == null) continue;
if (this.data[i].isEmbellished()) {
if (isEmbellished) {return FALSE}
isEmbellished = TRUE; this.core = i;
} else if (!this.data[i].isSpacelike()) {return FALSE}
}
return isEmbellished;
},
NonSpaceLength: function () {
var n = 0;
for (var i = 0, m = this.data.length; i < m; i++) {if (!this.data[i].isSpacelike()) {n++}}
return n;
},
FirstNonSpace: function () {
for (var i = 0, m = this.data.length; i < m; i++)
{if (!this.data[i].isSpacelike()) {return this.data[i]}}
return null;
},
LastNonSpace: function () {
for (var i = this.data.length-1; i >= 0; i--)
{if (!this.data[i].isSpacelike()) {return this.data[i]}}
return null;
},
Core: function () {
if (!(this.isEmbellished()) || typeof(this.core) === "undefined") {return this}
return this.data[this.core];
},
CoreMO: function () {
if (!(this.isEmbellished()) || typeof(this.core) === "undefined") {return this}
return this.data[this.core].CoreMO();
},
toString: function () {
if (this.inferred) {return '[' + this.data.join(',') + ']'}
return this.SUPER(arguments).toString.call(this);
},
setTeXclass: function (prev) {
for (var i = 0, m = this.data.length; i < m; i++)
{if (this.data[i]) {prev = this.data[i].setTeXclass(prev)}}
if (this.data[0]) {this.updateTeXclass(this.data[0])}
return prev;
}
});
MML.mfrac = MML.mbase.Subclass({
type: "mfrac", num: 0, den: 1,
texClass: MML.TEXCLASS.INNER,
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
linethickness: MML.LINETHICKNESS.MEDIUM,
numalign: MML.ALIGN.CENTER,
denomalign: MML.ALIGN.CENTER,
bevelled: FALSE
},
adjustChild_displaystyle: function (n) {return FALSE},
adjustChild_scriptlevel: function (n) {
var level = this.Get("scriptlevel");
if (!this.Get("displaystyle") || level > 0) {level++}
return level;
},
adjustChild_texprimestyle: function (n) {
if (n == this.den) {return true}
return this.Get("texprimestyle");
},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.msqrt = MML.mbase.Subclass({
type: "msqrt",
inferRow: TRUE,
texClass: MML.TEXCLASS.ORD,
setTeXclass: MML.mbase.setSeparateTeXclasses,
adjustChild_texprimestyle: function (n) {return TRUE}
});
MML.mroot = MML.mbase.Subclass({
type: "mroot",
texClass: MML.TEXCLASS.ORD,
adjustChild_displaystyle: function (n) {
if (n === 1) {return FALSE}
return this.Get("displaystyle");
},
adjustChild_scriptlevel: function (n) {
var level = this.Get("scriptlevel");
if (n === 1) {level += 2}
return level;
},
adjustChild_texprimestyle: function (n) {
if (n === 0) {return TRUE};
return this.Get("texprimestyle");
},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.mstyle = MML.mbase.Subclass({
type: "mstyle",
isSpacelike: MML.mbase.childrenSpacelike,
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
inferRow: TRUE,
defaults: {
scriptlevel: MML.INHERIT,
displaystyle: MML.INHERIT,
scriptsizemultiplier: Math.sqrt(1/2),
scriptminsize: "8pt",
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
infixlinebreakstyle: MML.LINEBREAKSTYLE.BEFORE,
decimalseparator: "."
},
adjustChild_scriptlevel: function (n) {
var level = this.scriptlevel;
if (level == null) {
level = this.Get("scriptlevel");
} else if (String(level).match(/^ *[-+]/)) {
delete this.scriptlevel;
var LEVEL = this.Get("scriptlevel");
this.scriptlevel = level;
level = LEVEL + parseInt(level);
}
return level;
},
inheritFromMe: TRUE,
noInherit: {
mpadded: {width: TRUE, height: TRUE, depth: TRUE, lspace: TRUE, voffset: TRUE},
mtable: {width: TRUE, height: TRUE, depth: TRUE}
},
setTeXclass: MML.mbase.setChildTeXclass
});
MML.merror = MML.mbase.Subclass({
type: "merror",
inferRow: TRUE,
texClass: MML.TEXCLASS.ORD
});
MML.mpadded = MML.mbase.Subclass({
type: "mpadded",
inferRow: TRUE,
isSpacelike: MML.mbase.childrenSpacelike,
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
width: "",
height: "",
depth: "",
lspace: 0,
voffset: 0
},
setTeXclass: MML.mbase.setChildTeXclass
});
MML.mphantom = MML.mbase.Subclass({
type: "mphantom",
texClass: MML.TEXCLASS.ORD,
inferRow: TRUE,
isSpacelike: MML.mbase.childrenSpacelike,
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
setTeXclass: MML.mbase.setChildTeXclass
});
MML.mfenced = MML.mbase.Subclass({
type: "mfenced",
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
open: '(',
close: ')',
separators: ','
},
texClass: MML.TEXCLASS.OPEN,
setTeXclass: function (prev) {
this.getPrevClass(prev);
var values = this.getValues("open","close","separators");
values.open = values.open.replace(/[ \t\n\r]/g,"");
values.close = values.close.replace(/[ \t\n\r]/g,"");
values.separators = values.separators.replace(/[ \t\n\r]/g,"");
// create a fake node for the open item
if (values.open !== "") {
this.SetData("open",MML.mo(values.open).With({stretchy:true, texClass:MML.TEXCLASS.OPEN}));
prev = this.data.open.setTeXclass(prev);
}
// get the separators
if (values.separators !== "") {
while (values.separators.length < this.data.length)
{values.separators += values.separators.charAt(values.separators.length-1)}
}
// handle the first item, if any
if (this.data[0]) {prev = this.data[0].setTeXclass(prev)}
// add fake nodes for separators and handle the following item
for (var i = 1, m = this.data.length; i < m; i++) {
if (this.data[i]) {
if (values.separators !== "") {
this.SetData("sep"+i,MML.mo(values.separators.charAt(i-1)));
prev = this.data["sep"+i].setTeXclass(prev);
}
prev = this.data[i].setTeXclass(prev);
}
}
// create fake node for the close item
if (values.close !== "") {
this.SetData("close",MML.mo(values.close).With({stretchy:true, texClass:MML.TEXCLASS.CLOSE}));
prev = this.data.close.setTeXclass(prev);
}
// get the data from the open item
this.updateTeXclass(this.data.open);
return prev;
}
});
MML.menclose = MML.mbase.Subclass({
type: "menclose",
inferRow: TRUE,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
notation: MML.NOTATION.LONGDIV,
texClass: MML.TEXCLASS.ORD
},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.msubsup = MML.mbase.Subclass({
type: "msubsup", base: 0, sub: 1, sup: 2,
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
subscriptshift: "",
superscriptshift: "",
texClass: MML.AUTO
},
autoDefault: function (name) {
if (name === "texClass")
{return (this.isEmbellished() ? this.CoreMO().Get(name) : MML.TEXCLASS.ORD)}
return 0;
},
adjustChild_displaystyle: function (n) {
if (n > 0) {return FALSE}
return this.Get("displaystyle");
},
adjustChild_scriptlevel: function (n) {
var level = this.Get("scriptlevel");
if (n > 0) {level++}
return level;
},
adjustChild_texprimestyle: function (n) {
if (n === this.sub) {return TRUE}
return this.Get("texprimestyle");
},
setTeXclass: MML.mbase.setBaseTeXclasses
});
MML.msub = MML.msubsup.Subclass({type: "msub"});
MML.msup = MML.msubsup.Subclass({type: "msup", sub:2, sup:1});
MML.munderover = MML.mbase.Subclass({
type: "munderover",
base: 0, under: 1, over: 2, sub: 1, sup: 2,
ACCENTS: ["", "accentunder", "accent"],
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
accent: MML.AUTO,
accentunder: MML.AUTO,
align: MML.ALIGN.CENTER,
texClass: MML.AUTO,
subscriptshift: "", // when converted to msubsup by moveablelimits
superscriptshift: "" // when converted to msubsup by moveablelimits
},
autoDefault: function (name) {
if (name === "texClass")
{return (this.isEmbellished() ? this.CoreMO().Get(name) : MML.TEXCLASS.ORD)}
if (name === "accent" && this.data[this.over]) {return this.data[this.over].CoreMO().Get("accent")}
if (name === "accentunder" && this.data[this.under]) {return this.data[this.under].CoreMO().Get("accent")}
return FALSE;
},
adjustChild_displaystyle: function (n) {
if (n > 0) {return FALSE}
return this.Get("displaystyle");
},
adjustChild_scriptlevel: function (n) {
var level = this.Get("scriptlevel");
if (n == this.under && !this.Get("accentunder")) {level++}
if (n == this.over && !this.Get("accent")) {level++}
return level;
},
adjustChild_texprimestyle: function (n) {
if (n === this.base && this.data[this.over]) {return TRUE}
return this.Get("texprimestyle");
},
setTeXclass: MML.mbase.setBaseTeXclasses
});
MML.munder = MML.munderover.Subclass({type: "munder"});
MML.mover = MML.munderover.Subclass({
type: "mover", over: 1, under: 2, sup: 1, sub: 2,
ACCENTS: ["", "accent", "accentunder"]
});
MML.mmultiscripts = MML.mbase.Subclass({
type: "mmultiscripts",
isEmbellished: MML.mbase.childEmbellished,
Core: MML.mbase.childCore,
CoreMO: MML.mbase.childCoreMO,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
subscriptshift: MML.AUTO,
superscriptshift: MML.AUTO,
texClass: MML.AUTO
},
autoDefault: function (name) {
if (name === "texClass")
{return (this.isEmbellished() ? this.CoreMO().Get(name) : MML.TEXCLASS.ORD)}
// compute this from size of children
return 0;
},
adjustChild_displaystyle: function (n) {
if (n > 0) {return FALSE}
return this.Get("displaystyle");
},
adjustChild_scriptlevel: function (n) {
var level = this.Get("scriptlevel");
if (n > 0) {level++}
return level;
},
adjustChild_texprimestyle: function (n) {return (n === this.base && this.data[this.over])},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.mtable = MML.mbase.Subclass({
type: "mtable",
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
align: MML.ALIGN.AXIS,
rowalign: MML.ALIGN.BASELINE,
columnalign: MML.ALIGN.CENTER,
groupalign: "{left}",
alignmentscope: TRUE,
columnwidth: MML.WIDTH.AUTO,
width: MML.WIDTH.AUTO,
rowspacing: "1ex",
columnspacing: ".8em",
rowlines: MML.LINES.NONE,
columnlines: MML.LINES.NONE,
frame: MML.LINES.NONE,
framespacing: "0.4em 0.5ex",
equalrows: FALSE,
equalcolumns: FALSE,
displaystyle: FALSE,
side: MML.SIDE.RIGHT,
minlabelspacing: "0.8em",
texClass: MML.TEXCLASS.ORD,
useHeight: 1
},
inheritFromMe: TRUE,
noInherit: {
mtable: {
align: TRUE, rowalign: TRUE, columnalign: TRUE, groupalign: TRUE,
alignmentscope: TRUE, columnwidth: TRUE, width: TRUE, rowspacing: TRUE,
columnspacing: TRUE, rowlines: TRUE, columnlines: TRUE, frame: TRUE,
framespacing: TRUE, equalrows: TRUE, equalcolumns: TRUE,
side: TRUE, minlabelspacing: TRUE, texClass: TRUE, useHeight: 1
}
},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.mtr = MML.mbase.Subclass({
type: "mtr",
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
rowalign: MML.INHERIT,
columnalign: MML.INHERIT,
groupalign: MML.INHERIT
},
inheritFromMe: TRUE,
noInherit: {
mrow: {rowalign: TRUE, columnalign: TRUE, groupalign: TRUE},
mtable: {rowalign: TRUE, columnalign: TRUE, groupalign: TRUE}
},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.mtd = MML.mbase.Subclass({
type: "mtd",
inferRow: TRUE,
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
rowspan: 1,
columnspan: 1,
rowalign: MML.INHERIT,
columnalign: MML.INHERIT,
groupalign: MML.INHERIT
},
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.maligngroup = MML.mbase.Subclass({
type: "malign",
isSpacelike: function () {return TRUE},
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
groupalign: MML.INHERIT
},
inheritFromMe: TRUE,
noInherit: {
mrow: {groupalign: TRUE},
mtable: {groupalign: TRUE}
}
});
MML.malignmark = MML.mbase.Subclass({
type: "malignmark",
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
edge: MML.SIDE.LEFT
},
isSpacelike: function () {return TRUE}
});
MML.mlabeledtr = MML.mtr.Subclass({
type: "mlabeledtr"
});
MML.maction = MML.mbase.Subclass({
type: "maction",
defaults: {
mathbackground: MML.INHERIT,
mathcolor: MML.INHERIT,
actiontype: MML.ACTIONTYPE.TOGGLE,
selection: 1
},
// FIXME: should base class on selection
setTeXclass: MML.mbase.setSeparateTeXclasses
});
MML.semantics = MML.mbase.Subclass({
type: "semantics",
defaults: {
definitionURL: null,
encoding: null
},
isEmbellished: MML.mbase.childEmbellished,
setTeXclass: MML.mbase.setChildTeXclass
});
MML.annotation = MML.mbase.Subclass({
type: "annotation", isToken: TRUE,
defaults: {
definitionURL: null,
encoding: null,
cd: "mathmlkeys",
name: "",
src: null
}
});
MML["annotation-xml"] = MML.mbase.Subclass({
type: "annotation-xml",
defaults: {
definitionURL: null,
encoding: null,
cd: "mathmlkeys",
name: "",
src: null
}
});
MML.math = MML.mstyle.Subclass({
type: "math",
defaults: {
mathvariant: MML.VARIANT.NORMAL,
mathsize: MML.SIZE.NORMAL,
mathcolor: "", // should be "black", but allow it to inherit from surrounding text
mathbackground: MML.COLOR.TRANSPARENT,
scriptlevel: 0,
displaystyle: MML.AUTO,
display: "inline",
maxwidth: "",
overflow: MML.OVERFLOW.LINEBREAK,
altimg: "",
'altimg-width': "",
'altimg-height': "",
'altimg-valign': "",
alttext: "",
cdgroup: "",
scriptsizemultiplier: Math.sqrt(1/2),
scriptminsize: "8px", // should be 8pt, but that's too big
infixlinebreakstyle: MML.LINEBREAKSTYLE.BEFORE,
decimalseparator: ".",
texprimestyle: FALSE // is it in TeX's C' style?
},
autoDefault: function (name) {
if (name === "displaystyle") {return this.Get("display") === "block"}
return "";
},
setTeXclass: MML.mbase.setChildTeXclass
});
MML.chars = MML.mbase.Subclass({
type: "chars",
Append: function () {this.data.push.apply(this.data,arguments)},
value: function () {return this.data.join("")},
toString: function () {return this.data.join("")}
});
MML.entity = MML.mbase.Subclass({
type: "entity",
Append: function () {this.data.push.apply(this.data,arguments)},
value: function () {
if (this.data[0].substr(0,2) === "#x") {return parseInt(this.data[0].substr(2),16)}
else if (this.data[0].substr(0,1) === "#") {return parseInt(this.data[0].substr(1))}
else {return 0} // FIXME: look up named entities from table
},
toString: function () {
var n = this.value();
if (n <= 0xFFFF) {return String.fromCharCode(n)}
return this.PLANE1 + String.fromCharCode(n-0x1D400+0xDC00);
}
});
MML.TeXAtom = MML.mbase.Subclass({
type: "texatom",
inferRow: TRUE,
texClass: MML.TEXCLASS.ORD,
setTeXclass: function (prev) {
this.getPrevClass(prev);
this.data[0].setTeXclass();
return this;
}
});
var TEXCLASS = MML.TEXCLASS;
var MO = {
ORD: [0,0,TEXCLASS.ORD],
ORD11: [1,1,TEXCLASS.ORD],
ORD21: [2,1,TEXCLASS.ORD],
ORD02: [0,2,TEXCLASS.ORD],
ORD55: [5,5,TEXCLASS.ORD],
OP: [1,2,TEXCLASS.OP,{largeop: true, movablelimits: true, symmetric: true}],
OPFIXED: [1,2,TEXCLASS.OP,{largeop: true, movablelimits: true}],
INTEGRAL: [0,1,TEXCLASS.OP,{largeop: true, symmetric: true}],
INTEGRAL2: [1,2,TEXCLASS.OP,{largeop: true, symmetric: true}],
BIN3: [3,3,TEXCLASS.BIN],
BIN4: [4,4,TEXCLASS.BIN],
BIN01: [0,1,TEXCLASS.BIN],
TALLBIN: [4,4,TEXCLASS.BIN,{stretchy: true}],
BINOP: [4,4,TEXCLASS.BIN,{largeop: true, movablelimits: true}],
REL: [5,5,TEXCLASS.REL],
REL1: [1,1,TEXCLASS.REL,{stretchy: true}],
REL4: [4,4,TEXCLASS.REL],
WIDEREL: [5,5,TEXCLASS.REL,{stretchy: true}],
RELACCENT: [5,5,TEXCLASS.REL,{accent: true, stretchy: true}],
OPEN: [0,0,TEXCLASS.OPEN,{fence: true, stretchy: true, symmetric: true}],
CLOSE: [0,0,TEXCLASS.CLOSE,{fence: true, stretchy: true, symmetric: true}],
INNER: [0,0,TEXCLASS.INNER],
PUNCT: [0,3,TEXCLASS.PUNCT],
ACCENT: [0,0,TEXCLASS.ORD,{accent: true}],
WIDEACCENT: [0,0,TEXCLASS.ORD,{accent: true, stretchy: true}]
};
MML.mo.Augment({
SPACE: [
'0em',
'0.1111em',
'0.1667em',
'0.2222em',
'0.2667em',
'0.3333em'
],
RANGES: [
[0x20,0x7F,TEXCLASS.REL,"BasicLatin"],
[0xA0,0xFF,TEXCLASS.ORD,"Latin1Supplement"],
[0x100,0x17F,TEXCLASS.ORD],
[0x180,0x24F,TEXCLASS.ORD],
[0x2B0,0x2FF,TEXCLASS.ORD,"SpacingModLetters"],
[0x300,0x36F,TEXCLASS.ORD,"CombDiacritMarks"],
[0x370,0x3FF,TEXCLASS.ORD,"GreekAndCoptic"],
[0x1E00,0x1EFF,TEXCLASS.ORD],
[0x2000,0x206F,TEXCLASS.PUNCT,"GeneralPunctuation"],
[0x2070,0x209F,TEXCLASS.ORD],
[0x20A0,0x20CF,TEXCLASS.ORD],
[0x20D0,0x20FF,TEXCLASS.ORD,"CombDiactForSymbols"],
[0x2100,0x214F,TEXCLASS.ORD,"LetterlikeSymbols"],
[0x2150,0x218F,TEXCLASS.ORD],
[0x2190,0x21FF,TEXCLASS.REL,"Arrows"],
[0x2200,0x22FF,TEXCLASS.BIN,"MathOperators"],
[0x2300,0x23FF,TEXCLASS.ORD,"MiscTechnical"],
[0x2460,0x24FF,TEXCLASS.ORD],
[0x25A0,0x25FF,TEXCLASS.ORD,"GeometricShapes"],
[0x2700,0x27BF,TEXCLASS.ORD,"Dingbats"],
[0x27C0,0x27EF,TEXCLASS.ORD,"MiscMathSymbolsA"],
[0x2900,0x297F,TEXCLASS.REL,"SupplementalArrowsB"],
[0x2980,0x29FF,TEXCLASS.ORD,"MiscMathSymbolsB"],
[0x2A00,0x2AFF,TEXCLASS.BIN,"SuppMathOperators"],
[0x2B00,0x2BFF,TEXCLASS.ORD],
[0x1D400,0x1D7FF,TEXCLASS.ORD]
],
OPTABLE: {
prefix: {
'\u2111': MO.ORD11, // black-letter capital i
'\u2113': MO.ORD11, // script small l
'\u211C': MO.ORD11, // black-letter capital r
'\u2200': MO.ORD21, // for all
'\u2202': MO.ORD21, // partial differential
'\u2203': MO.ORD21, // there exists
'\u2207': MO.ORD21, // nabla
'\u220F': MO.OP, // n-ary product
'\u2210': MO.OP, // n-ary coproduct
'\u2211': MO.OP, // n-ary summation
'\u2212': MO.BIN01, // minus sign
'\u2213': MO.BIN01, // minus-or-plus sign
'\u221A': [1,1,TEXCLASS.ORD,{stretchy: true}], // square root
'\u2220': MO.ORD, // angle
'\u222B': MO.INTEGRAL, // integral
'\u222E': MO.INTEGRAL, // contour integral
'\u22C0': MO.OP, // n-ary logical and
'\u22C1': MO.OP, // n-ary logical or
'\u22C2': MO.OP, // n-ary intersection
'\u22C3': MO.OP, // n-ary union
'\u2308': MO.OPEN, // left ceiling
'\u230A': MO.OPEN, // left floor
'\u27E8': MO.OPEN, // mathematical left angle bracket
'\u2A00': MO.OP, // n-ary circled dot operator
'\u2A01': MO.OP, // n-ary circled plus operator
'\u2A02': MO.OP, // n-ary circled times operator
'\u2A04': MO.OP, // n-ary union operator with plus
'\u2A06': MO.OP, // n-ary square union operator
'\u00AC': MO.ORD21, // not sign
'\u00B1': MO.BIN01, // plus-minus sign
'(': MO.OPEN, // left parenthesis
'+': MO.BIN01, // plus sign
'-': MO.BIN01, // hyphen-minus
'[': MO.OPEN, // left square bracket
'{': MO.OPEN, // left curly bracket
'|': MO.OPEN // vertical line
},
postfix: {
'!': [1,0,TEXCLASS.CLOSE], // exclamation mark
'&': MO.ORD, // ampersand
'\u2032': MO.ORD02, // prime
'\u203E': MO.WIDEACCENT, // overline
'\u2309': MO.CLOSE, // right ceiling
'\u230B': MO.CLOSE, // right floor
'\u23DE': MO.WIDEACCENT, // top curly bracket
'\u23DF': MO.WIDEACCENT, // bottom curly bracket
'\u266D': MO.ORD02, // music flat sign
'\u266E': MO.ORD02, // music natural sign
'\u266F': MO.ORD02, // music sharp sign
'\u27E9': MO.CLOSE, // mathematical right angle bracket
'\u02C6': MO.WIDEACCENT, // modifier letter circumflex accent
'\u02C7': MO.WIDEACCENT, // caron
'\u02D8': MO.ACCENT, // breve
'\u02D9': MO.ACCENT, // dot above
'\u02DC': MO.WIDEACCENT, // small tilde
'\u0302': MO.ACCENT, // combining circumflex accent
'\u00A8': MO.ACCENT, // diaeresis
'\u00AF': MO.WIDEACCENT, // macron
')': MO.CLOSE, // right parenthesis
']': MO.CLOSE, // right square bracket
'^': MO.WIDEACCENT, // circumflex accent
'_': MO.WIDEACCENT, // low line
'`': MO.ACCENT, // grave accent
'|': MO.CLOSE, // vertical line
'}': MO.CLOSE, // right curly bracket
'~': MO.WIDEACCENT // tilde
},
infix: {
'%': [3,3,TEXCLASS.ORD], // percent sign
'\u2022': MO.BIN4, // bullet
'\u2026': MO.INNER, // horizontal ellipsis
'\u2044': MO.TALLBIN, // fraction slash
'\u2061': MO.ORD, // function application
'\u2062': MO.ORD, // invisible times
'\u2063': [0,0,TEXCLASS.ORD,{separator: true}], // invisible separator
'\u2064': MO.ORD, // invisible plus
'\u2190': MO.RELACCENT, // leftwards arrow
'\u2191': MO.WIDEREL, // upwards arrow
'\u2192': MO.RELACCENT, // rightwards arrow
'\u2193': MO.WIDEREL, // downwards arrow
'\u2194': MO.RELACCENT, // left right arrow
'\u2195': MO.WIDEREL, // up down arrow
'\u2196': MO.WIDEREL, // north west arrow
'\u2197': MO.WIDEREL, // north east arrow
'\u2198': MO.WIDEREL, // south east arrow
'\u2199': MO.WIDEREL, // south west arrow
'\u21A6': MO.WIDEREL, // rightwards arrow from bar
'\u21A9': MO.WIDEREL, // leftwards arrow with hook
'\u21AA': MO.WIDEREL, // rightwards arrow with hook
'\u21BC': MO.RELACCENT, // leftwards harpoon with barb upwards
'\u21BD': MO.WIDEREL, // leftwards harpoon with barb downwards
'\u21C0': MO.RELACCENT, // rightwards harpoon with barb upwards
'\u21C1': MO.WIDEREL, // rightwards harpoon with barb downwards
'\u21CC': MO.WIDEREL, // rightwards harpoon over leftwards harpoon
'\u21D0': MO.WIDEREL, // leftwards double arrow
'\u21D1': MO.WIDEREL, // upwards double arrow
'\u21D2': MO.WIDEREL, // rightwards double arrow
'\u21D3': MO.WIDEREL, // downwards double arrow
'\u21D4': MO.WIDEREL, // left right double arrow
'\u21D5': MO.WIDEREL, // up down double arrow
'\u2208': MO.REL, // element of
'\u2209': MO.REL, // not an element of
'\u220B': MO.REL, // contains as member
'\u2212': MO.BIN4, // minus sign
'\u2213': MO.BIN4, // minus-or-plus sign
'\u2215': MO.TALLBIN, // division slash
'\u2216': MO.BIN4, // set minus
'\u2217': MO.BIN4, // asterisk operator
'\u2218': MO.BIN4, // ring operator
'\u2219': MO.BIN4, // bullet operator
'\u221D': MO.REL, // proportional to
'\u2223': MO.REL, // divides
'\u2225': MO.REL, // parallel to
'\u2227': MO.BIN4, // logical and
'\u2228': MO.BIN4, // logical or
'\u2229': MO.BIN4, // intersection
'\u222A': MO.BIN4, // union
'\u223C': MO.REL, // tilde operator
'\u2240': MO.BIN4, // wreath product
'\u2243': MO.REL, // asymptotically equal to
'\u2245': MO.REL, // approximately equal to
'\u2248': MO.REL, // almost equal to
'\u224D': MO.REL, // equivalent to
'\u2250': MO.REL, // approaches the limit
'\u2260': MO.REL, // not equal to
'\u2261': MO.REL, // identical to
'\u2264': MO.REL, // less-than or equal to
'\u2265': MO.REL, // greater-than or equal to
'\u226A': MO.REL, // much less-than
'\u226B': MO.REL, // much greater-than
'\u227A': MO.REL, // precedes
'\u227B': MO.REL, // succeeds
'\u2282': MO.REL, // subset of
'\u2283': MO.REL, // superset of
'\u2286': MO.REL, // subset of or equal to
'\u2287': MO.REL, // superset of or equal to
'\u228E': MO.BIN4, // multiset union
'\u2291': MO.REL, // square image of or equal to
'\u2292': MO.REL, // square original of or equal to
'\u2293': MO.BIN4, // square cap
'\u2294': MO.BIN4, // square cup
'\u2295': MO.BIN4, // circled plus
'\u2296': MO.BIN4, // circled minus
'\u2297': MO.BIN4, // circled times
'\u2298': MO.BIN4, // circled division slash
'\u2299': MO.BIN4, // circled dot operator
'\u22A2': MO.REL, // right tack
'\u22A3': MO.REL, // left tack
'\u22A4': MO.ORD55, // down tack
'\u22A5': MO.REL, // up tack
'\u22A8': MO.REL, // true
'\u22C4': MO.BIN4, // diamond operator
'\u22C5': MO.BIN4, // dot operator
'\u22C6': MO.BIN4, // star operator
'\u22C8': MO.REL, // bowtie
'\u22EE': MO.ORD55, // vertical ellipsis
'\u22EF': MO.INNER, // midline horizontal ellipsis
'\u22F1': [5,5,TEXCLASS.INNER], // down right diagonal ellipsis
'\u2500': [0,0,TEXCLASS.ORD,{stretchy: true}], // box drawings light horizontal
'\u25B3': MO.BIN4, // white up-pointing triangle
'\u25B5': MO.BIN4, // white up-pointing small triangle
'\u25B9': MO.BIN4, // white right-pointing small triangle
'\u25BD': MO.BIN4, // white down-pointing triangle
'\u25BF': MO.BIN4, // white down-pointing small triangle
'\u25C3': MO.BIN4, // white left-pointing small triangle
'\u2758': [4,4,TEXCLASS.REL,{fence: true, stretchy: true, symmetric: true}], // light vertical bar
'\u27F5': MO.REL1, // long leftwards arrow
'\u27F6': MO.REL1, // long rightwards arrow
'\u27F7': MO.REL1, // long left right arrow
'\u27F8': MO.REL1, // long leftwards double arrow
'\u27F9': MO.REL1, // long rightwards double arrow
'\u27FA': MO.REL1, // long left right double arrow
'\u2A2F': MO.BIN4, // vector or cross product
'\u2A3F': MO.BIN4, // amalgamation or coproduct
'\u2AAF': MO.REL, // precedes above single-line equals sign
'\u2AB0': MO.REL, // succeeds above single-line equals sign
'\u00B1': MO.BIN4, // plus-minus sign
'\u00B7': MO.BIN4, // middle dot
'\u00D7': MO.BIN4, // multiplication sign
'\u00F7': MO.BIN4, // division sign
'*': MO.BIN3, // asterisk
'+': MO.BIN4, // plus sign
',': [0,3,TEXCLASS.PUNCT,{separator: true}], // comma
'-': MO.BIN4, // hyphen-minus
'.': [3,3,TEXCLASS.ORD], // full stop
'/': MO.ORD11, // solidus
':': [1,2,TEXCLASS.REL], // colon
';': [0,3,TEXCLASS.PUNCT,{separator: true}], // semicolon
'<': MO.REL, // less-than sign
'=': MO.REL, // equals sign
'>': MO.REL, // greater-than sign
'?': [1,1,TEXCLASS.CLOSE], // question mark
'\\': MO.ORD, // reverse solidus
'_': MO.ORD11, // low line
'|': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}], // vertical line
'#': MO.ORD, // #
'$': MO.ORD, // $
'\u002E': [0,3,TEXCLASS.PUNCT,{separator: true}], // \ldotp
'\u02B9': MO.ORD, // prime
'\u02C9': MO.ACCENT, // \bar
'\u02CA': MO.ACCENT, // \acute
'\u02CB': MO.ACCENT, // \grave
'\u0300': MO.ACCENT, // \grave
'\u0301': MO.ACCENT, // \acute
'\u0303': MO.WIDEACCENT, // \tilde
'\u0304': MO.ACCENT, // \bar
'\u0306': MO.ACCENT, // \breve
'\u0307': MO.ACCENT, // \dot
'\u0308': MO.ACCENT, // \ddot
'\u030C': MO.ACCENT, // \check
'\u0332': MO.WIDEACCENT, // horizontal line
'\u0338': MO.REL4, // \not
'\u2015': [0,0,TEXCLASS.ORD,{stretchy: true}], // horizontal line
'\u2017': [0,0,TEXCLASS.ORD,{stretchy: true}], // horizontal line
'\u2020': MO.BIN3, // \dagger
'\u2021': MO.BIN3, // \ddagger
'\u20D7': MO.ACCENT, // \vec
'\u2118': MO.ORD, // \wp
'\u2205': MO.ORD, // \emptyset
'\u221E': MO.ORD, // \infty
'\u2305': MO.BIN3, // barwedge
'\u2306': MO.BIN3, // doublebarwedge
'\u2322': MO.REL4, // \frown
'\u2323': MO.REL4, // \smile
'\u2329': MO.OPEN, // langle
'\u232A': MO.CLOSE, // rangle
'\u23AA': MO.ORD, // \bracevert
'\u23AF': [0,0,TEXCLASS.ORD,{stretchy: true}], // \underline
'\u23B0': MO.OPEN, // \lmoustache
'\u23B1': MO.CLOSE, // \rmoustache
'\u25EF': MO.BIN3, // \bigcirc
'\u2660': MO.ORD, // \spadesuit
'\u2661': MO.ORD, // \heartsuit
'\u2662': MO.ORD, // \diamondsuit
'\u2663': MO.ORD, // \clubsuit
'\u27EE': MO.OPEN, // \lgroup
'\u27EF': MO.CLOSE, // \rgroup
'\u27FC': MO.REL4, // \longmapsto
'\u3008': MO.OPEN, // langle
'\u3009': MO.CLOSE, // rangle
'\uFE37': MO.WIDEACCENT, // horizontal brace down
'\uFE38': MO.WIDEACCENT // horizontal brace up
}
}
},{
OPTYPES: MO
});
})(MathJax.ElementJax.mml);
MathJax.ElementJax.mml.loadComplete("jax.js");
View Git Blame Copy Permalink