// @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7dn=apache-2.0.txt Apache-2.0 /* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */ /* vim: set ts=2 et sw=2 tw=80: */ /************************************************************* * * MathJax/jax/input/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-2020 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ (function (TEX,HUB,AJAX) { var MML, NBSP = "\u00A0"; var _ = function (id) { return MathJax.Localization._.apply(MathJax.Localization, [["TeX", id]].concat([].slice.call(arguments,1))); }; var isArray = MathJax.Object.isArray; var STACK = MathJax.Object.Subclass({ Init: function (env,inner) { this.global = {isInner: inner}; this.data = [STACKITEM.start(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) continue; 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) { if (item.copyEnv !== false) { 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", endError: /*_()*/ ["ExtraOpenMissingClose","Extra open brace or missing close brace"], closeError: /*_()*/ ["ExtraCloseMissingOpen","Extra close brace or missing open brace"], rightError: /*_()*/ ["MissingLeftExtraRight","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) { if (item.linebreak) {return false} TEX.Error(["Misplaced","Misplaced %1",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, Init: function (global) { this.SUPER(arguments).Init.call(this); this.global = global; }, 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: /*_()*/ ["ExtraOpenMissingClose","Extra open brace or missing close brace"], checkItem: function (item) { if (item.type === "close") { var mml = this.mmlData(); 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.prime = STACKITEM.Subclass({ type: "prime", checkItem: function (item) { if (this.data[0].type !== "msubsup") {return [MML.msup(this.data[0],this.data[1]),item]} this.data[0].SetData(this.data[0].sup,this.data[1]); return [this.data[0],item]; } }); STACKITEM.subsup = STACKITEM.Subclass({ type: "subsup", stopError: /*_()*/ ["MissingScript","Missing superscript or subscript argument"], supError: /*_()*/ ["MissingOpenForSup","Missing open brace for superscript"], subError: /*_()*/ ["MissingOpenForSub","Missing open brace for subscript"], checkItem: function (item) { if (item.type === "open" || item.type === "left") {return true} if (item.type === "mml") { if (this.primes) { if (this.position !== 2) {this.data[0].SetData(2,this.primes)} else {item.data[0] = MML.mrow(this.primes.With({variantForm:true}),item.data[0])} } this.data[0].SetData(this.position,item.data[0]); if (this.movesupsub != null) {this.data[0].movesupsub = this.movesupsub} return STACKITEM.mml(this.data[0]); } if (this.SUPER(arguments).checkItem.call(this,item)) {TEX.Error(this[["","subError","supError"][this.position]])} }, Pop: function () {} }); STACKITEM.over = STACKITEM.Subclass({ type: "over", isClose: true, name: "\\over", checkItem: function (item,stack) { if (item.type === "over") {TEX.Error(["AmbiguousUseOf","Ambiguous use of %1",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.texWithDelims = true; mml = TEX.fixedFence(this.open,mml,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: /*_()*/ ["ExtraLeftMissingRight", "Extra \\left or missing \\right"], checkItem: function (item) { if (item.type === "right") {return STACKITEM.mml(TEX.fenced(this.delim,this.mmlData(),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(["EnvBadEnd","\\begin{%1} ended with \\end{%2}",this.name,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(["EnvMissingEnd","Missing \\end{%1}",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(["MissingBoxFor","Missing box for %1",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, copyEnv: false, arraydef: {}, Init: function () { this.table = []; this.row = []; this.frame = []; this.hfill = []; 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 scriptlevel = this.arraydef.scriptlevel; delete this.arraydef.scriptlevel; var mml = MML.mtable.apply(MML,this.table).With(this.arraydef); if (this.frame.length === 4) { mml.frame = (this.frame.dashed ? "dashed" : "solid"); } else if (this.frame.length) { mml.hasFrame = true; if (this.arraydef.rowlines) {this.arraydef.rowlines = this.arraydef.rowlines.replace(/none( none)+$/,"none")} mml = MML.menclose(mml).With({notation: this.frame.join(" "), isFrame: true}); if ((this.arraydef.columnlines||"none") != "none" || (this.arraydef.rowlines||"none") != "none") {mml.padding = 0} // HTML-CSS jax implements this } if (scriptlevel) {mml = MML.mstyle(mml).With({scriptlevel: scriptlevel})} if (this.open || this.close) {mml = TEX.fenced(this.open,mml,this.close)} mml = STACKITEM.mml(mml); if (this.requireClose) { if (item.type === 'close') {return mml} TEX.Error(["MissingCloseBrace","Missing close brace"]); } return [mml,item]; } return this.SUPER(arguments).checkItem.call(this,item); }, EndEntry: function () { var mtd = MML.mtd.apply(MML,this.data); if (this.hfill.length) { if (this.hfill[0] === 0) mtd.columnalign = "right"; if (this.hfill[this.hfill.length-1] === this.data.length) mtd.columnalign = (mtd.columnalign ? "center" : "left"); } this.row.push(mtd); this.data = []; this.hfill = []; }, EndRow: function () { var mtr = MML.mtr; if (this.isNumbered && this.row.length === 3) { this.row.unshift(this.row.pop()); // move equation number to first position mtr = MML.mlabeledtr; } this.table.push(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.frame.push("bottom"); lines.pop(); this.arraydef.rowlines = lines.join(' '); } else if (lines.length < this.table.length-1) { this.arraydef.rowlines += " none"; } } if (this.rowspacing) { var rows = this.arraydef.rowspacing.split(/ /); while (rows.length < this.table.length) {rows.push(this.rowspacing+"em")} this.arraydef.rowspacing = rows.join(' '); } }, 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, Add: function () {this.data.push.apply(this.data,arguments); return this} }); STACKITEM.fn = STACKITEM.Subclass({ type: "fn", checkItem: function (item) { if (this.data[0]) { if (item.isOpen) {return true} if (item.type !== "fn") { if (item.type !== "mml" || !item.data[0]) {return [this.data[0],item]} if (item.data[0].isa(MML.mspace)) {return [this.data[0],item]} var mml = item.data[0]; if (mml.isEmbellished()) {mml = mml.CoreMO()} if ([0,0,1,1,0,1,1,0,0,0][mml.Get("texClass")]) {return [this.data[0],item]} } return [this.data[0],MML.mo(MML.entity("#x2061")).With({texClass:MML.TEXCLASS.NONE}),item]; } return this.SUPER(arguments).checkItem.apply(this,arguments); } }); STACKITEM.not = STACKITEM.Subclass({ type: "not", checkItem: function (item) { var mml, c; if (item.type === "open" || item.type === "left") {return true} if (item.type === "mml" && item.data[0].type.match(/^(mo|mi|mtext)$/)) { mml = item.data[0], c = mml.data.join(""); if (c.length === 1 && !mml.movesupsub && mml.data.length === 1) { c = STACKITEM.not.remap[c.charCodeAt(0)]; if (c) {mml.SetData(0,MML.chars(String.fromCharCode(c)))} else {mml.Append(MML.chars("\u0338"))} return item; } } // \mathrel{\rlap{\notChar}} mml = MML.mpadded(MML.mtext("\u29F8")).With({width:0}); mml = MML.TeXAtom(mml).With({texClass:MML.TEXCLASS.REL}); return [mml,item]; } }); STACKITEM.not.remap = { 0x2190:0x219A, 0x2192:0x219B, 0x2194:0x21AE, 0x21D0:0x21CD, 0x21D2:0x21CF, 0x21D4:0x21CE, 0x2208:0x2209, 0x220B:0x220C, 0x2223:0x2224, 0x2225:0x2226, 0x223C:0x2241, 0x007E:0x2241, 0x2243:0x2244, 0x2245:0x2247, 0x2248:0x2249, 0x224D:0x226D, 0x003D:0x2260, 0x2261:0x2262, 0x003C:0x226E, 0x003E:0x226F, 0x2264:0x2270, 0x2265:0x2271, 0x2272:0x2274, 0x2273:0x2275, 0x2276:0x2278, 0x2277:0x2279, 0x227A:0x2280, 0x227B:0x2281, 0x2282:0x2284, 0x2283:0x2285, 0x2286:0x2288, 0x2287:0x2289, 0x22A2:0x22AC, 0x22A8:0x22AD, 0x22A9:0x22AE, 0x22AB:0x22AF, 0x227C:0x22E0, 0x227D:0x22E1, 0x2291:0x22E2, 0x2292:0x22E3, 0x22B2:0x22EA, 0x22B3:0x22EB, 0x22B4:0x22EC, 0x22B5:0x22ED, 0x2203:0x2204 }; STACKITEM.dots = STACKITEM.Subclass({ type: "dots", checkItem: function (item) { if (item.type === "open" || item.type === "left") {return true} var dots = this.ldots; if (item.type === "mml" && item.data[0].isEmbellished()) { var tclass = item.data[0].CoreMO().Get("texClass"); if (tclass === MML.TEXCLASS.BIN || tclass === MML.TEXCLASS.REL) {dots = this.cdots} } return [dots,item]; } }); var TEXDEF = { // // Add new definitions without overriding user-defined ones // Add: function (src,dst,nouser) { if (!dst) {dst = this} for (var id in src) {if (src.hasOwnProperty(id)) { if (typeof src[id] === 'object' && !isArray(src[id]) && (typeof dst[id] === 'object' || typeof dst[id] === 'function')) {this.Add(src[id],dst[id],src[id],nouser)} else if (!dst[id] || !dst[id].isUser || !nouser) {dst[id] = src[id]} }} return dst; } }; var STARTUP = function () { MML = MathJax.ElementJax.mml; 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', '\u00A0': 'Space', '\u2019': 'Prime' }, remap: { '-': '2212', '*': '2217', '`': '2018' // map ` to back quote }, 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',{mathvariant: MML.VARIANT.NORMAL}], aleph: ['2135',{mathvariant: MML.VARIANT.NORMAL}], hbar: ['210F',{variantForm:true}], 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, variantForm:true}], 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, variantForm:true}], 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',{variantForm:true}], 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: '29F8', // 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', 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': ['2016',{texClass:MML.TEXCLASS.ORD}], '\\|': ['2016',{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',"-tex-mathit"], // needs 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: ['NamedFn'], arccos: ['NamedFn'], arctan: ['NamedFn'], arg: ['NamedFn'], cos: ['NamedFn'], cosh: ['NamedFn'], cot: ['NamedFn'], coth: ['NamedFn'], csc: ['NamedFn'], deg: ['NamedFn'], det: 'NamedOp', dim: ['NamedFn'], exp: ['NamedFn'], gcd: 'NamedOp', hom: ['NamedFn'], inf: 'NamedOp', ker: ['NamedFn'], lg: ['NamedFn'], lim: 'NamedOp', liminf: ['NamedOp','lim inf'], limsup: ['NamedOp','lim sup'], ln: ['NamedFn'], log: ['NamedFn'], max: 'NamedOp', min: 'NamedOp', Pr: 'NamedOp', sec: ['NamedFn'], sin: ['NamedFn'], sinh: ['NamedFn'], sup: 'NamedOp', tan: ['NamedFn'], tanh: ['NamedFn'], limits: ['Limits',1], nolimits: ['Limits',0], overline: ['UnderOver','00AF',null,1], underline: ['UnderOver','005F'], overbrace: ['UnderOver','23DE',1], underbrace: ['UnderOver','23DF',1], overparen: ['UnderOver','23DC'], underparen: ['UnderOver','23DD'], 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', middle: 'Middle', llap: 'Lap', rlap: 'Lap', raise: 'RaiseLower', lower: 'RaiseLower', moveleft: 'MoveLeftRight', moveright: 'MoveLeftRight', ',': ['Spacer',MML.LENGTH.THINMATHSPACE], ':': ['Spacer',MML.LENGTH.MEDIUMMATHSPACE], // 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', 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', "00B4"], // or 0301 or 02CA grave: ['Accent', "0060"], // or 0300 or 02CB ddot: ['Accent', "00A8"], // or 0308 tilde: ['Accent', "007E"], // or 0303 or 02DC bar: ['Accent', "00AF"], // or 0304 or 02C9 breve: ['Accent', "02D8"], // or 0306 check: ['Accent', "02C7"], // or 030C hat: ['Accent', "005E"], // or 0302 or 02C6 vec: ['Accent', "2192"], // or 20D7 dot: ['Accent', "02D9"], // or 0307 widetilde: ['Accent', "007E",1], // or 0303 or 02DC widehat: ['Accent', "005E",1], // or 0302 or 02C6 matrix: 'Matrix', array: 'Matrix', pmatrix: ['Matrix','(',')'], cases: ['Matrix','{','',"left left",null,".1em",null,true], eqalign: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D'], displaylines: ['Matrix',null,null,"center",null,".5em",'D'], cr: 'Cr', '\\': 'CrLaTeX', newline: ['CrLaTeX',true], hline: ['HLine','solid'], hdashline: ['HLine','dashed'], // noalign: 'HandleNoAlign', eqalignno: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D',null,"right"], leqalignno: ['Matrix',null,null,"right left",MML.LENGTH.THICKMATHSPACE,".5em",'D',null,"left"], hfill: 'HFill', hfil: 'HFill', // \hfil treated as \hfill for now hfilll: 'HFill', // \hfilll treated as \hfill for now // TeX substitution macros bmod: ['Macro','\\mmlToken{mo}[lspace="thickmathspace" rspace="thickmathspace"]{mod}'], pmod: ['Macro','\\pod{\\mmlToken{mi}{mod}\\kern 6mu #1}',1], mod: ['Macro','\\mathchoice{\\kern18mu}{\\kern12mu}{\\kern12mu}{\\kern12mu}\\mmlToken{mi}{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], textsf: ['Macro','\\mathord{\\sf\\text{#1}}',1], texttt: ['Macro','\\mathord{\\tt\\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'], ' ': ['Macro','\\text{ }'], // Specially handled not: 'Not', dots: 'Dots', space: 'Tilde', '\u00A0': 'Tilde', // LaTeX begin: 'BeginEnd', end: 'BeginEnd', newcommand: ['Extension','newcommand'], renewcommand: ['Extension','newcommand'], newenvironment: ['Extension','newcommand'], renewenvironment: ['Extension','newcommand'], def: ['Extension','newcommand'], 'let': ['Extension','newcommand'], verb: ['Extension','verb'], boldsymbol: ['Extension','boldsymbol'], tag: ['Extension','AMSmath'], notag: ['Extension','AMSmath'], label: ['Extension','AMSmath'], ref: ['Extension','AMSmath'], eqref: ['Extension','AMSmath'], nonumber: ['Macro','\\notag'], // Extensions to TeX unicode: ['Extension','unicode'], color: 'Color', href: ['Extension','HTML'], 'class': ['Extension','HTML'], style: ['Extension','HTML'], cssId: ['Extension','HTML'], bbox: ['Extension','bbox'], mmlToken: 'MmlToken', require: 'Require' }, environment: { array: ['AlignedArray'], 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,".2em",'T'], equation: [null,'Equation'], 'equation*': [null,'Equation'], eqnarray: ['ExtensionEnv',null,'AMSmath'], 'eqnarray*': ['ExtensionEnv',null,'AMSmath'], 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])} TEXDEF.macros[id].isUser = true; }} } }; /************************************************************************/ /* * 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,!!env); this.Parse(); this.Push(STACKITEM.stop()); }, Parse: function () { var c, n; while (this.i < this.string.length) { c = this.string.charAt(this.i++); n = c.charCodeAt(0); if (n >= 0xD800 && n < 0xDC00) {c += this.string.charAt(this.i++)} if (TEXDEF.special.hasOwnProperty(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(), macro = this.csFindMacro(name); if (macro) { if (!isArray(macro)) {macro = [macro]} var fn = macro[0]; if (!(fn instanceof Function)) {fn = this[fn]} fn.apply(this,[c+name].concat(macro.slice(1))); } else if (TEXDEF.mathchar0mi.hasOwnProperty(name)) {this.csMathchar0mi(name,TEXDEF.mathchar0mi[name])} else if (TEXDEF.mathchar0mo.hasOwnProperty(name)) {this.csMathchar0mo(name,TEXDEF.mathchar0mo[name])} else if (TEXDEF.mathchar7.hasOwnProperty(name)) {this.csMathchar7(name,TEXDEF.mathchar7[name])} else if (TEXDEF.delimiter.hasOwnProperty("\\"+name)) {this.csDelimiter(name,TEXDEF.delimiter["\\"+name])} else {this.csUndefined(c+name)} }, // // Look up a macro in the macros list // (overridden in begingroup extension) // csFindMacro: function (name) { return (TEXDEF.macros.hasOwnProperty(name) ? TEXDEF.macros[name] : null); }, // // Handle normal mathchar (as an mi) // csMathchar0mi: function (name,mchar) { var def = {mathvariant: MML.VARIANT.ITALIC}; if (isArray(mchar)) {def = mchar[1]; mchar = mchar[0]} this.Push(this.mmlToken(MML.mi(MML.entity("#x"+mchar)).With(def))); }, // // Handle normal mathchar (as an mo) // csMathchar0mo: function (name,mchar) { var def = {stretchy: false}; if (isArray(mchar)) {def = mchar[1]; def.stretchy = false; mchar = mchar[0]} this.Push(this.mmlToken(MML.mo(MML.entity("#x"+mchar)).With(def))); }, // // Handle mathchar in current family // csMathchar7: function (name,mchar) { var def = {mathvariant: MML.VARIANT.NORMAL}; if (isArray(mchar)) {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))); }, // // Handle delimiter // csDelimiter: function (name,delim) { var def = {}; if (isArray(delim)) {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))); }, // // Handle undefined control sequence // (overridden in noUndefined extension) // csUndefined: function (name) { TEX.Error(["UndefinedControlSequence","Undefined control sequence %1",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) { if (this.GetNext().match(/\d/)) // don't treat numbers as a unit {this.string = this.string.substr(0,this.i+1)+" "+this.string.substr(this.i+1)} var primes, base, top = this.stack.Top(); if (top.type === "prime") {base = top.data[0]; primes = top.data[1]; this.stack.Pop()} else {base = this.stack.Prev(); if (!base) {base = MML.mi("")}} if (base.isEmbellishedWrapper) {base = base.data[0].data[0]} var movesupsub = base.movesupsub, position = base.sup; if ((base.type === "msubsup" && base.data[base.sup]) || (base.type === "munderover" && base.data[base.over] && !base.subsupOK)) {TEX.Error(["DoubleExponent","Double exponent: use braces to clarify"])} if (base.type !== "msubsup") { if (movesupsub) { if (base.type !== "munderover" || base.data[base.over]) { if (base.movablelimits && base.isa(MML.mi)) {base = this.mi2mo(base)} 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, primes: primes, movesupsub: movesupsub })); }, Subscript: function (c) { if (this.GetNext().match(/\d/)) // don't treat numbers as a unit {this.string = this.string.substr(0,this.i+1)+" "+this.string.substr(this.i+1)} var primes, base, top = this.stack.Top(); if (top.type === "prime") {base = top.data[0]; primes = top.data[1]; this.stack.Pop()} else {base = this.stack.Prev(); if (!base) {base = MML.mi("")}} if (base.isEmbellishedWrapper) {base = base.data[0].data[0]} var movesupsub = base.movesupsub, position = base.sub; if ((base.type === "msubsup" && base.data[base.sub]) || (base.type === "munderover" && base.data[base.under] && !base.subsupOK)) {TEX.Error(["DoubleSubscripts","Double subscripts: use braces to clarify"])} if (base.type !== "msubsup") { if (movesupsub) { if (base.type !== "munderover" || base.data[base.under]) { if (base.movablelimits && base.isa(MML.mi)) {base = this.mi2mo(base)} 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, primes: primes, movesupsub: movesupsub })); }, PRIME: "\u2032", SMARTQUOTE: "\u2019", Prime: function (c) { var base = this.stack.Prev(); if (!base) {base = MML.mi()} if (base.type === "msubsup" && base.data[base.sup]) { TEX.Error(["DoubleExponentPrime", "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 = ["","\u2032","\u2033","\u2034","\u2057"][sup.length] || sup; this.Push(STACKITEM.prime(base,this.mmlToken(MML.mo(sup)))); }, mi2mo: function (mi) { var mo = MML.mo(); mo.Append.apply(mo,mi.data); var id; for (id in mo.defaults) {if (mo.defaults.hasOwnProperty(id) && mi[id] != null) {mo[id] = mi[id]}} for (id in MML.copyAttributes) {if (MML.copyAttributes.hasOwnProperty(id) && mi[id] != null) {mo[id] = mi[id]}} mo.lspace = mo.rspace = "0"; // prevent mo from having space in NativeMML mo.useMMLspacing &= ~(mo.SPACE_ATTR.lspace | mo.SPACE_ATTR.rspace); // don't count these explicit settings return mo; }, /* * 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(["CantUseHash1", "You can't use 'macro parameter character #' in math mode"]); }, /* * Handle other characters (as elements) */ Other: function (c) { var def, mo; if (this.stack.env.font) {def = {mathvariant: this.stack.env.font}} if (TEXDEF.remap.hasOwnProperty(c)) { c = TEXDEF.remap[c]; if (isArray(c)) {def = c[1]; c = c[0]} mo = MML.mo(MML.entity('#x'+c)).With(def); } else { mo = MML.mo(c).With(def); } if (mo.autoDefault("stretchy",true)) {mo.stretchy = false} if (mo.autoDefault("texClass",true) == "") {mo = MML.TeXAtom(mo)} this.Push(this.mmlToken(mo)); }, /************************************************************************/ /* * 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 = old} 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:0})); }, LeftRight: function (name) { this.Push(STACKITEM[name.substr(1)]().With({delim: this.GetDelimiter(name)})); }, Middle: function (name) { var delim = this.GetDelimiter(name); this.Push(MML.TeXAtom().With({texClass:MML.TEXCLASS.CLOSE})); if (this.stack.Top().type !== "left") {TEX.Error(["MisplacedMiddle","%1 must be within \\left and \\right",name])} this.Push(MML.mo(delim).With({stretchy:true})); this.Push(MML.TeXAtom().With({texClass:MML.TEXCLASS.OPEN})); }, NamedFn: function (name,id) { if (!id) {id = name.substr(1)}; var mml = MML.mi(id).With({texClass: MML.TEXCLASS.OP}); this.Push(STACKITEM.fn(this.mmlToken(mml))); }, NamedOp: function (name,id) { if (!id) {id = name.substr(1)}; id = id.replace(/ /,"\u2006"); var mml = MML.mo(id).With({ movablelimits: true, movesupsub: true, form: MML.FORM.PREFIX, texClass: MML.TEXCLASS.OP }); this.Push(this.mmlToken(mml)); }, Limits: function (name,limits) { var op = this.stack.Prev("nopop"); if (!op || (op.Get("texClass") !== MML.TEXCLASS.OP && op.movesupsub == null)) {TEX.Error(["MisplacedLimits","%1 is allowed only on operators",name])} var top = this.stack.Top(); if (op.type === "munderover" && !limits) { op = top.data[top.data.length-1] = MML.msubsup.apply(MML.subsup,op.data); } else if (op.type === "msubsup" && limits) { op = top.data[top.data.length-1] = MML.munderover.apply(MML.underover,op.data); } op.movesupsub = (limits ? true : false); op.Core().movablelimits = false; if (op.movablelimits) 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), arg = this.GetArgument(name); if (arg === "\\frac") {arg += "{"+this.GetArgument(arg)+"}{"+this.GetArgument(arg)+"}"} var mml = TEX.Parse(arg,this.stack.env).mml(); 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(["MisplacedMoveRoot","%1 can appear only within a root",name])} if (this.stack.global[id]) {TEX.Error(["MultipleMoveRoot","Multiple use of %1",name])} var n = this.GetArgument(name); if (!n.match(/-?[0-9]+/)) {TEX.Error(["IntegerArg","The argument to %1 must be an integer",name])} 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); var mo = (c.isEmbellished() ? c.CoreMO() : c); if (mo.isa(MML.mo)) mo.movablelimits = false; this.Push(MML.TeXAtom(MML.munderover(c,null,mml).With({accent: true}))); }, UnderOver: function (name,c,stack,noaccent) { var pos = {o: "over", u: "under"}[name.charAt(1)]; var base = this.ParseArg(name); if (base.Get("movablelimits")) {base.movablelimits = false} if (base.isa(MML.munderover) && base.isEmbellished()) { base.Core().With({lspace:0,rspace:0}); // get spacing right for NativeMML base = MML.mrow(MML.mo().With({rspace:0}),base); // add an empty so it's not embellished any more } var mml = MML.munderover(base,null,null); mml.SetData( mml[pos], this.mmlToken(MML.mo(MML.entity("#x"+c)).With({stretchy:true, accent:!noaccent})) ); if (stack) {mml = MML.TeXAtom(mml).With({texClass:MML.TEXCLASS.OP, movesupsub:true})} this.Push(mml.With({subsupOK:true})); }, Overset: function (name) { var top = this.ParseArg(name), base = this.ParseArg(name); base.movablelimits = false; this.Push(MML.mover(base,top)); }, Underset: function (name) { var bot = this.ParseArg(name), base = this.ParseArg(name); base.movablelimits = false; this.Push(MML.munder(base,bot)); }, 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) { def.mathvariant = MML.VARIANT.NORMAL; mml = STACKITEM.fn(this.mmlToken(MML.mi(match[1]).With(def))); } else { mml = STACKITEM.fn(MML.TeXAtom(TEX.Parse(arg,this.stack.env).mml()).With(def)); } } else {mml = MML.TeXAtom(this.ParseArg(name)).With(def)} this.Push(mml); }, MmlToken: function (name) { var type = this.GetArgument(name), attr = this.GetBrackets(name,"").replace(/^\s+/,""), data = this.GetArgument(name), def = {attrNames:[]}, match; if (!MML[type] || !MML[type].prototype.isToken) {TEX.Error(["NotMathMLToken","%1 is not a token element",type])} while (attr !== "") { match = attr.match(/^([a-z]+)\s*=\s*('[^']*'|"[^"]*"|[^ ,]*)\s*,?\s*/i); if (!match) {TEX.Error(["InvalidMathMLAttr","Invalid MathML attribute: %1",attr])} if (MML[type].prototype.defaults[match[1]] == null && !this.MmlTokenAllow[match[1]]) { TEX.Error(["UnknownAttrForElement", "%1 is not a recognized attribute for %2", match[1],type]); } var value = this.MmlFilterAttribute(match[1],match[2].replace(/^(['"])(.*)\1$/,"$2")); if (value) { if (value.toLowerCase() === "true") {value = true} else if (value.toLowerCase() === "false") {value = false} def[match[1]] = value; def.attrNames.push(match[1]); } attr = attr.substr(match[0].length); } this.Push(this.mmlToken(MML[type](data).With(def))); }, MmlFilterAttribute: function (name,value) {return value}, MmlTokenAllow: { fontfamily:1, fontsize:1, fontweight:1, fontstyle:1, color:1, background:1, id:1, "class":1, href:1, style:1 }, Strut: function (name) { this.Push(MML.mpadded(MML.mrow()).With({height: "8.6pt", depth: "3pt", width: 0})); }, Phantom: function (name,v,h) { var mml = this.ParseArg(name); if (v || h) { mml = MML.mpadded(mml); if (h) {mml.height = mml.depth = 0} if (v) {mml.width = 0} } this.Push(MML.TeXAtom(MML.mphantom(mml))); }, 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(MML.TeXAtom(smash)); }, Lap: function (name) { var mml = MML.mpadded(this.ParseArg(name)).With({width: 0}); if (name === "\\llap") {mml.lspace = "-1width"} this.Push(MML.TeXAtom(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}), right: MML.mspace().With({width: nh, mathsize: MML.SIZE.NORMAL}) })); }, Hskip: function (name) { this.Push(MML.mspace().With({width: this.GetDimen(name), mathsize: MML.SIZE.NORMAL})); }, Rule: function (name,style) { var w = this.GetDimen(name), h = this.GetDimen(name), d = this.GetDimen(name); var def = {width:w, height:h, depth:d}; if (style !== 'blank') { def.mathbackground = (this.stack.env.color || "black"); } this.Push(MML.mspace().With(def)); }, rule: function (name) { var v = this.GetBrackets(name), w = this.GetDimen(name), h = this.GetDimen(name); var mml = MML.mspace().With({ width: w, height:h, mathbackground: (this.stack.env.color || "black") }); if (v) { mml = MML.mpadded(mml).With({voffset: v}); if (v.match(/^\-/)) { mml.height = v; mml.depth = '+' + v.substr(1); } else { mml.height = '+' + v; } } 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,true); this.Push(MML.mstyle(MML.TeXAtom(MML.mo(delim).With({ minsize: size, maxsize: size, fence: true, stretchy: true, symmetric: true })).With({texClass: mclass})).With({scriptlevel: 0})); }, BuildRel: function (name) { var top = this.ParseUpTo(name,"\\over"); var bot = this.ParseArg(name); this.Push(MML.TeXAtom(MML.munderover(bot,null,top)).With({texClass: 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"})); }, Not: function (name) { this.Push(STACKITEM.not()); }, Dots: function (name) { this.Push(STACKITEM.dots().With({ ldots: this.mmlToken(MML.mo(MML.entity("#x2026")).With({stretchy:false})), cdots: this.mmlToken(MML.mo(MML.entity("#x22EF")).With({stretchy:false})) })); }, Require: function (name) { var file = this.GetArgument(name) .replace(/.*\//,"") // remove any leading path .replace(/[^a-z0-9_.-]/ig,""); // remove illegal characters 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 (!AJAX.loaded[AJAX.fileURL(file)]) { if (name != null) {delete TEXDEF[array || 'macros'][name.replace(/^\\/,"")]} HUB.RestartAfter(AJAX.Require(file)); } }, Macro: function (name,macro,argcount,def) { if (argcount) { var args = []; if (def != null) { var optional = this.GetBrackets(name); args.push(optional == null ? def : optional); } for (var i = args.length; 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(["MaxMacroSub1", "MathJax maximum macro substitution count exceeded; " + "is there a recursive macro call?"]); } }, Matrix: function (name,open,close,align,spacing,vspacing,style,cases,numbered) { var c = this.GetNext(); if (c === "") {TEX.Error(["MissingArgFor","Missing argument for %1",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 (cases) {array.isCases = true} if (numbered) {array.isNumbered = true; array.arraydef.side = numbered} 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})); if (this.stack.Top().isCases) { // // Make second column be in \text{...} (unless it is already // in a \text{...}, for backward compatibility). // var string = this.string; var braces = 0, close = -1, i = this.i, m = string.length; // // Look through the string character by character... // while (i < m) { var c = string.charAt(i); if (c === "{") { // // Increase the nested brace count and go on // braces++; i++; } else if (c === "}") { // // If there are too many close braces, just end (we will get an // error message later when the rest of the string is parsed) // Otherwise // decrease the nested brace count, // if it is now zero and we haven't already marked the end of the // first brace group, record the position (use to check for \text{} later) // go on to the next character. // if (braces === 0) { m = 0; } else { braces--; if (braces === 0 && close < 0) { close = i - this.i; } i++; } } else if (c === "&" && braces === 0) { // // Extra alignment tabs are not allowed in cases // TEX.Error(["ExtraAlignTab","Extra alignment tab in \\cases text"]); } else if (c === "\\") { // // If the macro is \cr or \\, end the search, otherwise skip the macro // (multi-letter names don't matter, as we will skip the rest of the // characters in the main loop) // if (string.substr(i).match(/^((\\cr)[^a-zA-Z]|\\\\)/)) {m = 0} else {i += 2} } else { // // Go on to the next character // i++; } } // // Check if the second column text is already in \text{}, // If not, process the second column as text and continue parsing from there, // (otherwise process the second column as normal, since it is in \text{} // var text = string.substr(this.i,i-this.i); if (!text.match(/^\s*\\text[^a-zA-Z]/) || close !== text.replace(/\s+$/,'').length - 1) { this.Push.apply(this,this.InternalMath(text,0)); this.i = i; } } }, Cr: function (name) { this.Push(STACKITEM.cell().With({isCR: true, name: name})); }, CrLaTeX: function (name, nobrackets) { var n; if (!nobrackets && this.string.charAt(this.i) === "[") { n = this.GetBrackets(name,"").replace(/ /g,"").replace(/,/,"."); if (n && !this.matchDimen(n)) { TEX.Error(["BracketMustBeDimension", "Bracket argument to %1 must be a dimension",name]); } } this.Push(STACKITEM.cell().With({isCR: true, name: name, linebreak: true})); var top = this.stack.Top(); if (top.isa(STACKITEM.array)) { if (n && top.arraydef.rowspacing) { var rows = top.arraydef.rowspacing.split(/ /); if (!top.rowspacing) {top.rowspacing = this.dimen2em(rows[0])} while (rows.length < top.table.length) {rows.push(this.Em(top.rowspacing))} rows[top.table.length-1] = this.Em(Math.max(0,top.rowspacing+this.dimen2em(n))); top.arraydef.rowspacing = rows.join(' '); } } else { if (n) {this.Push(MML.mspace().With({depth:n}))} this.Push(MML.mspace().With({linebreak:MML.LINEBREAK.NEWLINE})); } }, emPerInch: 7.2, pxPerInch: 72, matchDimen: function (dim) { return dim.match(/^(-?(?:\.\d+|\d+(?:\.\d*)?))(px|pt|em|ex|mu|pc|in|mm|cm)$/); }, dimen2em: function (dim) { var match = this.matchDimen(dim); var m = parseFloat(match[1]||"1"), unit = match[2]; if (unit === "em") {return m} if (unit === "ex") {return m * .43} if (unit === "pt") {return m / 10} // 10 pt to an em if (unit === "pc") {return m * 1.2} // 12 pt to a pc if (unit === "px") {return m * this.emPerInch / this.pxPerInch} if (unit === "in") {return m * this.emPerInch} if (unit === "cm") {return m * this.emPerInch / 2.54} // 2.54 cm to an inch if (unit === "mm") {return m * this.emPerInch / 25.4} // 10 mm to a cm if (unit === "mu") {return m / 18} return 0; }, Em: function (m) { if (Math.abs(m) < .0006) {return "0em"} return m.toFixed(3).replace(/\.?0+$/,"") + "em"; }, HLine: function (name,style) { if (style == null) {style = "solid"} var top = this.stack.Top(); if (!top.isa(STACKITEM.array) || top.data.length) {TEX.Error(["Misplaced","Misplaced %1",name])} if (top.table.length == 0) { top.frame.push("top"); } 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(' '); } }, HFill: function (name) { var top = this.stack.Top(); if (top.isa(STACKITEM.array)) top.hfill.push(top.data.length); else TEX.Error(["UnsupportedHFill","Unsupported use of %1",name]); }, /************************************************************************/ /* * LaTeX environments */ BeginEnd: function (name) { var env = this.GetArgument(name), isEnd = false; if (env.match(/^\\end\\/)) {isEnd = true; env = env.substr(5)} // special \end{} for \newenvironment environments if (env.match(/\\/i)) {TEX.Error(["InvalidEnv","Invalid environment name '%1'",env])} var cmd = this.envFindName(env); if (!cmd) {TEX.Error(["UnknownEnv","Unknown environment '%1'",env])} if (!isArray(cmd)) {cmd = [cmd]} var end = (isArray(cmd[1]) ? cmd[1][0] : cmd[1]); var mml = STACKITEM.begin().With({name: env, end: end, parse:this}); if (name === "\\end") { if (!isEnd && isArray(cmd[1]) && this[cmd[1][1]]) { mml = this[cmd[1][1]].apply(this,[mml].concat(cmd.slice(2))); } else { mml = STACKITEM.end().With({name: env}); } } else { if (++this.macroCount > TEX.config.MAXMACROS) { TEX.Error(["MaxMacroSub2", "MathJax maximum substitution count exceeded; " + "is there a recursive latex environment?"]); } if (cmd[0] && this[cmd[0]]) {mml = this[cmd[0]].apply(this,[mml].concat(cmd.slice(2)))} } this.Push(mml); }, envFindName: function (name) { return (TEXDEF.environment.hasOwnProperty(name) ? TEXDEF.environment[name] : null); }, 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(/[|:]/)) { if (lines.charAt(0).match(/[|:]/)) {array.frame.push("left"); array.frame.dashed = lines.charAt(0) === ":"} if (lines.charAt(lines.length-1).match(/[|:]/)) {array.frame.push("right")} 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} else if (style) {array.arraydef.displaystyle = false} if (style === "S") {array.arraydef.scriptlevel = 1} // FIXME: should use mstyle? if (raggedHeight) {array.arraydef.useHeight = false} this.Push(begin); return array; }, AlignedArray: function (begin) { var align = this.GetBrackets("\\begin{"+begin.name+"}"); return this.setArrayAlign(this.Array.apply(this,arguments),align); }, setArrayAlign: function (array,align) { align = this.trimSpaces(align||""); if (align === "t") {array.arraydef.align = "baseline 1"} else if (align === "b") {array.arraydef.align = "baseline -1"} else if (align === "c") {array.arraydef.align = "center"} else if (align) {array.arraydef.align = align} // FIXME: should be an error? return array; }, /************************************************************************/ /* * String handling routines */ /* * Convert delimiter to character */ convertDelimiter: function (c) { if (c) {c = (TEXDEF.delimiter.hasOwnProperty(c) ? TEXDEF.delimiter[c] : null)} if (c == null) {return null} if (isArray(c)) {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} var TEXT = text.replace(/^\s+|\s+$/g,''); if (TEXT.match(/\\$/) && text.match(/ $/)) TEXT += " "; return TEXT; }, /* * Check if the next character is a space */ nextIsSpace: function () { return this.string.charAt(this.i).match(/\s/); }, /* * 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(["MissingArgFor","Missing argument for %1",name])} return null; case '}': if (!noneOK) { TEX.Error(["ExtraCloseMissingOpen", "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) {return this.string.slice(j,this.i-1)} break; } } TEX.Error(["MissingCloseBrace","Missing close brace"]); break; } return this.string.charAt(this.i++); }, /* * Get an optional LaTeX argument in brackets */ GetBrackets: function (name,def) { if (this.GetNext() != '[') {return def}; 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(["ExtraCloseLooking", "Extra close brace while looking for %1","']'"]); } break; case ']': if (parens == 0) {return this.string.slice(j,this.i-1)} break; } } TEX.Error(["MissingCloseBracket", "Couldn't find closing ']' for argument to %1",name]); }, /* * Get the name of a delimiter (check it in the delimiter list). */ GetDelimiter: function (name,braceOK) { while (this.nextIsSpace()) {this.i++} var c = this.string.charAt(this.i); this.i++; if (this.i <= this.string.length) { if (c == "\\") { c += this.GetCS(name); } else if (c === "{" && braceOK) { this.i--; c = this.GetArgument(name).replace(/^\s+/,'').replace(/\s+$/,''); } if (TEXDEF.delimiter.hasOwnProperty(c)) {return this.convertDelimiter(c)} } TEX.Error(["MissingOrUnrecognizedDelim", "Missing or unrecognized delimiter for %1",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,"").replace(/,/,".")} } 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,"").replace(/,/,"."); } } TEX.Error(["MissingDimOrUnits", "Missing dimension or its units for %1",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(["ExtraCloseLooking", "Extra close brace while looking for %1",token]) } parens--; break; } if (parens == 0 && c == token) {return this.string.slice(j,k)} } TEX.Error(["TokenNotFoundForCommand", "Couldn't find %1 for %2",token,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 */ InternalMath: function (text,level) { var def = (this.stack.env.font ? {mathvariant: this.stack.env.font} : {}); var mml = [], i = 0, k = 0, c, match = '', braces = 0; if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) { while (i < text.length) { c = text.charAt(i++); if (c === '$') { if (match === '$' && braces === 0) { mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-1),{}).mml())); 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 === '{' && match !== '') { braces++; } else if (c === '}') { if (match === '}' && braces === 0) { mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i),{}).mml().With(def))); match = ''; k = i; } else if (match !== '') { if (braces) braces--; } } else if (c === '\\') { if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) { var len = RegExp["$&"].length; if (k < i-1) mml.push(this.InternalText(text.slice(k,i-1),def)); match = '}'; k = i-1; i += len; } else { 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 === ')' && braces === 0) { mml.push(MML.TeXAtom(TEX.Parse(text.slice(k,i-2),{}).mml())); match = ''; k = i; } else if (c.match(/[${}\\]/) && match === '') { i--; text = text.substr(0,i-1) + text.substr(i); // remove \ from \$, \{, \}, or \\ } } } } if (match !== '') TEX.Error(["MathNotTerminated","Math not terminated in text box"]); } if (k < text.length) mml.push(this.InternalText(text.slice(k),def)); if (level != null) { mml = [MML.mstyle.apply(MML,mml).With({displaystyle:false,scriptlevel:level})]; } else if (mml.length > 1) { mml = [MML.mrow.apply(MML,mml)]; } return mml; }, InternalText: function (text,def) { text = text.replace(/^\s+/,NBSP).replace(/\s+$/,NBSP); return MML.mtext(MML.chars(text)).With(def); }, /* * Routines to set the macro and environment definitions * (overridden by begingroup to make localized versions) */ setDef: function (name,value) {value.isUser = true; TEXDEF.macros[name] = value}, setEnv: function (name,value) {value.isUser = true; TEXDEF.environment[name] = value}, /* * Replace macro parameters 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(["IllegalMacroParam", "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(["MaxBufferSize", "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 }, sourceMenuTitle: /*_(MathMenu)*/ ["TeXCommands","TeX Commands"], annotationEncoding: "application/x-tex", prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run before processing TeX postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run after processing TeX // // Check if AMSmath extension must be loaded and push // it on the extensions array, if needed // Config: function () { this.SUPER(arguments).Config.apply(this,arguments); if (this.config.equationNumbers.autoNumber !== "none") { if (!this.config.extensions) {this.config.extensions = []} this.config.extensions.push("AMSmath.js"); } }, // // Convert TeX to ElementJax // Translate: function (script) { var mml, isError = false, math = MathJax.HTML.getScript(script); var display = (script.type.replace(/\n/g," ").match(/(;|\s|\n)mode\s*=\s*display(;|\s|\n|$)/) != null); var data = {math:math, display:display, script:script}; var callback = this.prefilterHooks.Execute(data); if (callback) return callback; math = data.math; try { mml = TEX.Parse(math).mml(); } catch(err) { if (!err.texError) {throw err} mml = this.formatError(err,math,display,script); isError = true; } if (mml.isa(MML.mtable) && mml.displaystyle === "inherit") mml.displaystyle = display; // for tagged equations if (mml.inferred) {mml = MML.apply(MathJax.ElementJax,mml.data)} else {mml = MML(mml)} if (display) {mml.root.display = "block"} if (isError) {mml.texError = true} data.math = mml; return this.postfilterHooks.Execute(data) || data.math; }, prefilterMath: function (math,displaystyle,script) { return math; }, postfilterMath: function (math,displaystyle,script) { this.combineRelations(math.root); return math; }, formatError: function (err,math,display,script) { var message = err.message.replace(/\n.*/,""); HUB.signal.Post(["TeX Jax - parse error",message,math,display,script]); return MML.Error(message); }, // // Produce an error and stop processing this equation // Error: function (message) { // // Translate message if it is ["id","message",args] // if (isArray(message)) {message = _.apply(_,message)} throw HUB.Insert(Error(message),{texError: true}); }, // // Add a user-defined macro to the macro list // Macro: function (name,def,argn) { TEXDEF.macros[name] = ['Macro'].concat([].slice.call(arguments,1)); TEXDEF.macros[name].isUser = true; }, /* * Create an mrow that has stretchy delimiters at either end, as needed */ fenced: function (open,mml,close) { var mrow = MML.mrow().With({open:open, close:close, texClass:MML.TEXCLASS.INNER}); mrow.Append( MML.mo(open).With({fence:true, stretchy:true, symmetric:true, texClass:MML.TEXCLASS.OPEN}) ); if (mml.type === "mrow" && mml.inferred) { mrow.Append.apply(mrow, mml.data); } else { mrow.Append(mml); } mrow.Append( MML.mo(close).With({fence:true, stretchy:true, symmetric:true, texClass:MML.TEXCLASS.CLOSE}) ); return mrow; }, /* * Create an mrow that has \mathchoice using \bigg and \big for the delimiters */ fixedFence: function (open,mml,close) { var mrow = MML.mrow().With({open:open, close:close, texClass:MML.TEXCLASS.ORD}); if (open) {mrow.Append(this.mathPalette(open,"l"))} if (mml.type === "mrow") {mrow.Append.apply(mrow,mml.data)} else {mrow.Append(mml)} if (close) {mrow.Append(this.mathPalette(close,"r"))} return mrow; }, mathPalette: function (fence,side) { if (fence === '{' || fence === '}') {fence = "\\"+fence} var D = '{\\bigg'+side+' '+fence+'}', T = '{\\big'+side+' '+fence+'}'; return TEX.Parse('\\mathchoice'+D+T+T+T,{}).mml(); }, // // Combine adjacent elements that are relations // (since MathML treats the spacing very differently) // combineRelations: function (mml) { var i, m, m1, m2; for (i = 0, m = mml.data.length; i < m; i++) { if (mml.data[i]) { if (mml.isa(MML.mrow)) { while (i+1 < m && (m1 = mml.data[i]) && (m2 = mml.data[i+1]) && m1.isa(MML.mo) && m2.isa(MML.mo) && m1.Get("texClass") === MML.TEXCLASS.REL && m2.Get("texClass") === MML.TEXCLASS.REL) { if (m1.variantForm == m2.variantForm && m1.Get("mathvariant") == m2.Get("mathvariant") && m1.style == m2.style && m1["class"] == m2["class"] && !m1.id && !m2.id) { m1.Append.apply(m1,m2.data); mml.data.splice(i+1,1); m--; } else { m1.rspace = m2.lspace = "0pt"; i++; } } } if (!mml.data[i].isToken) {this.combineRelations(mml.data[i])} } } } }); // // Add the default filters // TEX.prefilterHooks.Add(function (data) { data.math = TEX.prefilterMath(data.math,data.display,data.script); }); TEX.postfilterHooks.Add(function (data) { data.math = TEX.postfilterMath(data.math,data.display,data.script); }); TEX.loadComplete("jax.js"); })(MathJax.InputJax.TeX,MathJax.Hub,MathJax.Ajax); // @license-end