Repository: openmeetings Updated Branches: refs/heads/4.0.x fce7f3b9d -> b4060659c
http://git-wip-us.apache.org/repos/asf/openmeetings/blob/9d341f1b/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js ---------------------------------------------------------------------- diff --git a/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js b/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js index f8f6f38..cd7d507 100644 --- a/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js +++ b/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js @@ -3289,7 +3289,25 @@ MathJax.Hub.Startup = { MathJax.Ajax.Preloading( "[MathJax]/jax/element/mml/jax.js", +"[MathJax]/jax/element/mml/optable/Arrows.js", +"[MathJax]/jax/element/mml/optable/MiscMathSymbolsA.js", +"[MathJax]/jax/element/mml/optable/Dingbats.js", +"[MathJax]/jax/element/mml/optable/GeneralPunctuation.js", +"[MathJax]/jax/element/mml/optable/SpacingModLetters.js", +"[MathJax]/jax/element/mml/optable/MiscTechnical.js", +"[MathJax]/jax/element/mml/optable/SupplementalArrowsA.js", +"[MathJax]/jax/element/mml/optable/GreekAndCoptic.js", +"[MathJax]/jax/element/mml/optable/LetterlikeSymbols.js", +"[MathJax]/jax/element/mml/optable/SupplementalArrowsB.js", "[MathJax]/jax/element/mml/optable/BasicLatin.js", +"[MathJax]/jax/element/mml/optable/MiscSymbolsAndArrows.js", +"[MathJax]/jax/element/mml/optable/CombDiacritMarks.js", +"[MathJax]/jax/element/mml/optable/GeometricShapes.js", +"[MathJax]/jax/element/mml/optable/MathOperators.js", +"[MathJax]/jax/element/mml/optable/MiscMathSymbolsB.js", +"[MathJax]/jax/element/mml/optable/SuppMathOperators.js", +"[MathJax]/jax/element/mml/optable/CombDiactForSymbols.js", +"[MathJax]/jax/element/mml/optable/Latin1Supplement.js", "[MathJax]/extensions/MathEvents.js", "[MathJax]/extensions/tex2jax.js", "[MathJax]/jax/input/TeX/config.js", @@ -3307,8 +3325,34 @@ MathJax.Ajax.Preloading( "[MathJax]/jax/output/SVG/fonts/TeX/fontdata.js", "[MathJax]/jax/output/SVG/fonts/TeX/fontdata-extra.js", "[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Main.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Arrows.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/BoxDrawing.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/CombDiacritMarks.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Dingbats.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/EnclosedAlphanum.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/GeneralPunctuation.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/GeometricShapes.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/GreekAndCoptic.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Latin1Supplement.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/LatinExtendedA.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/LetterlikeSymbols.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MathOperators.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MiscMathSymbolsB.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MiscSymbols.js", "[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MiscTechnical.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/PUA.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/SpacingModLetters.js", +"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/SuppMathOperators.js", "[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/BasicLatin.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/CombDiacritMarks.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/GeometricShapes.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/GreekAndCoptic.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/LatinExtendedA.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/LatinExtendedB.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/LetterlikeSymbols.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/MiscSymbols.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/SpacingModLetters.js", +"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/SuppMathOperators.js", "[MathJax]/jax/output/SVG/fonts/TeX/Size1/Regular/Main.js", "[MathJax]/jax/output/SVG/fonts/TeX/Size2/Regular/Main.js", "[MathJax]/jax/output/SVG/fonts/TeX/Size3/Regular/Main.js", @@ -5136,7 +5180,7 @@ MathJax.ElementJax.mml.loadComplete("jax.js"); /************************************************************* * - * MathJax/jax/output/HTML-CSS/optable/BasicLatin.js + * MathJax/jax/output/HTML-CSS/optable/Arrows.js * * Copyright (c) 2010-2017 The MathJax Consortium * @@ -5160,5779 +5204,4907 @@ MathJax.ElementJax.mml.loadComplete("jax.js"); MathJax.Hub.Insert(MML.mo.prototype,{ OPTABLE: { - prefix: { - '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: || - '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: ||| - }, - postfix: { - '!!': [1,0,TEXCLASS.BIN], // multiple character operator: !! - '\'': MO.ACCENT, // apostrophe - '++': [0,0,TEXCLASS.BIN], // multiple character operator: ++ - '--': [0,0,TEXCLASS.BIN], // multiple character operator: -- - '..': [0,0,TEXCLASS.BIN], // multiple character operator: .. - '...': MO.ORD, // multiple character operator: ... - '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: || - '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: ||| - }, infix: { - '!=': MO.BIN4, // multiple character operator: != - '&&': MO.BIN4, // multiple character operator: && - '**': [1,1,TEXCLASS.BIN], // multiple character operator: ** - '*=': MO.BIN4, // multiple character operator: *= - '+=': MO.BIN4, // multiple character operator: += - '-=': MO.BIN4, // multiple character operator: -= - '->': MO.BIN5, // multiple character operator: -> - '//': [1,1,TEXCLASS.BIN], // multiple character operator: // - '/=': MO.BIN4, // multiple character operator: /= - ':=': MO.BIN4, // multiple character operator: := - '<=': MO.BIN5, // multiple character operator: <= - '<>': [1,1,TEXCLASS.BIN], // multiple character operator: <> - '==': MO.BIN4, // multiple character operator: == - '>=': MO.BIN5, // multiple character operator: >= - '@': MO.ORD11, // commercial at - '||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: || - '|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: ||| + '\u219A': MO.RELACCENT, // leftwards arrow with stroke + '\u219B': MO.RELACCENT, // rightwards arrow with stroke + '\u219C': MO.WIDEREL, // leftwards wave arrow + '\u219D': MO.WIDEREL, // rightwards wave arrow + '\u219E': MO.WIDEREL, // leftwards two headed arrow + '\u219F': MO.WIDEREL, // upwards two headed arrow + '\u21A0': MO.WIDEREL, // rightwards two headed arrow + '\u21A1': MO.RELSTRETCH, // downwards two headed arrow + '\u21A2': MO.WIDEREL, // leftwards arrow with tail + '\u21A3': MO.WIDEREL, // rightwards arrow with tail + '\u21A4': MO.WIDEREL, // leftwards arrow from bar + '\u21A5': MO.RELSTRETCH, // upwards arrow from bar + '\u21A7': MO.RELSTRETCH, // downwards arrow from bar + '\u21A8': MO.RELSTRETCH, // up down arrow with base + '\u21AB': MO.WIDEREL, // leftwards arrow with loop + '\u21AC': MO.WIDEREL, // rightwards arrow with loop + '\u21AD': MO.WIDEREL, // left right wave arrow + '\u21AE': MO.RELACCENT, // left right arrow with stroke + '\u21AF': MO.RELSTRETCH, // downwards zigzag arrow + '\u21B0': MO.RELSTRETCH, // upwards arrow with tip leftwards + '\u21B1': MO.RELSTRETCH, // upwards arrow with tip rightwards + '\u21B2': MO.RELSTRETCH, // downwards arrow with tip leftwards + '\u21B3': MO.RELSTRETCH, // downwards arrow with tip rightwards + '\u21B4': MO.RELSTRETCH, // rightwards arrow with corner downwards + '\u21B5': MO.RELSTRETCH, // downwards arrow with corner leftwards + '\u21B6': MO.RELACCENT, // anticlockwise top semicircle arrow + '\u21B7': MO.RELACCENT, // clockwise top semicircle arrow + '\u21B8': MO.REL, // north west arrow to long bar + '\u21B9': MO.WIDEREL, // leftwards arrow to bar over rightwards arrow to bar + '\u21BA': MO.REL, // anticlockwise open circle arrow + '\u21BB': MO.REL, // clockwise open circle arrow + '\u21BE': MO.RELSTRETCH, // upwards harpoon with barb rightwards + '\u21BF': MO.RELSTRETCH, // upwards harpoon with barb leftwards + '\u21C2': MO.RELSTRETCH, // downwards harpoon with barb rightwards + '\u21C3': MO.RELSTRETCH, // downwards harpoon with barb leftwards + '\u21C4': MO.WIDEREL, // rightwards arrow over leftwards arrow + '\u21C5': MO.RELSTRETCH, // upwards arrow leftwards of downwards arrow + '\u21C6': MO.WIDEREL, // leftwards arrow over rightwards arrow + '\u21C7': MO.WIDEREL, // leftwards paired arrows + '\u21C8': MO.RELSTRETCH, // upwards paired arrows + '\u21C9': MO.WIDEREL, // rightwards paired arrows + '\u21CA': MO.RELSTRETCH, // downwards paired arrows + '\u21CB': MO.WIDEREL, // leftwards harpoon over rightwards harpoon + '\u21CD': MO.RELACCENT, // leftwards double arrow with stroke + '\u21CE': MO.RELACCENT, // left right double arrow with stroke + '\u21CF': MO.RELACCENT, // rightwards double arrow with stroke + '\u21D6': MO.RELSTRETCH, // north west double arrow + '\u21D7': MO.RELSTRETCH, // north east double arrow + '\u21D8': MO.RELSTRETCH, // south east double arrow + '\u21D9': MO.RELSTRETCH, // south west double arrow + '\u21DA': MO.WIDEREL, // leftwards triple arrow + '\u21DB': MO.WIDEREL, // rightwards triple arrow + '\u21DC': MO.WIDEREL, // leftwards squiggle arrow + '\u21DD': MO.WIDEREL, // rightwards squiggle arrow + '\u21DE': MO.REL, // upwards arrow with double stroke + '\u21DF': MO.REL, // downwards arrow with double stroke + '\u21E0': MO.WIDEREL, // leftwards dashed arrow + '\u21E1': MO.RELSTRETCH, // upwards dashed arrow + '\u21E2': MO.WIDEREL, // rightwards dashed arrow + '\u21E3': MO.RELSTRETCH, // downwards dashed arrow + '\u21E4': MO.WIDEREL, // leftwards arrow to bar + '\u21E5': MO.WIDEREL, // rightwards arrow to bar + '\u21E6': MO.WIDEREL, // leftwards white arrow + '\u21E7': MO.RELSTRETCH, // upwards white arrow + '\u21E8': MO.WIDEREL, // rightwards white arrow + '\u21E9': MO.RELSTRETCH, // downwards white arrow + '\u21EA': MO.RELSTRETCH, // upwards white arrow from bar + '\u21EB': MO.RELSTRETCH, // upwards white arrow on pedestal + '\u21EC': MO.RELSTRETCH, // upwards white arrow on pedestal with horizontal bar + '\u21ED': MO.RELSTRETCH, // upwards white arrow on pedestal with vertical bar + '\u21EE': MO.RELSTRETCH, // upwards white double arrow + '\u21EF': MO.RELSTRETCH, // upwards white double arrow on pedestal + '\u21F0': MO.WIDEREL, // rightwards white arrow from wall + '\u21F1': MO.REL, // north west arrow to corner + '\u21F2': MO.REL, // south east arrow to corner + '\u21F3': MO.RELSTRETCH, // up down white arrow + '\u21F4': MO.RELACCENT, // right arrow with small circle + '\u21F5': MO.RELSTRETCH, // downwards arrow leftwards of upwards arrow + '\u21F6': MO.WIDEREL, // three rightwards arrows + '\u21F7': MO.RELACCENT, // leftwards arrow with vertical stroke + '\u21F8': MO.RELACCENT, // rightwards arrow with vertical stroke + '\u21F9': MO.RELACCENT, // left right arrow with vertical stroke + '\u21FA': MO.RELACCENT, // leftwards arrow with double vertical stroke + '\u21FB': MO.RELACCENT, // rightwards arrow with double vertical stroke + '\u21FC': MO.RELACCENT, // left right arrow with double vertical stroke + '\u21FD': MO.WIDEREL, // leftwards open-headed arrow + '\u21FE': MO.WIDEREL, // rightwards open-headed arrow + '\u21FF': MO.WIDEREL // left right open-headed arrow } } }); - MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js"); + MathJax.Ajax.loadComplete(MML.optableDir+"/Arrows.js"); })(MathJax.ElementJax.mml); -/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */ -/* vim: set ts=2 et sw=2 tw=80: */ - /************************************************************* * - * MathJax/extensions/MathEvents.js - * - * Implements the event handlers needed by the output jax to perform - * menu, hover, and other events. - * - * --------------------------------------------------------------------- + * MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js * - * Copyright (c) 2011-2017 The MathJax Consortium + * Copyright (c) 2010-2017 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 + * 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 (HUB,HTML,AJAX,CALLBACK,LOCALE,OUTPUT,INPUT) { - var VERSION = "2.7.2"; - - var EXTENSION = MathJax.Extension; - var ME = EXTENSION.MathEvents = {version: VERSION}; +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - var SETTINGS = HUB.config.menuSettings; + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + prefix: { + '\u27E6': MO.OPEN, // mathematical left white square bracket + '\u27EA': MO.OPEN, // mathematical left double angle bracket + '\u27EC': MO.OPEN // mathematical left white tortoise shell bracket + }, + postfix: { + '\u27E7': MO.CLOSE, // mathematical right white square bracket + '\u27EB': MO.CLOSE, // mathematical right double angle bracket + '\u27ED': MO.CLOSE // mathematical right white tortoise shell bracket + } + } + }); - var CONFIG = { - hover: 500, // time required to be considered a hover - frame: { - x: 3.5, y: 5, // frame padding and - bwidth: 1, // frame border width (in pixels) - bcolor: "#A6D", // frame border color - hwidth: "15px", // haze width - hcolor: "#83A" // haze color - }, - button: { - x: -6, y: -3, // menu button offsets - wx: -2 // button offset for full-width equations - }, - fadeinInc: .2, // increment for fade-in - fadeoutInc: .05, // increment for fade-out - fadeDelay: 50, // delay between fade-in or fade-out steps - fadeoutStart: 400, // delay before fade-out after mouseout - fadeoutDelay: 15*1000, // delay before automatic fade-out + MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsA.js"); - styles: { - ".MathJax_Hover_Frame": { - "border-radius": ".25em", // Opera 10.5 and IE9 - "-webkit-border-radius": ".25em", // Safari and Chrome - "-moz-border-radius": ".25em", // Firefox - "-khtml-border-radius": ".25em", // Konqueror +})(MathJax.ElementJax.mml); - "box-shadow": "0px 0px 15px #83A", // Opera 10.5 and IE9 - "-webkit-box-shadow": "0px 0px 15px #83A", // Safari and Chrome - "-moz-box-shadow": "0px 0px 15px #83A", // Forefox - "-khtml-box-shadow": "0px 0px 15px #83A", // Konqueror +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/Dingbats.js + * + * Copyright (c) 2010-2017 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. + * + */ - border: "1px solid #A6D ! important", - display: "inline-block", position:"absolute" - }, +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - ".MathJax_Menu_Button .MathJax_Hover_Arrow": { - position:"absolute", - cursor:"pointer", - display:"inline-block", - border:"2px solid #AAA", - "border-radius":"4px", - "-webkit-border-radius": "4px", // Safari and Chrome - "-moz-border-radius": "4px", // Firefox - "-khtml-border-radius": "4px", // Konqueror - "font-family":"'Courier New',Courier", - "font-size":"9px", - color:"#F0F0F0" - }, - ".MathJax_Menu_Button .MathJax_Hover_Arrow span": { - display:"block", - "background-color":"#AAA", - border:"1px solid", - "border-radius":"3px", - "line-height":0, - padding:"4px" - }, - ".MathJax_Hover_Arrow:hover": { - color:"white!important", - border:"2px solid #CCC!important" + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + prefix: { + '\u2772': MO.OPEN // light left tortoise shell bracket ornament }, - ".MathJax_Hover_Arrow:hover span": { - "background-color":"#CCC!important" + postfix: { + '\u2773': MO.CLOSE // light right tortoise shell bracket ornament } } - }; - - - // - // Common event-handling code - // - var EVENT = ME.Event = { + }); - LEFTBUTTON: 0, // the event.button value for left button - RIGHTBUTTON: 2, // the event.button value for right button - MENUKEY: "altKey", // the event value for alternate context menu + MathJax.Ajax.loadComplete(MML.optableDir+"/Dingbats.js"); - /*************************************************************/ - /* - * Enum element for key codes. - */ - KEY: { - RETURN: 13, - ESCAPE: 27, - SPACE: 32, - LEFT: 37, - UP: 38, - RIGHT: 39, - DOWN: 40 - }, +})(MathJax.ElementJax.mml); - Mousedown: function (event) {return EVENT.Handler(event,"Mousedown",this)}, - Mouseup: function (event) {return EVENT.Handler(event,"Mouseup",this)}, - Mousemove: function (event) {return EVENT.Handler(event,"Mousemove",this)}, - Mouseover: function (event) {return EVENT.Handler(event,"Mouseover",this)}, - Mouseout: function (event) {return EVENT.Handler(event,"Mouseout",this)}, - Click: function (event) {return EVENT.Handler(event,"Click",this)}, - DblClick: function (event) {return EVENT.Handler(event,"DblClick",this)}, - Menu: function (event) {return EVENT.Handler(event,"ContextMenu",this)}, +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js + * + * Copyright (c) 2010-2017 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. + * + */ - // - // Call the output jax's event handler or the zoom handler - // - Handler: function (event,type,math) { - if (AJAX.loadingMathMenu) {return EVENT.False(event)} - var jax = OUTPUT[math.jaxID]; - if (!event) {event = window.event} - event.isContextMenu = (type === "ContextMenu"); - if (jax[type]) {return jax[type](event,math)} - if (EXTENSION.MathZoom) {return EXTENSION.MathZoom.HandleEvent(event,type,math)} - }, +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - // - // Try to cancel the event in every way we can - // - False: function (event) { - if (!event) {event = window.event} - if (event) { - if (event.preventDefault) {event.preventDefault()} else {event.returnValue = false} - if (event.stopPropagation) {event.stopPropagation()} - event.cancelBubble = true; + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + prefix: { + '\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line + '\u2018': [0,0,TEXCLASS.OPEN,{fence: true}], // left single quotation mark + '\u201C': [0,0,TEXCLASS.OPEN,{fence: true}] // left double quotation mark + }, + postfix: { + '\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line + '\u2019': [0,0,TEXCLASS.CLOSE,{fence: true}], // right single quotation mark + '\u201D': [0,0,TEXCLASS.CLOSE,{fence: true}] // right double quotation mark } - return false; - }, + } + }); - // - // Keydown event handler. Should only fire on Space key. - // - Keydown: function (event, math) { - if (!event) event = window.event; - if (event.keyCode === EVENT.KEY.SPACE) { - EVENT.ContextMenu(event, this); - }; - }, + MathJax.Ajax.loadComplete(MML.optableDir+"/GeneralPunctuation.js"); - // - // Load the contextual menu code, if needed, and post the menu - // - ContextMenu: function (event,math,force) { - // - // Check if we are showing menus - // - var JAX = OUTPUT[math.jaxID], jax = JAX.getJaxFromMath(math); - var show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu; - if (!show || (SETTINGS.context !== "MathJax" && !force)) return; +})(MathJax.ElementJax.mml); - // - // Remove selections, remove hover fades - // - if (ME.msieEventBug) {event = window.event || event} - EVENT.ClearSelection(); HOVER.ClearHoverTimer(); - if (jax.hover) { - if (jax.hover.remove) {clearTimeout(jax.hover.remove); delete jax.hover.remove} - jax.hover.nofade = true; +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js + * + * Copyright (c) 2010-2017 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 (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; + + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + postfix: { + '\u02CD': MO.WIDEACCENT, // modifier letter low macron + '\u02DA': MO.ACCENT, // ring above + '\u02DD': MO.ACCENT, // double acute accent + '\u02F7': MO.WIDEACCENT // modifier letter low tilde } + } + }); - // - // If the menu code is loaded, - // Check if localization needs loading; - // If not, post the menu, and return. - // Otherwise wait for the localization to load - // Otherwse load the menu code. - // Try again after the file is loaded. - // - var MENU = MathJax.Menu; var load, fn; - if (MENU) { - if (MENU.loadingDomain) {return EVENT.False(event)} - load = LOCALE.loadDomain("MathMenu"); - if (!load) { - MENU.jax = jax; - var source = MENU.menu.Find("Show Math As").submenu; - source.items[0].name = jax.sourceMenuTitle; - source.items[0].format = (jax.sourceMenuFormat||"MathML"); - source.items[1].name = INPUT[jax.inputJax].sourceMenuTitle; - source.items[5].disabled = !INPUT[jax.inputJax].annotationEncoding; + MathJax.Ajax.loadComplete(MML.optableDir+"/SpacingModLetters.js"); - // - // Try and find each known annotation format and enable the menu - // items accordingly. - // - var annotations = source.items[2]; annotations.disabled = true; - var annotationItems = annotations.submenu.items; - annotationList = MathJax.Hub.Config.semanticsAnnotations; - for (var i = 0, m = annotationItems.length; i < m; i++) { - var name = annotationItems[i].name[1] - if (jax.root && jax.root.getAnnotation(name) !== null) { - annotations.disabled = false; - annotationItems[i].hidden = false; - } else { - annotationItems[i].hidden = true; - } - } +})(MathJax.ElementJax.mml); - var MathPlayer = MENU.menu.Find("Math Settings","MathPlayer"); - MathPlayer.hidden = !(jax.outputJax === "NativeMML" && HUB.Browser.hasMathPlayer); - return MENU.menu.Post(event); - } - MENU.loadingDomain = true; - fn = function () {delete MENU.loadingDomain}; - } else { - if (AJAX.loadingMathMenu) {return EVENT.False(event)} - AJAX.loadingMathMenu = true; - load = AJAX.Require("[MathJax]/extensions/MathMenu.js"); - fn = function () { - delete AJAX.loadingMathMenu; - if (!MathJax.Menu) {MathJax.Menu = {}} - } - } - var ev = { - pageX:event.pageX, pageY:event.pageY, - clientX:event.clientX, clientY:event.clientY - }; - CALLBACK.Queue( - load, fn, // load the file and delete the marker when done - ["ContextMenu",EVENT,ev,math,force] // call this function again - ); - return EVENT.False(event); - }, +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js + * + * Copyright (c) 2010-2017 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. + * + */ - // - // Mousedown handler for alternate means of accessing menu - // - AltContextMenu: function (event,math) { - var JAX = OUTPUT[math.jaxID]; - var show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu; - if (show) { - show = (JAX.config.showMathMenuMSIE != null ? JAX : HUB).config.showMathMenuMSIE; - if (SETTINGS.context === "MathJax" && !SETTINGS.mpContext && show) { - if (!ME.noContextMenuBug || event.button !== EVENT.RIGHTBUTTON) return; - } else { - if (!event[EVENT.MENUKEY] || event.button !== EVENT.LEFTBUTTON) return; - } - return JAX.ContextMenu(event,math,true); +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; + + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + postfix: { + '\u23B4': MO.WIDEACCENT, // top square bracket + '\u23B5': MO.WIDEACCENT, // bottom square bracket + '\u23DC': MO.WIDEACCENT, // top parenthesis + '\u23DD': MO.WIDEACCENT, // bottom parenthesis + '\u23E0': MO.WIDEACCENT, // top tortoise shell bracket + '\u23E1': MO.WIDEACCENT // bottom tortoise shell bracket } - }, + } + }); - ClearSelection: function () { - if (ME.safariContextMenuBug) {setTimeout("window.getSelection().empty()",0)} - if (document.selection) {setTimeout("document.selection.empty()",0)} - }, + MathJax.Ajax.loadComplete(MML.optableDir+"/MiscTechnical.js"); - getBBox: function (span) { - span.appendChild(ME.topImg); - var h = ME.topImg.offsetTop, d = span.offsetHeight-h, w = span.offsetWidth; - span.removeChild(ME.topImg); - return {w:w, h:h, d:d}; - } +})(MathJax.ElementJax.mml); - }; +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsA.js + * + * Copyright (c) 2010-2017 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. + * + */ - // - // Handle hover "discoverability" - // - var HOVER = ME.Hover = { +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - // - // Check if we are moving from a non-MathJax element to a MathJax one - // and either start fading in again (if it is fading out) or start the - // timer for the hover - // - Mouseover: function (event,math) { - if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") { - var from = event.fromElement || event.relatedTarget, - to = event.toElement || event.target; - if (from && to && (HUB.isMathJaxNode(from) !== HUB.isMathJaxNode(to) || - HUB.getJaxFor(from) !== HUB.getJaxFor(to))) { - var jax = this.getJaxFromMath(math); - if (jax.hover) {HOVER.ReHover(jax)} else {HOVER.HoverTimer(jax,math)} - return EVENT.False(event); - } - } - }, - // - // Check if we are moving from a MathJax element to a non-MathJax one - // and either start fading out, or clear the timer if we haven't - // hovered yet - // - Mouseout: function (event,math) { - if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") { - var from = event.fromElement || event.relatedTarget, - to = event.toElement || event.target; - if (from && to && (HUB.isMathJaxNode(from) !== HUB.isMathJaxNode(to) || - HUB.getJaxFor(from) !== HUB.getJaxFor(to))) { - var jax = this.getJaxFromMath(math); - if (jax.hover) {HOVER.UnHover(jax)} else {HOVER.ClearHoverTimer()} - return EVENT.False(event); - } - } - }, - // - // Restart hover timer if the mouse moves - // - Mousemove: function (event,math) { - if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") { - var jax = this.getJaxFromMath(math); if (jax.hover) return; - if (HOVER.lastX == event.clientX && HOVER.lastY == event.clientY) return; - HOVER.lastX = event.clientX; HOVER.lastY = event.clientY; - HOVER.HoverTimer(jax,math); - return EVENT.False(event); + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + infix: { + '\u27F0': MO.RELSTRETCH, // upwards quadruple arrow + '\u27F1': MO.RELSTRETCH, // downwards quadruple arrow + '\u27FB': MO.WIDEREL, // long leftwards arrow from bar + '\u27FD': MO.WIDEREL, // long leftwards double arrow from bar + '\u27FE': MO.WIDEREL, // long rightwards double arrow from bar + '\u27FF': MO.WIDEREL // long rightwards squiggle arrow } - }, + } + }); - // - // Clear the old timer and start a new one - // - HoverTimer: function (jax,math) { - this.ClearHoverTimer(); - this.hoverTimer = setTimeout(CALLBACK(["Hover",this,jax,math]),CONFIG.hover); - }, - ClearHoverTimer: function () { - if (this.hoverTimer) {clearTimeout(this.hoverTimer); delete this.hoverTimer} - }, + MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsA.js"); - // - // Handle putting up the hover frame - // - Hover: function (jax,math) { - // - // Check if Zoom handles the hover event - // - if (EXTENSION.MathZoom && EXTENSION.MathZoom.Hover({},math)) return; - // - // Get the hover data - // - var JAX = OUTPUT[jax.outputJax], - span = JAX.getHoverSpan(jax,math), - bbox = JAX.getHoverBBox(jax,span,math), - show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu; - var dx = CONFIG.frame.x, dy = CONFIG.frame.y, dd = CONFIG.frame.bwidth; // frame size - if (ME.msieBorderWidthBug) {dd = 0} - jax.hover = {opacity:0, id:jax.inputID+"-Hover"}; - // - // The frame and menu button - // - var frame = HTML.Element("span",{ - id:jax.hover.id, isMathJax: true, - style:{display:"inline-block", width:0, height:0, position:"relative"} - },[["span",{ - className:"MathJax_Hover_Frame", isMathJax: true, - style:{ - display:"inline-block", position:"absolute", - top:this.Px(-bbox.h-dy-dd-(bbox.y||0)), left:this.Px(-dx-dd+(bbox.x||0)), - width:this.Px(bbox.w+2*dx), height:this.Px(bbox.h+bbox.d+2*dy), - opacity:0, filter:"alpha(opacity=0)" - }} - ]] - ); - var button = HTML.Element("span",{ - isMathJax: true, id:jax.hover.id+"Menu", className:"MathJax_Menu_Button", - style:{display:"inline-block", "z-index": 1, width:0, height:0, position:"relative"} - },[["span",{ - className: "MathJax_Hover_Arrow", isMathJax: true, math: math, - onclick: this.HoverMenu, jax:JAX.id, - style: { - left:this.Px(bbox.w+dx+dd+(bbox.x||0)+CONFIG.button.x), - top:this.Px(-bbox.h-dy-dd-(bbox.y||0)-CONFIG.button.y), - opacity:0, filter:"alpha(opacity=0)" - } - },[["span",{isMathJax:true},"\u25BC"]]]] - ); - if (bbox.width) { - frame.style.width = button.style.width = bbox.width; - frame.style.marginRight = button.style.marginRight = "-"+bbox.width; - frame.firstChild.style.width = bbox.width; - button.firstChild.style.left = ""; - button.firstChild.style.right = this.Px(CONFIG.button.wx); - } - // - // Add the frame and button - // - span.parentNode.insertBefore(frame,span); - if (show) {span.parentNode.insertBefore(button,span)} - if (span.style) {span.style.position = "relative"} // so math is on top of hover frame - // - // Start the hover fade-in - // - this.ReHover(jax); - }, - // - // Restart the hover fade in and fade-out timers - // - ReHover: function (jax) { - if (jax.hover.remove) {clearTimeout(jax.hover.remove)} - jax.hover.remove = setTimeout(CALLBACK(["UnHover",this,jax]),CONFIG.fadeoutDelay); - this.HoverFadeTimer(jax,CONFIG.fadeinInc); - }, - // - // Start the fade-out - // - UnHover: function (jax) { - if (!jax.hover.nofade) {this.HoverFadeTimer(jax,-CONFIG.fadeoutInc,CONFIG.fadeoutStart)} - }, - // - // Handle the fade-in and fade-out - // - HoverFade: function (jax) { - delete jax.hover.timer; - jax.hover.opacity = Math.max(0,Math.min(1,jax.hover.opacity + jax.hover.inc)); - jax.hover.opacity = Math.floor(1000*jax.hover.opacity)/1000; - var frame = document.getElementById(jax.hover.id), - button = document.getElementById(jax.hover.id+"Menu"); - frame.firstChild.style.opacity = jax.hover.opacity; - frame.firstChild.style.filter = "alpha(opacity="+Math.floor(100*jax.hover.opacity)+")"; - if (button) { - button.firstChild.style.opacity = jax.hover.opacity; - button.firstChild.style.filter = frame.style.filter; - } - if (jax.hover.opacity === 1) {return} - if (jax.hover.opacity > 0) {this.HoverFadeTimer(jax,jax.hover.inc); return} - frame.parentNode.removeChild(frame); - if (button) {button.parentNode.removeChild(button)} - if (jax.hover.remove) {clearTimeout(jax.hover.remove)} - delete jax.hover; - }, - // - // Set the fade to in or out (via inc) and start the timer, if needed - // - HoverFadeTimer: function (jax,inc,delay) { - jax.hover.inc = inc; - if (!jax.hover.timer) { - jax.hover.timer = setTimeout(CALLBACK(["HoverFade",this,jax]),(delay||CONFIG.fadeDelay)); +})(MathJax.ElementJax.mml); + +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js + * + * Copyright (c) 2010-2017 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 (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; + + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + infix: { + '\u03F6': MO.REL // greek reversed lunate epsilon symbol } - }, + } + }); - // - // Handle a click on the menu button - // - HoverMenu: function (event) { - if (!event) {event = window.event} - return OUTPUT[this.jax].ContextMenu(event,this.math,true); - }, + MathJax.Ajax.loadComplete(MML.optableDir+"/GreekAndCoptic.js"); - // - // Clear all hover timers - // - ClearHover: function (jax) { - if (jax.hover.remove) {clearTimeout(jax.hover.remove)} - if (jax.hover.timer) {clearTimeout(jax.hover.timer)} - HOVER.ClearHoverTimer(); - delete jax.hover; - }, +})(MathJax.ElementJax.mml); - // - // Make a measurement in pixels - // - Px: function (m) { - if (Math.abs(m) < .006) {return "0px"} - return m.toFixed(2).replace(/\.?0+$/,"") + "px"; - }, +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js + * + * Copyright (c) 2010-2017 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. + * + */ - // - // Preload images so they show up with the menu - // - getImages: function () { - if (SETTINGS.discoverable) { - var menu = new Image(); - menu.src = CONFIG.button.src; +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; + + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + prefix: { + '\u2145': MO.ORD21, // double-struck italic capital d + '\u2146': [2,0,TEXCLASS.ORD] // double-struck italic small d } } + }); - }; + MathJax.Ajax.loadComplete(MML.optableDir+"/LetterlikeSymbols.js"); - // - // Handle touch events. - // - // Use double-tap-and-hold as a replacement for context menu event. - // Use double-tap as a replacement for double click. - // - var TOUCH = ME.Touch = { +})(MathJax.ElementJax.mml); - last: 0, // time of last tap event - delay: 500, // delay time for double-click +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js + * + * Copyright (c) 2010-2017 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. + * + */ - // - // Check if this is a double-tap, and if so, start the timer - // for the double-tap and hold (to trigger the contextual menu) - // - start: function (event) { - var now = new Date().getTime(); - var dblTap = (now - TOUCH.last < TOUCH.delay && TOUCH.up); - TOUCH.last = now; TOUCH.up = false; - if (dblTap) { - TOUCH.timeout = setTimeout(TOUCH.menu,TOUCH.delay,event,this); - event.preventDefault(); - } - }, +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - // - // Check if there is a timeout pending, i.e., we have a - // double-tap and were waiting to see if it is held long - // enough for the menu. Since we got the end before the - // timeout, it is a double-click, not a double-tap-and-hold. - // Prevent the default action and issue a double click. - // - end: function (event) { - var now = new Date().getTime(); - TOUCH.up = (now - TOUCH.last < TOUCH.delay); - if (TOUCH.timeout) { - clearTimeout(TOUCH.timeout); - delete TOUCH.timeout; TOUCH.last = 0; TOUCH.up = false; - event.preventDefault(); - return EVENT.Handler((event.touches[0]||event.touch),"DblClick",this); + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + infix: { + '\u2900': MO.RELACCENT, // rightwards two-headed arrow with vertical stroke + '\u2901': MO.RELACCENT, // rightwards two-headed arrow with double vertical stroke + '\u2902': MO.RELACCENT, // leftwards double arrow with vertical stroke + '\u2903': MO.RELACCENT, // rightwards double arrow with vertical stroke + '\u2904': MO.RELACCENT, // left right double arrow with vertical stroke + '\u2905': MO.RELACCENT, // rightwards two-headed arrow from bar + '\u2906': MO.RELACCENT, // leftwards double arrow from bar + '\u2907': MO.RELACCENT, // rightwards double arrow from bar + '\u2908': MO.REL, // downwards arrow with horizontal stroke + '\u2909': MO.REL, // upwards arrow with horizontal stroke + '\u290A': MO.RELSTRETCH, // upwards triple arrow + '\u290B': MO.RELSTRETCH, // downwards triple arrow + '\u290C': MO.WIDEREL, // leftwards double dash arrow + '\u290D': MO.WIDEREL, // rightwards double dash arrow + '\u290E': MO.WIDEREL, // leftwards triple dash arrow + '\u290F': MO.WIDEREL, // rightwards triple dash arrow + '\u2910': MO.WIDEREL, // rightwards two-headed triple dash arrow + '\u2911': MO.RELACCENT, // rightwards arrow with dotted stem + '\u2912': MO.RELSTRETCH, // upwards arrow to bar + '\u2913': MO.RELSTRETCH, // downwards arrow to bar + '\u2914': MO.RELACCENT, // rightwards arrow with tail with vertical stroke + '\u2915': MO.RELACCENT, // rightwards arrow with tail with double vertical stroke + '\u2916': MO.RELACCENT, // rightwards two-headed arrow with tail + '\u2917': MO.RELACCENT, // rightwards two-headed arrow with tail with vertical stroke + '\u2918': MO.RELACCENT, // rightwards two-headed arrow with tail with double vertical stroke + '\u2919': MO.RELACCENT, // leftwards arrow-tail + '\u291A': MO.RELACCENT, // rightwards arrow-tail + '\u291B': MO.RELACCENT, // leftwards double arrow-tail + '\u291C': MO.RELACCENT, // rightwards double arrow-tail + '\u291D': MO.RELACCENT, // leftwards arrow to black diamond + '\u291E': MO.RELACCENT, // rightwards arrow to black diamond + '\u291F': MO.RELACCENT, // leftwards arrow from bar to black diamond + '\u2920': MO.RELACCENT, // rightwards arrow from bar to black diamond + '\u2921': MO.RELSTRETCH, // north west and south east arrow + '\u2922': MO.RELSTRETCH, // north east and south west arrow + '\u2923': MO.REL, // north west arrow with hook + '\u2924': MO.REL, // north east arrow with hook + '\u2925': MO.REL, // south east arrow with hook + '\u2926': MO.REL, // south west arrow with hook + '\u2927': MO.REL, // north west arrow and north east arrow + '\u2928': MO.REL, // north east arrow and south east arrow + '\u2929': MO.REL, // south east arrow and south west arrow + '\u292A': MO.REL, // south west arrow and north west arrow + '\u292B': MO.REL, // rising diagonal crossing falling diagonal + '\u292C': MO.REL, // falling diagonal crossing rising diagonal + '\u292D': MO.REL, // south east arrow crossing north east arrow + '\u292E': MO.REL, // north east arrow crossing south east arrow + '\u292F': MO.REL, // falling diagonal crossing north east arrow + '\u2930': MO.REL, // rising diagonal crossing south east arrow + '\u2931': MO.REL, // north east arrow crossing north west arrow + '\u2932': MO.REL, // north west arrow crossing north east arrow + '\u2933': MO.RELACCENT, // wave arrow pointing directly right + '\u2934': MO.REL, // arrow pointing rightwards then curving upwards + '\u2935': MO.REL, // arrow pointing rightwards then curving downwards + '\u2936': MO.REL, // arrow pointing downwards then curving leftwards + '\u2937': MO.REL, // arrow pointing downwards then curving rightwards + '\u2938': MO.REL, // right-side arc clockwise arrow + '\u2939': MO.REL, // left-side arc anticlockwise arrow + '\u293A': MO.RELACCENT, // top arc anticlockwise arrow + '\u293B': MO.RELACCENT, // bottom arc anticlockwise arrow + '\u293C': MO.RELACCENT, // top arc clockwise arrow with minus + '\u293D': MO.RELACCENT, // top arc anticlockwise arrow with plus + '\u293E': MO.REL, // lower right semicircular clockwise arrow + '\u293F': MO.REL, // lower left semicircular anticlockwise arrow + '\u2940': MO.REL, // anticlockwise closed circle arrow + '\u2941': MO.REL, // clockwise closed circle arrow + '\u2942': MO.RELACCENT, // rightwards arrow above short leftwards arrow + '\u2943': MO.RELACCENT, // leftwards arrow above short rightwards arrow + '\u2944': MO.RELACCENT, // short rightwards arrow above leftwards arrow + '\u2945': MO.RELACCENT, // rightwards arrow with plus below + '\u2946': MO.RELACCENT, // leftwards arrow with plus below + '\u2947': MO.RELACCENT, // rightwards arrow through x + '\u2948': MO.RELACCENT, // left right arrow through small circle + '\u2949': MO.REL, // upwards two-headed arrow from small circle + '\u294A': MO.RELACCENT, // left barb up right barb down harpoon + '\u294B': MO.RELACCENT, // left barb down right barb up harpoon + '\u294C': MO.REL, // up barb right down barb left harpoon + '\u294D': MO.REL, // up barb left down barb right harpoon + '\u294E': MO.WIDEREL, // left barb up right barb up harpoon + '\u294F': MO.RELSTRETCH, // up barb right down barb right harpoon + '\u2950': MO.WIDEREL, // left barb down right barb down harpoon + '\u2951': MO.RELSTRETCH, // up barb left down barb left harpoon + '\u2952': MO.WIDEREL, // leftwards harpoon with barb up to bar + '\u2953': MO.WIDEREL, // rightwards harpoon with barb up to bar + '\u2954': MO.RELSTRETCH, // upwards harpoon with barb right to bar + '\u2955': MO.RELSTRETCH, // downwards harpoon with barb right to bar + '\u2956': MO.RELSTRETCH, // leftwards harpoon with barb down to bar + '\u2957': MO.RELSTRETCH, // rightwards harpoon with barb down to bar + '\u2958': MO.RELSTRETCH, // upwards harpoon with barb left to bar + '\u2959': MO.RELSTRETCH, // downwards harpoon with barb left to bar + '\u295A': MO.WIDEREL, // leftwards harpoon with barb up from bar + '\u295B': MO.WIDEREL, // rightwards harpoon with barb up from bar + '\u295C': MO.RELSTRETCH, // upwards harpoon with barb right from bar + '\u295D': MO.RELSTRETCH, // downwards harpoon with barb right from bar + '\u295E': MO.WIDEREL, // leftwards harpoon with barb down from bar + '\u295F': MO.WIDEREL, // rightwards harpoon with barb down from bar + '\u2960': MO.RELSTRETCH, // upwards harpoon with barb left from bar + '\u2961': MO.RELSTRETCH, // downwards harpoon with barb left from bar + '\u2962': MO.RELACCENT, // leftwards harpoon with barb up above leftwards harpoon with barb down + '\u2963': MO.REL, // upwards harpoon with barb left beside upwards harpoon with barb right + '\u2964': MO.RELACCENT, // rightwards harpoon with barb up above rightwards harpoon with barb down + '\u2965': MO.REL, // downwards harpoon with barb left beside downwards harpoon with barb right + '\u2966': MO.RELACCENT, // leftwards harpoon with barb up above rightwards harpoon with barb up + '\u2967': MO.RELACCENT, // leftwards harpoon with barb down above rightwards harpoon with barb down + '\u2968': MO.RELACCENT, // rightwards harpoon with barb up above leftwards harpoon with barb up + '\u2969': MO.RELACCENT, // rightwards harpoon with barb down above leftwards harpoon with barb down + '\u296A': MO.RELACCENT, // leftwards harpoon with barb up above long dash + '\u296B': MO.RELACCENT, // leftwards harpoon with barb down below long dash + '\u296C': MO.RELACCENT, // rightwards harpoon with barb up above long dash + '\u296D': MO.RELACCENT, // rightwards harpoon with barb down below long dash + '\u296E': MO.RELSTRETCH, // upwards harpoon with barb left beside downwards harpoon with barb right + '\u296F': MO.RELSTRETCH, // downwards harpoon with barb left beside upwards harpoon with barb right + '\u2970': MO.RELACCENT, // right double arrow with rounded head + '\u2971': MO.RELACCENT, // equals sign above rightwards arrow + '\u2972': MO.RELACCENT, // tilde operator above rightwards arrow + '\u2973': MO.RELACCENT, // leftwards arrow above tilde operator + '\u2974': MO.RELACCENT, // rightwards arrow above tilde operator + '\u2975': MO.RELACCENT, // rightwards arrow above almost equal to + '\u2976': MO.RELACCENT, // less-than above leftwards arrow + '\u2977': MO.RELACCENT, // leftwards arrow through less-than + '\u2978': MO.RELACCENT, // greater-than above rightwards arrow + '\u2979': MO.RELACCENT, // subset above rightwards arrow + '\u297A': MO.RELACCENT, // leftwards arrow through subset + '\u297B': MO.RELACCENT, // superset above leftwards arrow + '\u297C': MO.RELACCENT, // left fish tail + '\u297D': MO.RELACCENT, // right fish tail + '\u297E': MO.REL, // up fish tail + '\u297F': MO.REL // down fish tail } - }, - - // - // If the timeout passes without an end event, we issue - // the contextual menu event. - // - menu: function (event,math) { - delete TOUCH.timeout; TOUCH.last = 0; TOUCH.up = false; - return EVENT.Handler((event.touches[0]||event.touch),"ContextMenu",math); } + }); - }; + MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsB.js"); - /* - * // - * // Mobile screens are small, so use larger version of arrow - * // - * if (HUB.Browser.isMobile) { - * var arrow = CONFIG.styles[".MathJax_Hover_Arrow"]; - * arrow.width = "25px"; arrow.height = "18px"; - * CONFIG.button.x = -6; - * } - */ +})(MathJax.ElementJax.mml); - // - // Set up browser-specific values - // - HUB.Browser.Select({ - MSIE: function (browser) { - var mode = (document.documentMode || 0); - var isIE8 = browser.versionAtLeast("8.0"); - ME.msieBorderWidthBug = (document.compatMode === "BackCompat"); // borders are inside offsetWidth/Height - ME.msieEventBug = browser.isIE9; // must get event from window even though event is passed - ME.msieAlignBug = (!isIE8 || mode < 8); // inline-block spans don't rest on baseline - if (mode < 9) {EVENT.LEFTBUTTON = 1} // IE < 9 has wrong event.button values - }, - Safari: function (browser) { - ME.safariContextMenuBug = true; // selection can be started by contextmenu event - }, - Opera: function (browser) { - ME.operaPositionBug = true; // position is wrong unless border is used - }, - Konqueror: function (browser) { - ME.noContextMenuBug = true; // doesn't produce contextmenu event +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/BasicLatin.js + * + * Copyright (c) 2010-2017 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 (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; + + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + prefix: { + '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: || + '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: ||| + }, + postfix: { + '!!': [1,0,TEXCLASS.BIN], // multiple character operator: !! + '\'': MO.ACCENT, // apostrophe + '++': [0,0,TEXCLASS.BIN], // multiple character operator: ++ + '--': [0,0,TEXCLASS.BIN], // multiple character operator: -- + '..': [0,0,TEXCLASS.BIN], // multiple character operator: .. + '...': MO.ORD, // multiple character operator: ... + '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: || + '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: ||| + }, + infix: { + '!=': MO.BIN4, // multiple character operator: != + '&&': MO.BIN4, // multiple character operator: && + '**': [1,1,TEXCLASS.BIN], // multiple character operator: ** + '*=': MO.BIN4, // multiple character operator: *= + '+=': MO.BIN4, // multiple character operator: += + '-=': MO.BIN4, // multiple character operator: -= + '->': MO.BIN5, // multiple character operator: -> + '//': [1,1,TEXCLASS.BIN], // multiple character operator: // + '/=': MO.BIN4, // multiple character operator: /= + ':=': MO.BIN4, // multiple character operator: := + '<=': MO.BIN5, // multiple character operator: <= + '<>': [1,1,TEXCLASS.BIN], // multiple character operator: <> + '==': MO.BIN4, // multiple character operator: == + '>=': MO.BIN5, // multiple character operator: >= + '@': MO.ORD11, // commercial at + '||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: || + '|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: ||| + } } }); - // - // Used in measuring zoom and hover positions - // - ME.topImg = (ME.msieAlignBug ? - HTML.Element("img",{style:{width:0,height:0,position:"relative"},src:"about:blank"}) : - HTML.Element("span",{style:{width:0,height:0,display:"inline-block"}}) - ); - if (ME.operaPositionBug) {ME.topImg.style.border="1px solid"} + MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js"); - // - // Get configuration from user - // - ME.config = CONFIG = HUB.CombineConfig("MathEvents",CONFIG); - var SETFRAME = function () { - var haze = CONFIG.styles[".MathJax_Hover_Frame"]; - haze.border = CONFIG.frame.bwidth+"px solid "+CONFIG.frame.bcolor+" ! important"; - haze["box-shadow"] = haze["-webkit-box-shadow"] = - haze["-moz-box-shadow"] = haze["-khtml-box-shadow"] = - "0px 0px "+CONFIG.frame.hwidth+" "+CONFIG.frame.hcolor; - }; +})(MathJax.ElementJax.mml); - // - // Queue the events needed for startup - // - CALLBACK.Queue( - HUB.Register.StartupHook("End Config",{}), // wait until config is complete - [SETFRAME], - ["getImages",HOVER], - ["Styles",AJAX,CONFIG.styles], - ["Post",HUB.Startup.signal,"MathEvents Ready"], - ["loadComplete",AJAX,"[MathJax]/extensions/MathEvents.js"] - ); +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/MiscSymbolsAndArrows.js + * + * Copyright (c) 2010-2017 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. + * + */ -})(MathJax.Hub,MathJax.HTML,MathJax.Ajax,MathJax.Callback, - MathJax.Localization,MathJax.OutputJax,MathJax.InputJax); +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; -/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */ -/* vim: set ts=2 et sw=2 tw=80: */ + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + infix: { + '\u2B45': MO.RELSTRETCH, // leftwards quadruple arrow + '\u2B46': MO.RELSTRETCH // rightwards quadruple arrow + } + } + }); + + MathJax.Ajax.loadComplete(MML.optableDir+"/MiscSymbolsAndArrows.js"); + +})(MathJax.ElementJax.mml); /************************************************************* * - * MathJax/extensions/tex2jax.js - * - * Implements the TeX to Jax preprocessor that locates TeX code - * within the text of a document and replaces it with SCRIPT tags - * for processing by MathJax. + * MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js + * + * Copyright (c) 2010-2017 The MathJax Consortium * - * --------------------------------------------------------------------- - * - * Copyright (c) 2009-2017 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 - * + * + * http://www.apache.org/licenses/LICENSE-2.0 + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * */ -MathJax.Extension.tex2jax = { - version: "2.7.2", - config: { - inlineMath: [ // The start/stop pairs for in-line math -// ['$','$'], // (comment out any you don't want, or add your own, but - ['\\(','\\)'] // be sure that you don't have an extra comma at the end) - ], +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - displayMath: [ // The start/stop pairs for display math - ['$$','$$'], // (comment out any you don't want, or add your own, but - ['\\[','\\]'] // be sure that you don't have an extra comma at the end) - ], + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + postfix: { + '\u0311': MO.ACCENT // combining inverted breve + } + } + }); - balanceBraces: true, // determines whether tex2jax requires braces to be - // balanced within math delimiters (allows for nested - // dollar signs). Set to false to get pre-v2.0 compatibility. + MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiacritMarks.js"); - skipTags: ["script","noscript","style","textarea","pre","code","annotation","annotation-xml"], - // The names of the tags whose contents will not be - // scanned for math delimiters +})(MathJax.ElementJax.mml); - ignoreClass: "tex2jax_ignore", // the class name of elements whose contents should - // NOT be processed by tex2jax. Note that this - // is a regular expression, so be sure to quote any - // regexp special characters +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js + * + * Copyright (c) 2010-2017 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. + * + */ - processClass: "tex2jax_process", // the class name of elements whose contents SHOULD - // be processed when they appear inside ones that - // are ignored. Note that this is a regular expression, - // so be sure to quote any regexp special characters +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - processEscapes: false, // set to true to allow \$ to produce a dollar without - // starting in-line math mode + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + infix: { + '\u25A0': MO.BIN3, // black square + '\u25A1': MO.BIN3, // white square + '\u25AA': MO.BIN3, // black small square + '\u25AB': MO.BIN3, // white small square + '\u25AD': MO.BIN3, // white rectangle + '\u25AE': MO.BIN3, // black vertical rectangle + '\u25AF': MO.BIN3, // white vertical rectangle + '\u25B0': MO.BIN3, // black parallelogram + '\u25B1': MO.BIN3, // white parallelogram + '\u25B2': MO.BIN4, // black up-pointing triangle + '\u25B4': MO.BIN4, // black up-pointing small triangle + '\u25B6': MO.BIN4, // black right-pointing triangle + '\u25B7': MO.BIN4, // white right-pointing triangle + '\u25B8': MO.BIN4, // black right-pointing small triangle + '\u25BC': MO.BIN4, // black down-pointing triangle + '\u25BE': MO.BIN4, // black down-pointing small triangle + '\u25C0': MO.BIN4, // black left-pointing triangle + '\u25C1': MO.BIN4, // white left-pointing triangle + '\u25C2': MO.BIN4, // black left-pointing small triangle + '\u25C4': MO.BIN4, // black left-pointing pointer + '\u25C5': MO.BIN4, // white left-pointing pointer + '\u25C6': MO.BIN4, // black diamond + '\u25C7': MO.BIN4, // white diamond + '\u25C8': MO.BIN4, // white diamond containing black small diamond + '\u25C9': MO.BIN4, // fisheye + '\u25CC': MO.BIN4, // dotted circle + '\u25CD': MO.BIN4, // circle with vertical fill + '\u25CE': MO.BIN4, // bullseye + '\u25CF': MO.BIN4, // black circle + '\u25D6': MO.BIN4, // left half black circle + '\u25D7': MO.BIN4, // right half black circle + '\u25E6': MO.BIN4 // white bullet + } + } + }); - processEnvironments: true, // set to true to process \begin{xxx}...\end{xxx} outside - // of math mode, false to prevent that + MathJax.Ajax.loadComplete(MML.optableDir+"/GeometricShapes.js"); - processRefs: true, // set to true to process \ref{...} outside of math mode +})(MathJax.ElementJax.mml); +/************************************************************* + * + * MathJax/jax/output/HTML-CSS/optable/MathOperators.js + * + * Copyright (c) 2010-2017 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. + * + */ - preview: "TeX" // set to "none" to not insert MathJax_Preview spans - // or set to an array specifying an HTML snippet - // to use the same preview for every equation. +(function (MML) { + var MO = MML.mo.OPTYPES; + var TEXCLASS = MML.TEXCLASS; - }, - - // - // Tags to ignore when searching for TeX in the page - // - ignoreTags: { - br: (MathJax.Hub.Browser.isMSIE && document.documentMode < 9 ? "\n" : " "), - wbr: "", - "#comment": "" - }, - - PreProcess: function (element) { - if (!this.configured) { - this.config = MathJax.Hub.CombineConfig("tex2jax",this.config); - if (this.config.Augment) {MathJax.Hub.Insert(this,this.config.Augment)} - if (typeof(this.config.previewTeX) !== "undefined" && !this.config.previewTeX) - {this.config.preview = "none"} // backward compatibility for previewTeX parameter - this.configured = true; - } - if (typeof(element) === "string") {element = document.getElementById(element)} - if (!element) {element = document.body} - if (this.createPatterns()) {this.scanElement(element,element.nextSibling)} - }, - - createPatterns: function () { - var starts = [], parts = [], i, m, config = this.config; - this.match = {}; - for (i = 0, m = config.inlineMath.length; i < m; i++) { - starts.push(this.patternQuote(config.inlineMath[i][0])); - this.match[config.inlineMath[i][0]] = { - mode: "", - end: config.inlineMath[i][1], - pattern: this.endPattern(config.inlineMath[i][1]) - }; - } - for (i = 0, m = config.displayMath.length; i < m; i++) { - starts.push(this.patternQuote(config.displayMath[i][0])); - this.match[config.displayMath[i][0]] = { - mode: "; mode=display", - end: config.displayMath[i][1], - pattern: this.endPattern(config.displayMath[i][1]) - }; - } - if (starts.length) {parts.push(starts.sort(this.sortLength).join("|"))} - if (config.processEnvironments) {parts.push("\\\\begin\\{([^}]*)\\}")} - if (config.processEscapes) {parts.push("\\\\*\\\\\\\$")} - if (config.processRefs) {parts.push("\\\\(eq)?ref\\{[^}]*\\}")} - this.start = new RegExp(parts.join("|"),"g"); - this.skipTags = new RegExp("^("+config.skipTags.join("|")+")$","i"); - var ignore = []; - if (MathJax.Hub.config.preRemoveClass) {ignore.push(MathJax.Hub.config.preRemoveClass)}; - if (config.ignoreClass) {ignore.push(config.ignoreClass)} - this.ignoreClass = (ignore.length ? new RegExp("(^| )("+ignore.join("|")+")( |$)") : /^$/); - this.processClass = new RegExp("(^| )("+config.processClass+")( |$)"); - return (parts.length > 0); - }, - - patternQuote: function (s) {return s.replace(/([\^$(){}+*?\-|\[\]\:\\])/g,'\\$1')}, - - endPattern: function (end) { - return new RegExp(this.patternQuote(end)+"|\\\\.|[{}]","g"); - }, - - sortLength: function (a,b) { - if (a.length !== b.length) {return b.length - a.length} - return (a == b ? 0 : (a < b ? -1 : 1)); - }, - - scanElement: function (element,stop,ignore) { - var cname, tname, ignoreChild, process; - while (element && element != stop) { - if (element.nodeName.toLowerCase() === '#text') { - if (!ignore) {element = this.scanText(element)} - } else { - cname = (typeof(element.className) === "undefined" ? "" : element.className); - tname = (typeof(element.tagName) === "undefined" ? "" : element.tagName); - if (typeof(cname) !== "string") {cname = String(cname)} // jsxgraph uses non-string class names! - process = this.processClass.exec(cname); - if (element.firstChild && !cname.match(/(^| )MathJax/) && - (process || !this.skipTags.exec(tname))) { - ignoreChild = (ignore || this.ignoreClass.exec(cname)) && !process; - this.scanElement(element.firstChild,stop,ignoreChild); - } - } - if (element) {element = element.nextSibling} - } - }, - - scanText: function (element) { - if (element.nodeValue.replace(/\s+/,'') == '') {return element} - var match, prev; - this.search = {start: true}; - this.pattern = this.start; - while (element) { - this.pattern.lastIndex = 0; - while (element && element.nodeName.toLowerCase() === '#text' && - (match = this.pattern.exec(element.nodeValue))) { - if (this.search.start) {element = this.startMatch(match,element)} - else {element = this.endMatch(match,element)} - } - if (this.search.matched) {element = this.encloseMath(element)} - if (element) { - do {prev = element; element = element.nextSibling} - while (element && this.ignoreTags[element.nodeName.toLowerCase()] != null); - if (!element || element.nodeName !== '#text') - {return (this.search.close ? this.prevEndMatch() : prev)} - } - } - return element; - }, - - startMatch: function (match,element) { - var delim = this.match[match[0]]; - if (delim != null) { // a start delimiter - this.search = { - end: delim.end, mode: delim.mode, pcount: 0, - open: element, olen: match[0].length, opos: this.pattern.lastIndex - match[0].length - }; - this.switchPattern(delim.pattern); - } else if (match[0].substr(0,6) === "\\begin") { // \begin{...} - this.search = { - end: "\\end{"+match[1]+"}", mode: "; mode=display", pcount: 0, - open: element, olen: 0, opos: this.pattern.lastIndex - match[0].length, - isBeginEnd: true - }; - this.switchPattern(this.endPattern(this.search.end)); - } else if (match[0].substr(0,4) === "\\ref" || match[0].substr(0,6) === "\\eqref") { - this.search = { - mode: "", end: "", open: element, pcount: 0, - olen: 0, opos: this.pattern.lastIndex - match[0].length - } - return this.endMatch([""],element); - } else { // escaped dollar signs - // put $ in a span so it doesn't get processed again - // split off backslashes so they don't get removed later - var slashes = match[0].substr(0,match[0].length-1), n, span; - if (slashes.length % 2 === 0) {span = [slashes.replace(/\\\\/g,"\\")]; n = 1} - else {span = [slashes.substr(1).replace(/\\\\/g,"\\"),"$"]; n = 0} - span = MathJax.HTML.Element("span",null,span); - var text = MathJax.HTML.TextNode(element.nodeValue.substr(0,match.index)); - element.nodeValue = element.nodeValue.substr(match.index + match[0].length - n); - element.parentNode.insertBefore(span,element); - element.parentNode.insertBefore(text,span); - this.pattern.lastIndex = n; - } - return element; - }, - - endMatch: function (match,element) { - var search = this.search; - if (match[0] == search.end) { - if (!search.close || search.pcount === 0) { - search.close = element; - search.cpos = this.pattern.lastIndex; - search.clen = (search.isBeginEnd ? 0 : match[0].length); - } - if (search.pcount === 0) { - search.matched = true; - element = this.encloseMath(element); - this.switchPattern(this.start); - } - } - else if (match[0] === "{") {search.pcount++} - else if (match[0] === "}" && search.pcount) {search.pcount--} - return element; - }, - prevEndMatch: function () { - this.search.matched = true; - var element = this.encloseMath(this.search.close); - this.switchPattern(this.start); - return element; - }, - - switchPattern: function (pattern) { - pattern.lastIndex = this.pattern.lastIndex; - this.pattern = pattern; - this.search.start = (pattern === this.start); - }, - - encloseMath: function (element) { - var search = this.search, close = search.close, CLOSE, math, next; - if (search.cpos === close.length) {close = close.nextSibling} - else {close = close.splitText(search.cpos)} - if (!close) {CLOSE = close = MathJax.HTML.addText(search.close.parentNode,"")} - search.close = close; - math = (search.opos ? search.open.splitText(search.opos) : search.open); - while ((next = math.nextSibling) && next !== close) { - if (next.nodeValue !== null) { - if (next.nodeName === "#comment") { - math.nodeValue += next.nodeValue.replace(/^\[CDATA\[((.|\n|\r)*)\]\]$/,"$1"); - } else { - math.nodeValue += next.nodeValue; - } - } else { - var ignore = this.ignoreTags[next.nodeName.toLowerCase()]; - math.nodeValue += (ignore == null ? " " : ignore); + MathJax.Hub.Insert(MML.mo.prototype,{ + OPTABLE: { + prefix: { + '\u2204': MO.ORD21, // there does not exist + '\u221B': MO.ORD11, // cube root + '\u221C': MO.ORD11, // fourth root + '\u2221': MO.ORD, // measured angle + '\u2222': MO.ORD, // spherical angle + '\u222C': MO.INTEGRAL, // double integral + '\u222D': MO.INTEGRAL, // triple integral + '\u222F': MO.INTEGRAL, // surface integral + '\u2230': MO.INTEGRAL, // volume integral + '\u2231': MO.INTEGRAL, // clockwise integral + '\u2232': MO.INTEGRAL, // clockwise contour integral + '\u2233': MO.INTEGRAL // anticlockwise contour integral + }, + infix: { + '\u2201': [1,2,TEXCLASS.ORD], // complement + '\u2206': MO.BIN3, // increment + '\u220A': MO.REL, // small element of + '\u220C': MO.REL, // does not contain as member + '\u220D': MO.REL, // small contains as member + '\u220E': MO.BIN3, // end of proof + '\u2214': MO.BIN4, // dot plus + '\u221F': MO.REL, // right angle + '\u2224': MO.REL, // does not divide + '\u2226': MO.REL, // not parallel to + '\u2234': MO.REL, // therefore + '\u2235': MO.REL, // because + '\u2236': MO.REL, // ratio + '\u2237': MO.REL, // proportion + '\u2238': MO.BIN4, // dot minus + '\u2239': MO.REL, // excess + '\u223A': MO.BIN4, // geometric proportion + '\u223B': MO.REL, // homothetic + '\u223D': MO.REL, // reversed tilde + '\u223D\u0331': MO.BIN3, // reversed tilde with underline + '\u223E': MO.REL, // inverted lazy s + '\u223F': MO.BIN3, // sine wave + '\u2241': MO.REL, // not tilde + '\u2242': MO.REL, // minus tilde + '\u2242\u0338': MO.REL, // minus tilde with slash + '\u2244': MO.REL, // not asymptotically equal to + '\u2246': MO.REL, // approximately but not actually equal to + '\u2247': MO.REL, // neither approximately nor actually equal to + '\u2249': MO.REL, // not almost equal to + '\u224A': MO.REL, // almost equal or equal to + '\u224B': MO.REL, // triple tilde + '\u224C': MO.REL, // all equal to + '\u224E': MO.REL, // geometrically equivalent to + '\u224E\u0338': MO.REL, // geometrically equivalent to with slash + '\u224F': MO.REL, // difference between + '\u224F\u0338': MO.REL, // difference between with slash + '\u2251': MO.REL, // geometrically equal to + '\u2252': MO.REL, // approximately equal to or the image of + '\u2253': MO.REL, // image of or approximately equal to + '\u2254': MO.REL, // colon equals + '\u2255': MO.REL, // equals colon + '\u2256': MO.REL, // ring in equal to + '\u2257': MO.REL, // ring equal to + '\u2258': MO.REL, // corresponds to + '\u2259': MO.REL, // estimates + '\u225A': MO.REL, // equiangular to + '\u225C': MO.REL, // delta equal to + '\u225D': MO.REL, // equal to by definition + '\u225E': MO.REL, // measured by + '\u225F': MO.REL, // questioned equal to + '\u2262': MO.REL, // not identical to + '\u2263': MO.REL, // strictly equivalent to + '\u2266': MO.REL, // less-than over equal to + '\u2266\u0338': MO.REL, // less-than over equal to with slash + '\u2267': MO.REL, // greater-than over equal to + '\u2268': MO.REL, // less-than but not equal to + '\u2269': MO.REL, // greater-than but not equal to + '\u226A\u0338': MO.REL, // much less than with slash + '\u226B\u0338': MO.REL, // much greater than with slash + '\u226C': MO.REL, // between + '\u226D': MO.REL, // not equivalent to + '\u226E': MO.REL, // not less-than + '\u226F': MO.REL, // not greater-than + '\u2270': MO.REL, // neither less-than nor equal to + '\u2271': MO.REL, // neither greater-than nor equal to + '\u2272': MO.REL, // less-than or equivalent to + '\u2273': MO.REL, // greater-than or equivalent to + '\u2274': MO.REL, // neither less-than nor equivalent to + '\u2275': MO.REL, // neither greater-than nor equivalent to + '\u2276': MO.REL, // less-than or greater-than + '\u2277': MO.REL, // greater-than or less-than + '\u2278': MO.REL, // neither less-than nor greater-than + '\u2279': MO.REL, // neither greater-than nor less-than + '\u227C': MO.REL, // precedes or equal to + '\u227D': MO.REL, // succeeds or equal to + '\u227E': MO.REL, // precedes or equivalent to + '\u227F': MO.REL, // succeeds or equivalent to + '\u227F\u0338': MO.REL, // succeeds or equivalent to with slash + '\u2280': MO.REL, // does not precede + '\u2281': MO.REL, // does not succeed + '\u2282\u20D2': MO.REL, // subset of with vertical line + '\u2283\u20D2': MO.REL, // superset of with vertical line + '\u2284': MO.REL, // not a subset of + '\u2285': MO.REL, // not a superset of + '\u2288': MO.REL, // neither a subset of nor equal to + '\u2289': MO.REL, // neither a superset of nor equal to + '\u228A': MO.REL, // subset of with not equal to + '\u228B': MO.REL, // superset of with not equal to + '\u228C': MO.BIN4, // multiset + '\u228D': MO.BIN4, // multiset multiplication + '\u228F': MO.REL, // square image of + '\u228F\u0338': MO.REL, // square image of with slash + '\u2290': MO.REL, // square original of + '\u2290\u0338': MO.REL, // square original of with slash + '\u229A': MO.BIN4, // circled ring operator + '\u229B': MO.BIN4, // circled asterisk operator + '\u229C': MO.BIN4, // circled equals + '\u229D': MO.BIN4, // circled dash + '\u229E': MO.BIN4, // squared plus + '\u229F': MO.BIN4, // squared minus + '\u22A0': MO.BIN4, // squared times + '\u22A1': MO.BIN4, // squared dot operator + '\u22A6': MO.REL, // assertion + '\u22A7': MO.REL, // models + '\u22A9': MO.REL, // forces + '\u22AA': MO.REL, // triple vertical bar right turnstile + '\u22AB': MO.REL, // double vertical bar double right turnstile + '\u22AC': MO.REL, // does not prove + '\u22AD': MO.REL, // not true + '\u22AE': MO.REL, // does not force + '\u22AF': MO.REL, // negated double vertical bar double right turnstile + '\u22B0': MO.REL, // precedes under relation + '\u22B1': MO.REL, // succeeds under relation + '\u22B2': MO.REL, // normal subgroup of + '\u22B3': MO.REL, // contains as normal subgroup + '\u22B4': MO.REL, // normal subgroup of or equal to + '\u22B5': MO.REL, // contains as normal subgroup or equal to + '\u22B6': MO.REL, // original of + '\u22B7': MO.REL, // image of + '\u22B8': MO.REL, // multimap + '\u22B9': MO.REL, // hermitian conjugate matrix + '\u22BA': MO.BIN4, // intercalate + '\u22BB': MO.BIN4, // xor + '\u22BC': MO.BIN4, // nand + '\u22BD': MO.BIN4, // nor + '\u22BE': MO.BIN3, // right angle with arc + '\u22BF': MO.BIN3, // right triangle + '\u22C7': MO.BIN4, // division times + '\u22C9': MO.BIN4, // left normal factor semidirect product + '\u22CA': MO.BIN4, // right normal factor semidirect product + '\u22CB': MO.BIN4, // left semidirect product + '\u22CC': MO.BIN4, // right semidirect product + '\u22CD': MO.REL, // reversed tilde equals + '\u22CE': MO.BIN4, // curly logical or + '\u22CF': MO.BIN4, // curly logical and + '\u22D0': MO.REL, // double subset + '\u22D1': MO.REL, // double superset + '\u22D2': MO.BIN4, // double intersection + '\u22D3': MO.BIN4, // double union + '\u22D4': MO.REL, // pitchfork + '\u22D5': MO.REL, // equal and parallel to + '\u22D6': MO.REL, // less-than with dot + '\u22D7': MO.REL, // greater-than with dot + '\u22D8': MO.REL, // very much less-than + '\u22D9': MO.REL, // very much greater-than + '\u22DA': MO.REL, // less-than equal to or greater-than + '\u22DB': MO.REL, // greater-than equal to or less-than + '\u22DC': MO.REL, // equal to or less-than + '\u22DD': MO.REL, // equal to or greater-than + '\u22DE': MO.REL, // equal to or precedes + '\u22DF': MO.REL, // equal to or succeeds + '\u22E0': MO.REL, // does not precede or equal + '\u22E1': MO.REL, // does not succeed or equal + '\u22E2': MO.REL, // not square image of or equal to + '\u22E3': MO.REL, // not square original of or equal to + '\u22E4': MO.REL, // square image of or not equal to + '\u22E5': MO.REL, // square original of or not equal to + '\u22E6': MO.REL, // less-than but not equivalent to + '\u22E7': MO.REL, // greater-than but not equivalent to + '\u22E8': MO.REL, // precedes but not equivalent to + '\u22E9': MO.REL, // succeeds but not equivalent to + '\u22EA': MO.REL, // not normal subgroup of + '\u22EB': MO.REL, // does not contain as normal subgroup + '\u22EC': MO.REL, // not normal subgroup of or equal to + '\u22ED': MO.REL, // does not contain as normal subgroup or equal + '\u22F0': MO.REL, // up right diagonal ellipsis + '\u22F2': MO.REL, // element of with long horizontal stroke + '\u22F3': MO.REL, // element of with vertical bar at end of horizontal stroke + '\u22F4': MO.REL, // small element of with vertical bar at end of horizontal stroke + '\u22F5': MO.REL, // element of with dot above + '\u22F6': MO.REL, // element of with overbar + '\u22F7': MO.REL, // small element of with overbar + '\u22F8': MO.REL, // element of with underbar + '\u22F9': MO.REL, // element of with two horizontal strokes + '\u22FA': MO.REL, // contains with long horizontal stroke + '\u22FB': MO.REL, // contains with vertical bar at end of horizontal stroke + '\u22FC': MO.REL, // small contains with vertical bar at end of horizontal stroke + '\u22FD': MO.REL, // contains with overbar + '\u22FE': MO.REL, // small contains with overbar + '\u22FF': MO.REL // z notation bag membership } - math.parentNode.removeChild(next); - } - var TeX = math.nodeValue.substr(search.olen,math.nodeValue.length-search.olen-search.clen); - math.parentNode.removeChild(math); - if (this.config.preview !== "none") {this.createPreview(search.mode,TeX)} - math = this.createMathTag(search.mode,TeX); - this.search = {}; this.pattern.lastIndex = 0; - if (CLOSE) {CLOSE.parentNode.removeChild(CLOSE)} - return math; - }, - - insertNode: function (node) { - var search = this.search; - search.close.parentNode.insertBefore(node,search.close); - }, - - createPreview: function (mode,tex) { - var previewClass = MathJax.Hub.config.preRemoveClass; - var preview = this.config.preview; - if (preview === "none") return; - if ((this.search.close.previousSibling||{}).className === previewClass) return; - if (preview === "TeX") {preview = [this.filterPreview(tex)]} - if (preview) { - preview = MathJax.HTML.Element("span",{className:previewClass},preview); - this.insertNode(prev <TRUNCATED>
