wikimedia/mediawiki-extensions-Math
1
0
Fork 0
mirror of https://gerrit.wikimedia.org/r/mediawiki/extensions/Math synced 2024-11-30 02:15:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
mediawiki-extensions-Math/modules/MathJax/jax/input/TeX/jax.js

1761 lines
66 KiB
JavaScript
Raw Normal View History

Initial experimental import of MathJax source into Math extension as a client-side rendering supplement to the PNG rendering. * Pulled in MathJax 1.1 (minus the 112 megabytes of PNG "fonts") * Pulled in some of <https://en.wikipedia.org/wiki/User:Nageh/mathJax> bits for initialization This doesn't currently override PNG images, but does replace the text-form if you configure it.
2011-12-06 01:17:35 +00:00
/*************************************************************
*
* MathJax/jax/input/TeX/jax.js
*
* Implements the TeX InputJax that reads mathematics in
* TeX and LaTeX format and converts it to the MML ElementJax
* internal format.
*
* ---------------------------------------------------------------------
*
* Copyright (c) 2009-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.
*/
(function (TEX) {
var TRUE = true, FALSE = false, MML, NBSP = String.fromCharCode(0xA0);
var STACK = MathJax.Object.Subclass({
Init: function (env) {
this.global = {};
this.data = [STACKITEM.start().With({global: this.global})];
if (env) {this.data[0].env = env}
this.env = this.data[0].env;
},
Push: function () {
var i, m, item, top;
for (i = 0, m = arguments.length; i < m; i++) {
item = arguments[i];
if (item instanceof MML.mbase) {item = STACKITEM.mml(item)}
item.global = this.global;
top = (this.data.length ? this.Top().checkItem(item) : TRUE);
if (top instanceof Array) {this.Pop(); this.Push.apply(this,top)}
else if (top instanceof STACKITEM) {this.Pop(); this.Push(top)}
else if (top) {
this.data.push(item);
if (item.env) {
for (var id in this.env)
{if (this.env.hasOwnProperty(id)) {item.env[id] = this.env[id]}}
this.env = item.env;
} else {item.env = this.env}
}
}
},
Pop: function () {
var item = this.data.pop(); if (!item.isOpen) {delete item.env}
this.env = (this.data.length ? this.Top().env : {});
return item;
},
Top: function (n) {
if (n == null) {n = 1}
if (this.data.length < n) {return null}
return this.data[this.data.length-n];
},
Prev: function (noPop) {
var top = this.Top();
if (noPop) {return top.data[top.data.length-1]}
else {return top.Pop()}
},
toString: function () {return "stack[\n "+this.data.join("\n ")+"\n]"}
});
var STACKITEM = STACK.Item = MathJax.Object.Subclass({
type: "base",
closeError: "Extra close brace or missing open brace",
rightError: "Missing \\left or extra \\right",
Init: function () {
if (this.isOpen) {this.env = {}}
this.data = [];
this.Push.apply(this,arguments);
},
Push: function () {this.data.push.apply(this.data,arguments)},
Pop: function () {return this.data.pop()},
mmlData: function (inferred,forceRow) {
if (inferred == null) {inferred = TRUE}
if (this.data.length === 1 && !forceRow) {return this.data[0]}
return MML.mrow.apply(MML,this.data).With((inferred ? {inferred: TRUE}: {}));
},
checkItem: function (item) {
if (item.type === "over" && this.isOpen) {item.num = this.mmlData(FALSE); this.data = []}
if (item.type === "cell" && this.isOpen) {TEX.Error("Misplaced "+item.name)}
if (item.isClose && this[item.type+"Error"]) {TEX.Error(this[item.type+"Error"])}
if (!item.isNotStack) {return TRUE}
this.Push(item.data[0]); return FALSE;
},
With: function (def) {
for (var id in def) {if (def.hasOwnProperty(id)) {this[id] = def[id]}}
return this;
},
toString: function () {return this.type+"["+this.data.join("; ")+"]"}
});
STACKITEM.start = STACKITEM.Subclass({
type: "start", isOpen: TRUE,
checkItem: function (item) {
if (item.type === "stop") {return STACKITEM.mml(this.mmlData())}
return this.SUPER(arguments).checkItem.call(this,item);
}
});
STACKITEM.stop = STACKITEM.Subclass({
type: "stop", isClose: TRUE
});
STACKITEM.open = STACKITEM.Subclass({
type: "open", isOpen: TRUE,
stopError: "Extra open brace or missing close brace",
checkItem: function (item) {
if (item.type === "close") {
var mml = this.mmlData(); // this.mmlData(TRUE,TRUE); // force row
return STACKITEM.mml(MML.TeXAtom(mml)); // TeXAtom make it an ORD to prevent spacing (FIXME: should be another way)
}
return this.SUPER(arguments).checkItem.call(this,item);
}
});
STACKITEM.close = STACKITEM.Subclass({
type: "close", isClose: TRUE
});
STACKITEM.subsup = STACKITEM.Subclass({
type: "subsup",
stopError: "Missing superscript or subscript argument",
checkItem: function (item) {
var script = ["","subscript","superscript"][this.position];
if (item.type === "open" || item.type === "left") {return TRUE}
if (item.type === "mml") {
this.data[0].SetData(this.position,item.data[0]);
return STACKITEM.mml(this.data[0]);
}
if (this.SUPER(arguments).checkItem.call(this,item))
{TEX.Error("Missing open brace for "+script)}
},
Pop: function () {}
});
STACKITEM.over = STACKITEM.Subclass({
type: "over", isClose: TRUE, name: "\\over",
checkItem: function (item,stack) {
if (item.type === "over") {TEX.Error("Ambiguous use of "+item.name)}
if (item.isClose) {
var mml = MML.mfrac(this.num,this.mmlData(FALSE));
if (this.thickness != null) {mml.linethickness = this.thickness}
if (this.open || this.close) {
mml.texClass = MML.TEXCLASS.INNER;
mml.texWithDelims = TRUE;
mml = MML.mfenced(mml).With({open: this.open, close: this.close});
}
return [STACKITEM.mml(mml), item];
}
return this.SUPER(arguments).checkItem.call(this,item);
},
toString: function () {return "over["+this.num+" / "+this.data.join("; ")+"]"}
});
STACKITEM.left = STACKITEM.Subclass({
type: "left", isOpen: TRUE, delim: '(',
stopError: "Extra \\left or missing \\right",
checkItem: function (item) {
if (item.type === "right") {
var mml = MML.mfenced(this.data.length === 1 ? this.data[0] : MML.mrow.apply(MML,this.data));
return STACKITEM.mml(mml.With({open: this.delim, close: item.delim}));
}
return this.SUPER(arguments).checkItem.call(this,item);
}
});
STACKITEM.right = STACKITEM.Subclass({
type: "right", isClose: TRUE, delim: ')'
});
STACKITEM.begin = STACKITEM.Subclass({
type: "begin", isOpen: TRUE,
checkItem: function (item) {
if (item.type === "end") {
if (item.name !== this.name)
{TEX.Error("\\begin{"+this.name+"} ended with \\end{"+item.name+"}")}
if (!this.end) {return STACKITEM.mml(this.mmlData())}
return this.parse[this.end].call(this.parse,this,this.data);
}
if (item.type === "stop") {TEX.Error("Missing \\end{"+this.name+"}")}
return this.SUPER(arguments).checkItem.call(this,item);
}
});
STACKITEM.end = STACKITEM.Subclass({
type: "end", isClose: TRUE
});
STACKITEM.style = STACKITEM.Subclass({
type: "style",
checkItem: function (item) {
if (!item.isClose) {return this.SUPER(arguments).checkItem.call(this,item)}
var mml = MML.mstyle.apply(MML,this.data).With(this.styles);
return [STACKITEM.mml(mml),item];
}
});
STACKITEM.position = STACKITEM.Subclass({
type: "position",
checkItem: function (item) {
if (item.isClose) {TEX.Error("Missing box for "+this.name)}
if (item.isNotStack) {
var mml = item.mmlData();
switch (this.move) {
case 'vertical':
mml = MML.mpadded(mml).With({height: this.dh, depth: this.dd, voffset: this.dh});
return [STACKITEM.mml(mml)];
case 'horizontal':
return [STACKITEM.mml(this.left),item,STACKITEM.mml(this.right)];
}
}
return this.SUPER(arguments).checkItem.call(this,item);
}
});
STACKITEM.array = STACKITEM.Subclass({
type: "array", isOpen: TRUE, arraydef: {},
Init: function () {
this.table = []; this.row = []; this.env = {};
this.SUPER(arguments).Init.apply(this,arguments);
},
checkItem: function (item) {
if (item.isClose && item.type !== "over") {
if (item.isEntry) {this.EndEntry(); this.clearEnv(); return FALSE}
if (item.isCR) {this.EndEntry(); this.EndRow(); this.clearEnv(); return FALSE}
this.EndTable(); this.clearEnv();
var mml = MML.mtable.apply(MML,this.table).With(this.arraydef);
if (this.open || this.close) {
mml = MML.mfenced(mml).With({open: this.open, close: this.close});
}
mml = STACKITEM.mml(mml);
if (this.requireClose) {
if (item.type === 'close') {return mml}
TEX.Error("Missing close brace");
}
return [mml,item];
}
return this.SUPER(arguments).checkItem.call(this,item);
},
EndEntry: function () {this.row.push(MML.mtd.apply(MML,this.data)); this.data = []},
EndRow: function () {this.table.push(MML.mtr.apply(MML,this.row)); this.row = []},
EndTable: function () {
if (this.data.length || this.row.length) {this.EndEntry(); this.EndRow()}
this.checkLines();
},
checkLines: function () {
if (this.arraydef.rowlines) {
var lines = this.arraydef.rowlines.split(/ /);
if (lines.length === this.table.length) {
this.arraydef.frame = lines.pop();
this.arraydef.rowlines = lines.join(' ');
} else if (lines.length < this.table.length -1) {
this.arraydef.rowlines += " none";
}
}
},
clearEnv: function () {
for (var id in this.env) {if (this.env.hasOwnProperty(id)) {delete this.env[id]}}
}
});
STACKITEM.cell = STACKITEM.Subclass({
type: "cell", isClose: TRUE
});
STACKITEM.mml = STACKITEM.Subclass({
type: "mml", isNotStack: TRUE,
Push: function () {
// embellished are type ORD in TeX (but not MML) so wrap them in TeXAtom
for (var i = 0, m = arguments.length; i < m; i++) {
if (arguments[i].type !== "mo" && arguments[i].isEmbellished())
{arguments[i] = MML.TeXAtom(arguments[i]).With({isEmbellishedWrapper: TRUE})}
}
this.data.push.apply(this.data,arguments);
},
Add: function () {this.data.push.apply(this.data,arguments); return this}
});
var TEXDEF = {};
var STARTUP = function () {
MML = MathJax.ElementJax.mml;
MathJax.Hub.Insert(TEXDEF,{
// patterns for letters and numbers
letter: /[a-z]/i,
digit: /[0-9.]/,
number: /^(?:[0-9]+(?:\{,\}[0-9]{3})*(?:\.[0-9]*)*|\.[0-9]+)/,
special: {
'\\': 'ControlSequence',
'{': 'Open',
'}': 'Close',
'~': 'Tilde',
'^': 'Superscript',
'_': 'Subscript',
' ': 'Space',
"\t": 'Space',
"\r": 'Space',
"\n": 'Space',
"'": 'Prime',
'%': 'Comment',
'&': 'Entry',
'#': 'Hash',
'\u2019': 'Prime'
},
remap: {
'-': '2212',
'*': '2217'
},
mathchar0mi: {
// Lower-case greek
alpha: '03B1',
beta: '03B2',
gamma: '03B3',
delta: '03B4',
epsilon: '03F5',
zeta: '03B6',
eta: '03B7',
theta: '03B8',
iota: '03B9',
kappa: '03BA',
lambda: '03BB',
mu: '03BC',
nu: '03BD',
xi: '03BE',
omicron: '03BF', // added for completeness
pi: '03C0',
rho: '03C1',
sigma: '03C3',
tau: '03C4',
upsilon: '03C5',
phi: '03D5',
chi: '03C7',
psi: '03C8',
omega: '03C9',
varepsilon: '03B5',
vartheta: '03D1',
varpi: '03D6',
varrho: '03F1',
varsigma: '03C2',
varphi: '03C6',
// Ord symbols
S: '00A7',
aleph: ['2135',{mathvariant: MML.VARIANT.NORMAL}],
hbar: '210F',
imath: '0131',
jmath: '0237',
ell: '2113',
wp: ['2118',{mathvariant: MML.VARIANT.NORMAL}],
Re: ['211C',{mathvariant: MML.VARIANT.NORMAL}],
Im: ['2111',{mathvariant: MML.VARIANT.NORMAL}],
partial: ['2202',{mathvariant: MML.VARIANT.NORMAL}],
infty: ['221E',{mathvariant: MML.VARIANT.NORMAL}],
prime: ['2032',{mathvariant: MML.VARIANT.NORMAL}],
emptyset: ['2205',{mathvariant: MML.VARIANT.NORMAL}],
nabla: ['2207',{mathvariant: MML.VARIANT.NORMAL}],
top: ['22A4',{mathvariant: MML.VARIANT.NORMAL}],
bot: ['22A5',{mathvariant: MML.VARIANT.NORMAL}],
angle: ['2220',{mathvariant: MML.VARIANT.NORMAL}],
triangle: ['25B3',{mathvariant: MML.VARIANT.NORMAL}],
backslash: ['2216',{mathvariant: MML.VARIANT.NORMAL}],
forall: ['2200',{mathvariant: MML.VARIANT.NORMAL}],
exists: ['2203',{mathvariant: MML.VARIANT.NORMAL}],
neg: ['00AC',{mathvariant: MML.VARIANT.NORMAL}],
lnot: ['00AC',{mathvariant: MML.VARIANT.NORMAL}],
flat: ['266D',{mathvariant: MML.VARIANT.NORMAL}],
natural: ['266E',{mathvariant: MML.VARIANT.NORMAL}],
sharp: ['266F',{mathvariant: MML.VARIANT.NORMAL}],
clubsuit: ['2663',{mathvariant: MML.VARIANT.NORMAL}],
diamondsuit: ['2662',{mathvariant: MML.VARIANT.NORMAL}],
heartsuit: ['2661',{mathvariant: MML.VARIANT.NORMAL}],
spadesuit: ['2660',{mathvariant: MML.VARIANT.NORMAL}]
},
mathchar0mo: {
surd: '221A',
// big ops
coprod: ['2210',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigvee: ['22C1',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigwedge: ['22C0',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
biguplus: ['2A04',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigcap: ['22C2',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigcup: ['22C3',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
'int': ['222B',{texClass: MML.TEXCLASS.OP}],
intop: ['222B',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE, movablelimits:TRUE}],
iint: ['222C',{texClass: MML.TEXCLASS.OP}],
iiint: ['222D',{texClass: MML.TEXCLASS.OP}],
prod: ['220F',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
sum: ['2211',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigotimes: ['2A02',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigoplus: ['2A01',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
bigodot: ['2A00',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
oint: ['222E',{texClass: MML.TEXCLASS.OP}],
bigsqcup: ['2A06',{texClass: MML.TEXCLASS.OP, movesupsub:TRUE}],
smallint: ['222B',{largeop:FALSE}],
// binary operations
triangleleft: '25C3',
triangleright: '25B9',
bigtriangleup: '25B3',
bigtriangledown: '25BD',
wedge: '2227',
land: '2227',
vee: '2228',
lor: '2228',
cap: '2229',
cup: '222A',
ddagger: '2021',
dagger: '2020',
sqcap: '2293',
sqcup: '2294',
uplus: '228E',
amalg: '2A3F',
diamond: '22C4',
bullet: '2219',
wr: '2240',
div: '00F7',
odot: ['2299',{largeop: FALSE}],
oslash: ['2298',{largeop: FALSE}],
otimes: ['2297',{largeop: FALSE}],
ominus: ['2296',{largeop: FALSE}],
oplus: ['2295',{largeop: FALSE}],
mp: '2213',
pm: '00B1',
circ: '2218',
bigcirc: '25EF',
setminus: '2216',
cdot: '22C5',
ast: '2217',
times: '00D7',
star: '22C6',
// Relations
propto: '221D',
sqsubseteq: '2291',
sqsupseteq: '2292',
parallel: '2225',
mid: '2223',
dashv: '22A3',
vdash: '22A2',
leq: '2264',
le: '2264',
geq: '2265',
ge: '2265',
lt: '003C',
gt: '003E',
succ: '227B',
prec: '227A',
approx: '2248',
succeq: '2AB0', // or '227C',
preceq: '2AAF', // or '227D',
supset: '2283',
subset: '2282',
supseteq: '2287',
subseteq: '2286',
'in': '2208',
ni: '220B',
notin: '2209',
owns: '220B',
gg: '226B',
ll: '226A',
sim: '223C',
simeq: '2243',
perp: '22A5',
equiv: '2261',
asymp: '224D',
smile: '2323',
frown: '2322',
ne: '2260',
neq: '2260',
cong: '2245',
doteq: '2250',
bowtie: '22C8',
models: '22A8',
notChar: '0338',
// Arrows
Leftrightarrow: '21D4',
Leftarrow: '21D0',
Rightarrow: '21D2',
leftrightarrow: '2194',
leftarrow: '2190',
gets: '2190',
rightarrow: '2192',
to: '2192',
mapsto: '21A6',
leftharpoonup: '21BC',
leftharpoondown: '21BD',
rightharpoonup: '21C0',
rightharpoondown: '21C1',
nearrow: '2197',
searrow: '2198',
nwarrow: '2196',
swarrow: '2199',
rightleftharpoons: '21CC',
hookrightarrow: '21AA',
hookleftarrow: '21A9',
longleftarrow: '27F5',
Longleftarrow: '27F8',
longrightarrow: '27F6',
Longrightarrow: '27F9',
Longleftrightarrow: '27FA',
longleftrightarrow: '27F7',
longmapsto: '27FC',
// Misc.
ldots: '2026',
cdots: '22EF',
vdots: '22EE',
ddots: '22F1',
dots: '2026', // should be more complex than this
dotsc: '2026', // dots with commas
dotsb: '22EF', // dots with binary ops and relations
dotsm: '22EF', // dots with multiplication
dotsi: '22EF', // dots with integrals
dotso: '2026', // other dots
ldotp: ['002E', {texClass: MML.TEXCLASS.PUNCT}],
cdotp: ['22C5', {texClass: MML.TEXCLASS.PUNCT}],
colon: ['003A', {texClass: MML.TEXCLASS.PUNCT}]
},
mathchar7: {
Gamma: '0393',
Delta: '0394',
Theta: '0398',
Lambda: '039B',
Xi: '039E',
Pi: '03A0',
Sigma: '03A3',
Upsilon: '03A5',
Phi: '03A6',
Psi: '03A8',
Omega: '03A9',
'_': '005F',
'#': '0023',
'$': '0024',
'%': '0025',
'&': '0026',
And: '0026'
},
delimiter: {
'(': '(',
')': ')',
'[': '[',
']': ']',
'<': '27E8',
'>': '27E9',
'\\lt': '27E8',
'\\gt': '27E9',
'/': '/',
'|': ['|',{texClass:MML.TEXCLASS.ORD}],
'.': '',
'\\\\': '\\',
'\\lmoustache': '23B0', // non-standard
'\\rmoustache': '23B1', // non-standard
'\\lgroup': '27EE', // non-standard
'\\rgroup': '27EF', // non-standard
'\\arrowvert': '23D0',
'\\Arrowvert': '2016',
'\\bracevert': '23AA', // non-standard
'\\Vert': ['2225',{texClass:MML.TEXCLASS.ORD}],
'\\|': ['2225',{texClass:MML.TEXCLASS.ORD}],
'\\vert': ['|',{texClass:MML.TEXCLASS.ORD}],
'\\uparrow': '2191',
'\\downarrow': '2193',
'\\updownarrow': '2195',
'\\Uparrow': '21D1',
'\\Downarrow': '21D3',
'\\Updownarrow': '21D5',
'\\backslash': '\\',
'\\rangle': '27E9',
'\\langle': '27E8',
'\\rbrace': '}',
'\\lbrace': '{',
'\\}': '}',
'\\{': '{',
'\\rceil': '2309',
'\\lceil': '2308',
'\\rfloor': '230B',
'\\lfloor': '230A',
'\\lbrack': '[',
'\\rbrack': ']'
},
macros: {
displaystyle: ['SetStyle','D',TRUE,0],
textstyle: ['SetStyle','T',FALSE,0],
scriptstyle: ['SetStyle','S',FALSE,1],
scriptscriptstyle: ['SetStyle','SS',FALSE,2],
rm: ['SetFont',MML.VARIANT.NORMAL],
mit: ['SetFont',MML.VARIANT.ITALIC],
oldstyle: ['SetFont',MML.VARIANT.OLDSTYLE],
cal: ['SetFont',MML.VARIANT.CALIGRAPHIC],
it: ['SetFont',MML.VARIANT.ITALIC], // may need special handling
bf: ['SetFont',MML.VARIANT.BOLD],
bbFont: ['SetFont',MML.VARIANT.DOUBLESTRUCK],
scr: ['SetFont',MML.VARIANT.SCRIPT],
frak: ['SetFont',MML.VARIANT.FRAKTUR],
sf: ['SetFont',MML.VARIANT.SANSSERIF],
tt: ['SetFont',MML.VARIANT.MONOSPACE],
// font:
tiny: ['SetSize',0.5],
Tiny: ['SetSize',0.6], // non-standard
scriptsize: ['SetSize',0.7],
small: ['SetSize',0.85],
normalsize: ['SetSize',1.0],
large: ['SetSize',1.2],
Large: ['SetSize',1.44],
LARGE: ['SetSize',1.73],
huge: ['SetSize',2.07],
Huge: ['SetSize',2.49],
arcsin: ['NamedOp',0],
arccos: ['NamedOp',0],
arctan: ['NamedOp',0],
arg: ['NamedOp',0],
cos: ['NamedOp',0],
cosh: ['NamedOp',0],
cot: ['NamedOp',0],
coth: ['NamedOp',0],
csc: ['NamedOp',0],
deg: ['NamedOp',0],
det: 'NamedOp',
dim: ['NamedOp',0],
exp: ['NamedOp',0],
gcd: 'NamedOp',
hom: ['NamedOp',0],
inf: 'NamedOp',
ker: ['NamedOp',0],
lg: ['NamedOp',0],
lim: 'NamedOp',
liminf: ['NamedOp',null,'lim&thinsp;inf'],
limsup: ['NamedOp',null,'lim&thinsp;sup'],
ln: ['NamedOp',0],
log: ['NamedOp',0],
max: 'NamedOp',
min: 'NamedOp',
Pr: 'NamedOp',
sec: ['NamedOp',0],
sin: ['NamedOp',0],
sinh: ['NamedOp',0],
sup: 'NamedOp',
tan: ['NamedOp',0],
tanh: ['NamedOp',0],
limits: ['Limits',1],
nolimits: ['Limits',0],
overline: ['UnderOver','203E'],
underline: ['UnderOver','005F'],
overbrace: ['UnderOver','23DE',1],
underbrace: ['UnderOver','23DF',1],
overrightarrow: ['UnderOver','2192'],
underrightarrow: ['UnderOver','2192'],
overleftarrow: ['UnderOver','2190'],
underleftarrow: ['UnderOver','2190'],
overleftrightarrow: ['UnderOver','2194'],
underleftrightarrow: ['UnderOver','2194'],
overset: 'Overset',
underset: 'Underset',
stackrel: ['Macro','\\mathrel{\\mathop{#2}\\limits^{#1}}',2],
over: 'Over',
overwithdelims: 'Over',
atop: 'Over',
atopwithdelims: 'Over',
above: 'Over',
abovewithdelims: 'Over',
brace: ['Over','{','}'],
brack: ['Over','[',']'],
choose: ['Over','(',')'],
frac: 'Frac',
sqrt: 'Sqrt',
root: 'Root',
uproot: ['MoveRoot','upRoot'],
leftroot: ['MoveRoot','leftRoot'],
left: 'LeftRight',
right: 'LeftRight',
llap: 'Lap',
rlap: 'Lap',
raise: 'RaiseLower',
lower: 'RaiseLower',
moveleft: 'MoveLeftRight',
moveright: 'MoveLeftRight',
',': ['Spacer',MML.LENGTH.THINMATHSPACE],
':': ['Spacer',MML.LENGTH.THINMATHSPACE], // for LaTeX
'>': ['Spacer',MML.LENGTH.MEDIUMMATHSPACE],
';': ['Spacer',MML.LENGTH.THICKMATHSPACE],
'!': ['Spacer',MML.LENGTH.NEGATIVETHINMATHSPACE],
enspace: ['Spacer',".5em"],
quad: ['Spacer',"1em"],
qquad: ['Spacer',"2em"],
thinspace: ['Spacer',MML.LENGTH.THINMATHSPACE],
negthinspace: ['Spacer',MML.LENGTH.NEGATIVETHINMATHSPACE],
hskip: 'Hskip',
hspace: 'Hskip',
kern: 'Hskip',
mskip: 'Hskip',
mspace: 'Hskip',
mkern: 'Hskip',
Rule: ['Rule'],
Space: ['Rule','blank'],
big: ['MakeBig',MML.TEXCLASS.ORD,0.85],
Big: ['MakeBig',MML.TEXCLASS.ORD,1.15],
bigg: ['MakeBig',MML.TEXCLASS.ORD,1.45],
Bigg: ['MakeBig',MML.TEXCLASS.ORD,1.75],
bigl: ['MakeBig',MML.TEXCLASS.OPEN,0.85],
Bigl: ['MakeBig',MML.TEXCLASS.OPEN,1.15],
biggl: ['MakeBig',MML.TEXCLASS.OPEN,1.45],
Biggl: ['MakeBig',MML.TEXCLASS.OPEN,1.75],
bigr: ['MakeBig',MML.TEXCLASS.CLOSE,0.85],
Bigr: ['MakeBig',MML.TEXCLASS.CLOSE,1.15],
biggr: ['MakeBig',MML.TEXCLASS.CLOSE,1.45],
Biggr: ['MakeBig',MML.TEXCLASS.CLOSE,1.75],
bigm: ['MakeBig',MML.TEXCLASS.REL,0.85],
Bigm: ['MakeBig',MML.TEXCLASS.REL,1.15],
biggm: ['MakeBig',MML.TEXCLASS.REL,1.45],
Biggm: ['MakeBig',MML.TEXCLASS.REL,1.75],
mathord: ['TeXAtom',MML.TEXCLASS.ORD],
mathop: ['TeXAtom',MML.TEXCLASS.OP],
mathopen: ['TeXAtom',MML.TEXCLASS.OPEN],
mathclose: ['TeXAtom',MML.TEXCLASS.CLOSE],
mathbin: ['TeXAtom',MML.TEXCLASS.BIN],
mathrel: ['TeXAtom',MML.TEXCLASS.REL],
mathpunct: ['TeXAtom',MML.TEXCLASS.PUNCT],
mathinner: ['TeXAtom',MML.TEXCLASS.INNER],
vcenter: ['TeXAtom',MML.TEXCLASS.VCENTER],
mathchoice: ['Extension','mathchoice'],
buildrel: 'BuildRel',
hbox: ['HBox',0],
text: 'HBox',
mbox: ['HBox',0],
fbox: 'FBox',
strut: 'Strut',
mathstrut: ['Macro','\\vphantom{(}'],
phantom: 'Phantom',
vphantom: ['Phantom',1,0],
hphantom: ['Phantom',0,1],
smash: 'Smash',
acute: ['Accent', "02CA"], // or 0301
grave: ['Accent', "02CB"], // or 0300
ddot: ['Accent', "00A8"], // or 0308
tilde: ['Accent', "02DC"], // or 0303
bar: ['Accent', "02C9"], // or 0304
breve: ['Accent', "02D8"], // or 0306
check: ['Accent', "02C7"], // or 030C
hat: ['Accent', "02C6"], // or 0302
vec: ['Accent', "20D7"],
dot: ['Accent', "02D9"], // or 0307
widetilde: ['Accent', "02DC",1], // or 0303
widehat: ['Accent', "02C6",1], // or 0302
matrix: 'Matrix',
array: 'Matrix',
pmatrix: ['Matrix','(',')'],
cases: ['Matrix','{','',"left left",null,".1em"],
eqalign: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D'],
displaylines: ['Matrix',null,null,"center",null,".5em",'D'],
cr: 'Cr',
'\\': 'Cr',
newline: 'Cr',
hline: ['HLine','solid'],
hdashline: ['HLine','dashed'],
// noalign: 'HandleNoAlign',
eqalignno: ['Matrix',null,null,"right left right",MML.LENGTH.THICKMATHSPACE+" 3em",".5em",'D'],
leqalignno: ['Matrix',null,null,"right left right",MML.LENGTH.THICKMATHSPACE+" 3em",".5em",'D'],
// TeX substitution macros
bmod: ['Macro','\\mathbin{\\rm mod}'],
pmod: ['Macro','\\pod{{\\rm mod}\\kern 6mu #1}',1],
mod: ['Macro','\\mathchoice{\\kern18mu}{\\kern12mu}{\\kern12mu}{\\kern12mu}{\\rm mod}\\,\\,#1',1],
pod: ['Macro','\\mathchoice{\\kern18mu}{\\kern8mu}{\\kern8mu}{\\kern8mu}(#1)',1],
iff: ['Macro','\\;\\Longleftrightarrow\\;'],
skew: ['Macro','{{#2{#3\\mkern#1mu}\\mkern-#1mu}{}}',3],
mathcal: ['Macro','{\\cal #1}',1],
mathscr: ['Macro','{\\scr #1}',1],
mathrm: ['Macro','{\\rm #1}',1],
mathbf: ['Macro','{\\bf #1}',1],
mathbb: ['Macro','{\\bbFont #1}',1],
Bbb: ['Macro','{\\bbFont #1}',1],
mathit: ['Macro','{\\it #1}',1],
mathfrak: ['Macro','{\\frak #1}',1],
mathsf: ['Macro','{\\sf #1}',1],
mathtt: ['Macro','{\\tt #1}',1],
textrm: ['Macro','\\mathord{\\rm\\text{#1}}',1],
textit: ['Macro','\\mathord{\\it{\\text{#1}}}',1],
textbf: ['Macro','\\mathord{\\bf{\\text{#1}}}',1],
pmb: ['Macro','\\rlap{#1}\\kern1px{#1}',1],
TeX: ['Macro','T\\kern-.14em\\lower.5ex{E}\\kern-.115em X'],
LaTeX: ['Macro','L\\kern-.325em\\raise.21em{\\scriptstyle{A}}\\kern-.17em\\TeX'],
not: ['Macro','\\mathrel{\\rlap{\\kern.5em\\notChar}}'],
' ': ['Macro','\\text{ }'],
space: 'Tilde',
// LaTeX
begin: 'Begin',
end: 'End',
newcommand: ['Extension','newcommand'],
renewcommand: ['Extension','newcommand'],
newenvironment: ['Extension','newcommand'],
def: ['Extension','newcommand'],
verb: ['Extension','verb'],
boldsymbol: ['Extension','boldsymbol'],
tag: ['Extension','AMSmath'],
notag: ['Extension','AMSmath'],
label: ['Macro','',1], // not implemented yet
nonumber: ['Macro',''], // not implemented yet
// Extensions to TeX
unicode: ['Extension','unicode'],
color: 'Color',
href: ['Extension','HTML'],
'class': ['Extension','HTML'],
style: ['Extension','HTML'],
cssId: ['Extension','HTML'],
// bbox: ['Extension','bbox'],
require: 'Require'
},
environment: {
array: ['Array'],
matrix: ['Array',null,null,null,'c'],
pmatrix: ['Array',null,'(',')','c'],
bmatrix: ['Array',null,'[',']','c'],
Bmatrix: ['Array',null,'\\{','\\}','c'],
vmatrix: ['Array',null,'\\vert','\\vert','c'],
Vmatrix: ['Array',null,'\\Vert','\\Vert','c'],
cases: ['Array',null,'\\{','.','ll',null,".1em"],
eqnarray: ['Array',null,null,null,'rcl',MML.LENGTH.THICKMATHSPACE,".5em",'D'],
'eqnarray*': ['Array',null,null,null,'rcl',MML.LENGTH.THICKMATHSPACE,".5em",'D'],
equation: [null,'Equation'],
'equation*': [null,'Equation'],
align: ['ExtensionEnv',null,'AMSmath'],
'align*': ['ExtensionEnv',null,'AMSmath'],
aligned: ['ExtensionEnv',null,'AMSmath'],
multline: ['ExtensionEnv',null,'AMSmath'],
'multline*': ['ExtensionEnv',null,'AMSmath'],
split: ['ExtensionEnv',null,'AMSmath'],
gather: ['ExtensionEnv',null,'AMSmath'],
'gather*': ['ExtensionEnv',null,'AMSmath'],
gathered: ['ExtensionEnv',null,'AMSmath'],
alignat: ['ExtensionEnv',null,'AMSmath'],
'alignat*': ['ExtensionEnv',null,'AMSmath'],
alignedat: ['ExtensionEnv',null,'AMSmath']
},
p_height: 1.2 / .85 // cmex10 height plus depth over .85
});
//
// Add macros defined in the configuration
//
if (this.config.Macros) {
var MACROS = this.config.Macros;
for (var id in MACROS) {if (MACROS.hasOwnProperty(id)) {
if (typeof(MACROS[id]) === "string") {TEXDEF.macros[id] = ['Macro',MACROS[id]]}
else {TEXDEF.macros[id] = ["Macro"].concat(MACROS[id])}
}}
}
};
/************************************************************************/
/*
* The TeX Parser
*/
var PARSE = MathJax.Object.Subclass({
Init: function (string,env) {
this.string = string; this.i = 0; this.macroCount = 0;
var ENV; if (env) {ENV = {}; for (var id in env) {if (env.hasOwnProperty(id)) {ENV[id] = env[id]}}}
this.stack = TEX.Stack(ENV);
this.Parse();
this.Push(STACKITEM.stop());
},
Parse: function () {
var c;
while (this.i < this.string.length) {
c = this.string.charAt(this.i++);
if (TEXDEF.special[c]) {this[TEXDEF.special[c]](c)}
else if (TEXDEF.letter.test(c)) {this.Variable(c)}
else if (TEXDEF.digit.test(c)) {this.Number(c)}
else {this.Other(c)}
}
},
Push: function () {this.stack.Push.apply(this.stack,arguments)},
mml: function () {
if (this.stack.Top().type !== "mml") {return null}
return this.stack.Top().data[0];
},
mmlToken: function (token) {return token}, // used by boldsymbol extension
/************************************************************************/
/*
* Handle various token classes
*/
/*
* Lookup a control-sequence and process it
*/
ControlSequence: function (c) {
var name = this.GetCS(), mchar, def;
if (TEXDEF.macros[name]) { // javascript macro
var macro = TEXDEF.macros[name];
if (!(macro instanceof Array)) {macro = [macro]}
var fn = macro[0]; if (!(fn instanceof Function)) {fn = this[fn]}
fn.apply(this,["\\"+name].concat(macro.slice(1)));
} else if (TEXDEF.mathchar0mi[name]) { // normal mathchar (mi)
mchar = TEXDEF.mathchar0mi[name]; def = {mathvariant: MML.VARIANT.ITALIC};
if (mchar instanceof Array) {def = mchar[1]; mchar = mchar[0]}
this.Push(this.mmlToken(MML.mi(MML.entity("#x"+mchar)).With(def)));
} else if (TEXDEF.mathchar0mo[name]) { // normal mathchar (mo)
mchar = TEXDEF.mathchar0mo[name]; def = {stretchy: FALSE};
if (mchar instanceof Array) {def = mchar[1]; def.stretchy = FALSE; mchar = mchar[0]}
this.Push(this.mmlToken(MML.mo(MML.entity("#x"+mchar)).With(def)));
} else if (TEXDEF.mathchar7[name]) { // mathchar in current family
mchar = TEXDEF.mathchar7[name]; def = {mathvariant: MML.VARIANT.NORMAL};
if (mchar instanceof Array) {def = mchar[1]; mchar = mchar[0]}
if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
this.Push(this.mmlToken(MML.mi(MML.entity("#x"+mchar)).With(def)));
} else if (TEXDEF.delimiter["\\"+name] != null) { // delimiter
var delim = TEXDEF.delimiter["\\"+name]; def = {};
if (delim instanceof Array) {def = delim[1]; delim = delim[0]}
if (delim.length === 4) {delim = MML.entity('#x'+delim)} else {delim = MML.chars(delim)}
this.Push(this.mmlToken(MML.mo(delim).With({fence: FALSE, stretchy: FALSE}).With(def)));
} else { // error
this.csUndefined("\\"+name);
}
},
csUndefined: function (name) {
TEX.Error("Undefined control sequence "+name);
},
/*
* Handle a variable (a single letter)
*/
Variable: function (c) {
var def = {}; if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
this.Push(this.mmlToken(MML.mi(MML.chars(c)).With(def)));
},
/*
* Determine the extent of a number (pattern may need work)
*/
Number: function (c) {
var mml, n = this.string.slice(this.i-1).match(TEXDEF.number);
if (n) {mml = MML.mn(n[0].replace(/[{}]/g,"")); this.i += n[0].length - 1}
else {mml = MML.mo(MML.chars(c))}
if (this.stack.env.font) {mml.mathvariant = this.stack.env.font}
this.Push(this.mmlToken(mml));
},
/*
* Handle { and }
*/
Open: function (c) {this.Push(STACKITEM.open())},
Close: function (c) {this.Push(STACKITEM.close())},
/*
* Handle tilde and spaces
*/
Tilde: function (c) {this.Push(MML.mtext(MML.chars(NBSP)))},
Space: function (c) {},
/*
* Handle ^, _, and '
*/
Superscript: function (c) {
var position, base = this.stack.Prev(); if (!base) {base = MML.mi("")}
if (base.isEmbellishedWrapper) {base = base.data[0].data[0]}
if (base.type === "msubsup") {
if (base.data[base.sup]) {
if (!base.data[base.sup].isPrime) {TEX.Error("Double exponent: use braces to clarify")}
base = MML.msubsup(base,null,null);
}
position = base.sup;
} else if (base.movesupsub) {
if (base.type !== "munderover" || base.data[base.over])
{base = MML.munderover(base,null,null).With({movesupsub:TRUE})}
position = base.over;
} else {
base = MML.msubsup(base,null,null);
position = base.sup;
}
this.Push(STACKITEM.subsup(base).With({position: position}));
},
Subscript: function (c) {
var position, base = this.stack.Prev(); if (!base) {base = MML.mi("")}
if (base.isEmbellishedWrapper) {base = base.data[0].data[0]}
if (base.type === "msubsup") {
if (base.data[base.sub]) {TEX.Error("Double subscripts: use braces to clarify")}
position = base.sub;
} else if (base.movesupsub) {
if (base.type !== "munderover" || base.data[base.under])
{base = MML.munderover(base,null,null).With({movesupsub:TRUE})}
position = base.under;
} else {
base = MML.msubsup(base,null,null);
position = base.sub;
}
this.Push(STACKITEM.subsup(base).With({position: position}));
},
PRIME: String.fromCharCode(0x2032), SMARTQUOTE: String.fromCharCode(0x2019),
Prime: function (c) {
var base = this.stack.Prev(); if (!base) {base = MML.mi()}
if (base.type === "msubsup" && base.data[base.sup])
{TEX.Error("Prime causes double exponent: use braces to clarify")}
var sup = ""; this.i--;
do {sup += this.PRIME; this.i++, c = this.GetNext()}
while (c === "'" || c === this.SMARTQUOTE);
sup = this.mmlToken(MML.mo(MML.chars(sup)).With({isPrime: TRUE, variantForm: TEX.isSTIX}));
this.Push(MML.msubsup(base,null,sup));
},
/*
* Handle comments
*/
Comment: function (c) {
while (this.i < this.string.length && this.string.charAt(this.i) != "\n") {this.i++}
},
/*
* Handle hash marks outside of definitions
*/
Hash: function (c) {
TEX.Error("You can't use 'macro parameter character #' in math mode");
},
/*
* Handle other characters (as <mo> elements)
*/
Other: function (c) {
var def = {stretchy: false}, mo;
if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
if (TEXDEF.remap[c]) {
c = TEXDEF.remap[c];
if (c instanceof Array) {def = c[1]; c = c[0]}
mo = MML.mo(MML.entity('#x'+c));
} else {
mo = MML.mo(c);
}
if (mo.autoDefault("texClass",true) == "") {mo = MML.TeXAtom(mo)}
this.Push(this.mmlToken(mo.With(def)));
},
/************************************************************************/
/*
* Macros
*/
SetFont: function (name,font) {this.stack.env.font = font},
SetStyle: function (name,texStyle,style,level) {
this.stack.env.style = texStyle; this.stack.env.level = level;
this.Push(STACKITEM.style().With({styles: {displaystyle: style, scriptlevel: level}}));
},
SetSize: function (name,size) {
this.stack.env.size = size;
this.Push(STACKITEM.style().With({styles: {mathsize: size+"em"}})); // convert to absolute?
},
Color: function (name) {
var color = this.GetArgument(name);
var old = this.stack.env.color; this.stack.env.color = color;
var math = this.ParseArg(name);
if (old) {this.stack.env.color} else {delete this.stack.env.color}
this.Push(MML.mstyle(math).With({mathcolor: color}));
},
Spacer: function (name,space) {
this.Push(MML.mspace().With({width: space, mathsize: MML.SIZE.NORMAL, scriptlevel:1}));
},
LeftRight: function (name) {
this.Push(STACKITEM[name.substr(1)]().With({delim: this.GetDelimiter(name)}));
},
NamedOp: function (name,limits,id) {
var underover = (limits != null && limits === 0 ? FALSE : TRUE);
if (!id) {id = name.substr(1)}; limits = ((limits || limits == null) ? TRUE : FALSE);
id = id.replace(/&thinsp;/,String.fromCharCode(0x2006));
var mml = MML.mo(id).With({
movablelimits: limits,
movesupsub: underover,
form: MML.FORM.PREFIX,
texClass: MML.TEXCLASS.OP
});
mml.useMMLspacing &= ~mml.SPACE_ATTR.form; // don't count this explicit form setting
this.Push(this.mmlToken(mml));
},
Limits: function (name,limits) {
var op = this.stack.Prev("nopop");
if (op.texClass !== MML.TEXCLASS.OP) {TEX.Error(name+" is allowed only on operators")}
op.movesupsub = (limits ? TRUE : FALSE);
op.movablelimits = FALSE;
},
Over: function (name,open,close) {
var mml = STACKITEM.over().With({name: name});
if (open || close) {
mml.open = open; mml.close = close;
} else if (name.match(/withdelims$/)) {
mml.open = this.GetDelimiter(name);
mml.close = this.GetDelimiter(name);
}
if (name.match(/^\\above/)) {mml.thickness = this.GetDimen(name)}
else if (name.match(/^\\atop/) || open || close) {mml.thickness = 0}
this.Push(mml);
},
Frac: function (name) {
var num = this.ParseArg(name);
var den = this.ParseArg(name);
this.Push(MML.mfrac(num,den));
},
Sqrt: function (name) {
var n = this.GetBrackets(name), mml = this.ParseArg(name);
if (n == "") {mml = MML.msqrt.apply(MML,mml.array())}
else {mml = MML.mroot(mml,this.parseRoot(n))}
this.Push(mml);
},
Root: function (name) {
var n = this.GetUpTo(name,"\\of");
var arg = this.ParseArg(name);
this.Push(MML.mroot(arg,this.parseRoot(n)));
},
parseRoot: function (n) {
var env = this.stack.env, inRoot = env.inRoot; env.inRoot = true;
var parser = TEX.Parse(n,env); n = parser.mml(); var global = parser.stack.global;
if (global.leftRoot || global.upRoot) {
n = MML.mpadded(n);
if (global.leftRoot) {n.width = global.leftRoot}
if (global.upRoot) {n.voffset = global.upRoot; n.height = global.upRoot}
}
env.inRoot = inRoot;
return n;
},
MoveRoot: function (name,id) {
if (!this.stack.env.inRoot) TEX.Error(name+" can appear only within a root");
if (this.stack.global[id]) TEX.Error("Multiple use of "+name);
var n = this.GetArgument(name);
if (!n.match(/-?[0-9]+/)) TEX.Error("The argument to "+name+" must be an integer");
n = (n/15)+"em";
if (n.substr(0,1) !== "-") {n = "+"+n}
this.stack.global[id] = n;
},
Accent: function (name,accent,stretchy) {
var c = this.ParseArg(name);
var def = {accent: true}; if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
var mml = this.mmlToken(MML.mo(MML.entity("#x"+accent)).With(def));
mml.stretchy = (stretchy ? TRUE : FALSE);
this.Push(MML.munderover(c,null,mml).With({accent: TRUE}));
},
UnderOver: function (name,c,stack) {
var pos = {o: "over", u: "under"}[name.charAt(1)];
var base = this.ParseArg(name);
if (base.Get("movablelimits")) {base.movablelimits = false}
var mml = MML.munderover(base,null,null);
if (stack) {mml.movesupsub = TRUE}
mml.data[mml[pos]] =
this.mmlToken(MML.mo(MML.entity("#x"+c)).With({stretchy: TRUE, accent: (pos == "under")}));
this.Push(mml);
},
Overset: function (name) {
var top = this.ParseArg(name), base = this.ParseArg(name);
this.Push(MML.munderover(base,null,top));
},
Underset: function (name) {
var bot = this.ParseArg(name), base = this.ParseArg(name);
this.Push(MML.munderover(base,bot,null));
},
TeXAtom: function (name,mclass) {
var def = {texClass: mclass}, mml;
if (mclass == MML.TEXCLASS.OP) {
def.movesupsub = def.movablelimits = TRUE;
var arg = this.GetArgument(name);
var match = arg.match(/^\s*\\rm\s+([a-zA-Z0-9 ]+)$/);
if (match) {
mml = this.mmlToken(MML.mo(match[1]).With({
movablelimits: TRUE, movesupsub: TRUE,
mathvariant: MML.VARIANT.NORMAL,
form: MML.FORM.PREFIX,
texClass: MML.TEXCLASS.OP
}));
mml.useMMLspacing &= ~mml.SPACE_ATTR.form; // don't count this explicit form setting
} else {mml = MML.TeXAtom(TEX.Parse(arg,this.stack.env).mml()).With(def)}
} else {mml = MML.TeXAtom(this.ParseArg(name)).With(def)}
this.Push(mml);
},
Strut: function (name) {
this.Push(MML.mpadded(MML.mrow()).With({height: "8.6pt", depth: "3pt", width: 0}));
},
Phantom: function (name,v,h) {
var box = MML.mphantom(this.ParseArg(name));
if (v || h) {
box = MML.mpadded(box);
if (h) {box.height = box.depth = 0}
if (v) {box.width = 0}
}
this.Push(box);
},
Smash: function (name) {
var bt = this.trimSpaces(this.GetBrackets(name));
var smash = MML.mpadded(this.ParseArg(name));
switch (bt) {
case "b": smash.depth = 0; break;
case "t": smash.height = 0; break;
default: smash.height = smash.depth = 0;
}
this.Push(smash);
},
Lap: function (name) {
var mml = MML.mpadded(this.ParseArg(name)).With({width: 0});
if (name === "\\llap") {mml.lspace = "-1 width"}
this.Push(mml);
},
RaiseLower: function (name) {
var h = this.GetDimen(name);
var item = STACKITEM.position().With({name: name, move: 'vertical'});
if (h.charAt(0) === '-') {h = h.slice(1); name = {raise: "\\lower", lower: "\\raise"}[name.substr(1)]}
if (name === "\\lower") {item.dh = '-'+h; item.dd = '+'+h} else {item.dh = '+'+h; item.dd = '-'+h}
this.Push(item);
},
MoveLeftRight: function (name) {
var h = this.GetDimen(name);
var nh = (h.charAt(0) === '-' ? h.slice(1) : '-'+h);
if (name === "\\moveleft") {var tmp = h; h = nh; nh = tmp}
this.Push(STACKITEM.position().With({
name: name, move: 'horizontal',
left: MML.mspace().With({width: h, mathsize: MML.SIZE.NORMAL, scriptlevel:1}),
right: MML.mspace().With({width: nh, mathsize: MML.SIZE.NORMAL, scriptlevel:1})
}));
},
Hskip: function (name) {
this.Push(MML.mspace().With({
width: this.GetDimen(name), mathsize: MML.SIZE.NORMAL, scriptlevel:0
}));
},
Rule: function (name,style) {
var w = this.GetDimen(name),
h = this.GetDimen(name),
d = this.GetDimen(name);
var mml, def = {width:w, height:h, depth:d};
if (style !== 'blank') {
mml = MML.mpadded(MML.mrow()).With(def);
if (parseFloat(w) && parseFloat(h)+parseFloat(d))
{mml = MML.mstyle(mml).With({mathbackground:(this.stack.env.color || "black")})}
} else {
mml = MML.mspace().With(def);
}
this.Push(mml);
},
MakeBig: function (name,mclass,size) {
size *= TEXDEF.p_height;
size = String(size).replace(/(\.\d\d\d).+/,'$1')+"em";
var delim = this.GetDelimiter(name);
this.Push(MML.TeXAtom(MML.mo(delim).With({
minsize: size, maxsize: size, scriptlevel: 0,
fence: TRUE, stretchy: TRUE, symmetric: TRUE
})).With({texClass: mclass}));
},
BuildRel: function (name) {
var top = this.ParseUpTo(name,"\\over");
var bot = this.ParseArg(name);
this.Push(MML.TeXAtom(MML.munderover(bot,null,top)).With({mclass: MML.TEXCLASS.REL}));
},
HBox: function (name,style) {
this.Push.apply(this,this.InternalMath(this.GetArgument(name),style));
},
FBox: function (name) {
this.Push(MML.menclose.apply(MML,this.InternalMath(this.GetArgument(name))).With({notation:"box"}));
},
Require: function (name) {
var file = this.GetArgument(name); // @@@ FIXME: check for OK URL
this.Extension(null,file);
},
Extension: function (name,file,array) {
if (name && !typeof(name) === "string") {name = name.name}
file = TEX.extensionDir+"/"+file;
if (!file.match(/\.js$/)) {file += ".js"}
if (!MathJax.Ajax.loaded[MathJax.Ajax.fileURL(file)]) {
if (name != null) {delete TEXDEF[array || 'macros'][name.replace(/^\\/,"")]}
MathJax.Hub.RestartAfter(MathJax.Ajax.Require(file));
}
},
Macro: function (name,macro,argcount) {
if (argcount) {
var args = [];
for (var i = 0; i < argcount; i++) {args.push(this.GetArgument(name))}
macro = this.SubstituteArgs(args,macro);
}
this.string = this.AddArgs(macro,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?")}
},
Matrix: function (name,open,close,align,spacing,vspacing,style) {
var c = this.GetNext(); if (c === "") {TEX.Error("Missing argument for "+name)}
if (c === "{") {this.i++} else {this.string = c+"}"+this.string.slice(this.i+1); this.i = 0}
var array = STACKITEM.array().With({
requireClose: TRUE,
arraydef: {
rowspacing: (vspacing||"4pt"),
columnspacing: (spacing||"1em")
}
});
if (open || close) {array.open = open; array.close = close}
if (style === "D") {array.arraydef.displaystyle = TRUE}
if (align != null) {array.arraydef.columnalign = align}
this.Push(array);
},
Entry: function (name) {
this.Push(STACKITEM.cell().With({isEntry: TRUE, name: name}));
},
Cr: function (name) {
this.Push(STACKITEM.cell().With({isCR: TRUE, name: name}));
},
HLine: function (name,style) {
if (style == null) {style = "solid"}
var top = this.stack.Top();
if (top.type !== "array" || top.data.length) {TEX.Error("Misplaced "+name)}
if (top.table.length == 0) {
top.arraydef.frame = style;
} else {
var lines = (top.arraydef.rowlines ? top.arraydef.rowlines.split(/ /) : []);
while (lines.length < top.table.length) {lines.push("none")}
lines[top.table.length-1] = style;
top.arraydef.rowlines = lines.join(' ');
}
},
/************************************************************************/
/*
* LaTeX environments
*/
Begin: function (name) {
var env = this.GetArgument(name);
if (env.match(/[^a-z*]/i)) {TEX.Error('Invalid environment name "'+env+'"')}
if (!TEXDEF.environment[env]) {TEX.Error('Unknown environment "'+env+'"')}
if (++this.macroCount > TEX.config.MAXMACROS)
{TEX.Error("MathJax maximum substitution count exceeded; is there a recursive latex environment?")}
var cmd = TEXDEF.environment[env]; if (!(cmd instanceof Array)) {cmd = [cmd]}
var mml = STACKITEM.begin().With({name: env, end: cmd[1], parse:this});
if (cmd[0] && this[cmd[0]]) {mml = this[cmd[0]].apply(this,[mml].concat(cmd.slice(2)))}
this.Push(mml);
},
End: function (name) {
this.Push(STACKITEM.end().With({name: this.GetArgument(name)}));
},
Equation: function (begin,row) {return row},
ExtensionEnv: function (begin,file) {this.Extension(begin.name,file,"environment")},
Array: function (begin,open,close,align,spacing,vspacing,style,raggedHeight) {
if (!align) {align = this.GetArgument("\\begin{"+begin.name+"}")}
var lines = ("c"+align).replace(/[^clr|:]/g,'').replace(/[^|:]([|:])+/g,'$1');
align = align.replace(/[^clr]/g,'').split('').join(' ');
align = align.replace(/l/g,'left').replace(/r/g,'right').replace(/c/g,'center');
var array = STACKITEM.array().With({
arraydef: {
columnalign: align,
columnspacing: (spacing||"1em"),
rowspacing: (vspacing||"4pt")
}
});
if (lines.match(/[|:]/)) {
var frame = (lines.charAt(0)+lines.charAt(lines.length-1)).replace(/[^|:]/g,"");
if (frame !== "") {
array.arraydef.frame = {'|':'solid', ':':'dashed'}[frame.charAt(0)];
array.arraydef.framespacing = ".5em .5ex"
}
lines = lines.substr(1,lines.length-2);
array.arraydef.columnlines =
lines.split('').join(' ').replace(/[^|: ]/g,'none').replace(/\|/g,'solid').replace(/:/g,'dashed');
}
if (open) {array.open = this.convertDelimiter(open)}
if (close) {array.close = this.convertDelimiter(close)}
if (style === "D") {array.arraydef.displaystyle = TRUE}
if (style === "S") {array.arraydef.scriptlevel = 1} // FIXME: should use mstyle?
if (raggedHeight) {array.arraydef.useHeight = FALSE}
this.Push(begin);
return array;
},
/************************************************************************/
/*
* String handling routines
*/
/*
* Convert delimiter to character
*/
convertDelimiter: function (c) {
if (c) {c = TEXDEF.delimiter[c]}
if (c == null) {return null}
if (c instanceof Array) {c = c[0]}
if (c.length === 4) {c = String.fromCharCode(parseInt(c,16))}
return c;
},
/*
* Trim spaces from a string
*/
trimSpaces: function (text) {
if (typeof(text) != 'string') {return text}
return text.replace(/^\s+|\s+$/g,'');
},
/*
* Check if the next character is a space
*/
nextIsSpace: function () {
return this.string.charAt(this.i).match(/[ \n\r\t]/);
},
/*
* Get the next non-space character
*/
GetNext: function () {
while (this.nextIsSpace()) {this.i++}
return this.string.charAt(this.i);
},
/*
* Get and return a control-sequence name
*/
GetCS: function () {
var CS = this.string.slice(this.i).match(/^([a-z]+|.) ?/i);
if (CS) {this.i += CS[1].length; return CS[1]} else {this.i++; return " "}
},
/*
* Get and return a TeX argument (either a single character or control sequence,
* or the contents of the next set of braces).
*/
GetArgument: function (name,noneOK) {
switch (this.GetNext()) {
case "":
if (!noneOK) {TEX.Error("Missing argument for "+name)}
return null;
case '}':
if (!noneOK) {TEX.Error("Extra close brace or missing open brace")}
return null;
case '\\':
this.i++; return "\\"+this.GetCS();
case '{':
var j = ++this.i, parens = 1;
while (this.i < this.string.length) {
switch (this.string.charAt(this.i++)) {
case '\\': this.i++; break;
case '{': parens++; break;
case '}':
if (parens == 0) {TEX.Error("Extra close brace")}
if (--parens == 0) {return this.string.slice(j,this.i-1)}
break;
}
}
TEX.Error("Missing close brace");
break;
}
return this.string.charAt(this.i++);
},
/*
* Get an optional LaTeX argument in brackets
*/
GetBrackets: function (name) {
if (this.GetNext() != '[') {return ''};
var j = ++this.i, parens = 0;
while (this.i < this.string.length) {
switch (this.string.charAt(this.i++)) {
case '{': parens++; break;
case '\\': this.i++; break;
case '}':
if (parens-- <= 0) {TEX.Error("Extra close brace while looking for ']'")}
break;
case ']':
if (parens == 0) {return this.string.slice(j,this.i-1)}
break;
}
}
TEX.Error("Couldn't find closing ']' for argument to "+name);
},
/*
* Get the name of a delimiter (check it in the delimiter list).
*/
GetDelimiter: function (name) {
while (this.nextIsSpace()) {this.i++}
var c = this.string.charAt(this.i);
if (this.i < this.string.length) {
this.i++; if (c == "\\") {c += this.GetCS(name)}
if (TEXDEF.delimiter[c] != null) {return this.convertDelimiter(c)}
}
TEX.Error("Missing or unrecognized delimiter for "+name);
},
/*
* Get a dimension (including its units).
*/
GetDimen: function (name) {
var dimen;
if (this.nextIsSpace()) {this.i++}
if (this.string.charAt(this.i) == '{') {
dimen = this.GetArgument(name);
if (dimen.match(/^\s*([-+]?(\.\d+|\d+(\.\d*)?))\s*(pt|em|ex|mu|px|mm|cm|in|pc)\s*$/))
{return dimen.replace(/ /g,"")}
} else {
dimen = this.string.slice(this.i);
var match = dimen.match(/^\s*(([-+]?(\.\d+|\d+(\.\d*)?))\s*(pt|em|ex|mu|px|mm|cm|in|pc)) ?/);
if (match) {
this.i += match[0].length;
return match[1].replace(/ /g,"");
}
}
TEX.Error("Missing dimension or its units for "+name);
},
/*
* Get everything up to the given control sequence (token)
*/
GetUpTo: function (name,token) {
while (this.nextIsSpace()) {this.i++}
var j = this.i, k, c, parens = 0;
while (this.i < this.string.length) {
k = this.i; c = this.string.charAt(this.i++);
switch (c) {
case '\\': c += this.GetCS(); break;
case '{': parens++; break;
case '}':
if (parens == 0) {TEX.Error("Extra close brace while looking for "+token)}
parens--;
break;
}
if (parens == 0 && c == token) {return this.string.slice(j,k)}
}
TEX.Error("Couldn't find "+token+" for "+name);
},
/*
* Parse various substrings
*/
ParseArg: function (name) {return TEX.Parse(this.GetArgument(name),this.stack.env).mml()},
ParseUpTo: function (name,token) {return TEX.Parse(this.GetUpTo(name,token),this.stack.env).mml()},
/*
* Break up a string into text and math blocks
* @@@ FIXME: skip over braced groups? @@@
* @@@ FIXME: pass environment to TEX.Parse? @@@
*/
InternalMath: function (text,level) {
var def = {displaystyle: FALSE}; if (level != null) {def.scriptlevel = level}
if (this.stack.env.font) {def.mathvariant = this.stack.env.font}
if (!text.match(/\$|\\\(/)) {return [this.InternalText(text,def)]}
var i = 0, k = 0, c, match = '';
var mml = [];
while (i < text.length) {
c = text.charAt(i++);
if (c === '$') {
if (match === '$') {
mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-1)).mml().With(def)));
match = ''; k = i;
} else if (match === '') {
if (k < i-1) {mml.push(this.InternalText(text.slice(k,i-1),def))}
match = '$'; k = i;
}
} else if (c === '\\') {
c = text.charAt(i++);
if (c === '(' && match === '') {
if (k < i-2) {mml.push(this.InternalText(text.slice(k,i-2),def))}
match = ')'; k = i;
} else if (c === ')' && match === ')') {
mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-2)).mml().With(def)));
match = ''; k = i;
}
}
}
if (match !== '') {TEX.Error("Math not terminated in text box")}
if (k < text.length) {mml.push(this.InternalText(text.slice(k),def))}
return mml;
},
InternalText: function (text,def) {
text = text.replace(/^\s+/,NBSP).replace(/\s+$/,NBSP);
return MML.mtext(MML.chars(text)).With(def);
},
/*
* Replace macro paramters with their values
*/
SubstituteArgs: function (args,string) {
var text = ''; var newstring = ''; var c; var i = 0;
while (i < string.length) {
c = string.charAt(i++);
if (c === "\\") {text += c + string.charAt(i++)}
else if (c === '#') {
c = string.charAt(i++);
if (c === '#') {text += c} else {
if (!c.match(/[1-9]/) || c > args.length)
{TEX.Error("Illegal macro parameter reference")}
newstring = this.AddArgs(this.AddArgs(newstring,text),args[c-1]);
text = '';
}
} else {text += c}
}
return this.AddArgs(newstring,text);
},
/*
* Make sure that macros are followed by a space if their names
* could accidentally be continued into the following text.
*/
AddArgs: function (s1,s2) {
if (s2.match(/^[a-z]/i) && s1.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i)) {s1 += ' '}
if (s1.length + s2.length > TEX.config.MAXBUFFER)
{TEX.Error("MathJax internal buffer size exceeded; is there a recursive macro call?")}
return s1+s2;
}
});
/************************************************************************/
TEX.Augment({
Stack: STACK, Parse: PARSE, Definitions: TEXDEF, Startup: STARTUP,
config: {
MAXMACROS: 10000, // maximum number of macro substitutions per equation
MAXBUFFER: 5*1024 // maximum size of TeX string to process
},
Translate: function (script) {
var mml, math = script.innerHTML.replace(/^\s+/,"").replace(/\s+$/,"");
if (MathJax.Hub.Browser.isKonqueror)
{math = math.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&amp;/g,"&")}
var displaystyle =
(script.type.replace(/\n/g," ").match(/(;|\s|\n)mode\s*=\s*display(;|\s|\n|$)/) != null);
math = TEX.prefilterMath(math,displaystyle,script);
try {
mml = TEX.Parse(math).mml();
// mml = MML.semantics(mml,MML.annotation(math).With({encoding:"application:x-tex"}));
} catch(err) {
if (!err.texError) {throw err}
mml = this.formatError(err,math,displaystyle,script);
}
if (mml.inferred) {mml = MML.apply(MathJax.ElementJax,mml.data)} else {mml = MML(mml)}
if (displaystyle) {mml.root.display = "block"}
return this.postfilterMath(mml,displaystyle,script);
},
prefilterMath: function (math,displaystyle,script) {
// avoid parsing super- and subscript numbers as a unit
return math.replace(/([_^]\s*\d)([0-9.,])/g,"$1 $2");
},
postfilterMath: function (math,displaystyle,script) {
this.combineRelations(math.root);
return math;
},
formatError: function (err,math,displaystyle,script) {
return MML.merror(err.message.replace(/\n.*/,""));
},
Error: function (message) {
throw MathJax.Hub.Insert(Error(message),{texError: TRUE});
},
Macro: function (name,def,argn) {
TEXDEF.macros[name] = ['Macro'].concat([].slice.call(arguments,1));
},
combineRelations: function (mml) {
for (var i = 0, m = mml.data.length; i < m; i++) {
if (mml.data[i]) {
if (mml.isa(MML.mrow)) {
while (i+1 < m && mml.data[i+1] &&
mml.data[i].isa(MML.mo) && mml.data[i+1].isa(MML.mo) &&
mml.data[i].Get("texClass") === MML.TEXCLASS.REL &&
mml.data[i+1].Get("texClass") === MML.TEXCLASS.REL) {
mml.data[i].Append.apply(mml.data[i],mml.data[i+1].data);
mml.data.splice(i+1,1); m--;
}
}
if (!mml.data[i].isToken) {this.combineRelations(mml.data[i])}
}
}
}
});
TEX.loadComplete("jax.js");
})(MathJax.InputJax.TeX);
Reference in a new issue Copy permalink