diff options
Diffstat (limited to 'js/mathjax/extensions/toMathML.js')
-rw-r--r-- | js/mathjax/extensions/toMathML.js | 243 |
1 files changed, 243 insertions, 0 deletions
diff --git a/js/mathjax/extensions/toMathML.js b/js/mathjax/extensions/toMathML.js new file mode 100644 index 0000000..cb95c08 --- /dev/null +++ b/js/mathjax/extensions/toMathML.js @@ -0,0 +1,243 @@ +// @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/extensions/toMathML.js + * + * Implements a toMathML() method for the mml Element Jax that returns + * a MathML string from a given math expression. + * + * --------------------------------------------------------------------- + * + * Copyright (c) 2010-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. + */ + +MathJax.Hub.Register.LoadHook("[MathJax]/jax/element/mml/jax.js",function () { + var VERSION = "2.7.9"; + + var MML = MathJax.ElementJax.mml, + SETTINGS = MathJax.Hub.config.menuSettings; + + MML.mbase.Augment({ + + toMathML: function (space) { + var inferred = (this.inferred && this.parent.inferRow); + if (space == null) {space = ""} + var tag = this.type, attr = this.toMathMLattributes(); + if (tag === "mspace") {return space + "<"+tag+attr+" />"} + var data = [], SPACE = (this.isToken ? "" : space+(inferred ? "" : " ")); + for (var i = 0, m = this.data.length; i < m; i++) { + if (this.data[i]) {data.push(this.data[i].toMathML(SPACE))} + else if (!this.isToken && !this.isChars) {data.push(SPACE+"<mrow />")} + } + if (this.isToken || this.isChars) {return space + "<"+tag+attr+">"+data.join("")+"</"+tag+">"} + if (inferred) {return data.join("\n")} + if (data.length === 0 || (data.length === 1 && data[0] === "")) + {return space + "<"+tag+attr+" />"} + return space + "<"+tag+attr+">\n"+data.join("\n")+"\n"+ space +"</"+tag+">"; + }, + + toMathMLattributes: function () { + var defaults = (this.type === "mstyle" ? MML.math.prototype.defaults : this.defaults); + var names = (this.attrNames||MML.copyAttributeNames), + skip = MML.skipAttributes, copy = MML.copyAttributes; + var attr = []; + + if (this.type === "math" && (!this.attr || !('xmlns' in this.attr))) + {attr.push('xmlns="http://www.w3.org/1998/Math/MathML"')} + if (!this.attrNames) { + for (var id in defaults) {if (!skip[id] && !copy[id] && defaults.hasOwnProperty(id)) { + if (this[id] != null && this[id] !== defaults[id]) { + if (this.Get(id,null,1) !== this[id]) + attr.push(id+'="'+this.toMathMLattribute(this[id])+'"'); + } + }} + } + for (var i = 0, m = names.length; i < m; i++) { + if (copy[names[i]] === 1 && !defaults.hasOwnProperty(names[i])) continue; + value = (this.attr||{})[names[i]]; if (value == null) {value = this[names[i]]} + if (value != null) {attr.push(names[i]+'="'+this.toMathMLquote(value)+'"')} + } + this.toMathMLclass(attr); + if (attr.length) {return " "+attr.join(" ")} else {return ""} + }, + toMathMLclass: function (attr) { + var CLASS = []; if (this["class"]) {CLASS.push(this["class"])} + if (this.isa(MML.TeXAtom) && SETTINGS.texHints) { + var TEXCLASS = ["ORD","OP","BIN","REL","OPEN","CLOSE","PUNCT","INNER","VCENTER"][this.texClass]; + if (TEXCLASS) { + CLASS.push("MJX-TeXAtom-"+TEXCLASS) + if (TEXCLASS === "OP" && !this.movablelimits) CLASS.push("MJX-fixedlimits"); + } + } + if (this.mathvariant && this.toMathMLvariants[this.mathvariant]) + {CLASS.push("MJX"+this.mathvariant)} + if (this.variantForm) {CLASS.push("MJX-variant")} + if (CLASS.length) {attr.unshift('class="'+this.toMathMLquote(CLASS.join(" "))+'"')} + }, + toMathMLattribute: function (value) { + if (typeof(value) === "string" && + value.replace(/ /g,"").match(/^(([-+])?(\d+(\.\d*)?|\.\d+))mu$/)) { + // FIXME: should take scriptlevel into account + return (RegExp.$2||"")+((1/18)*RegExp.$3).toFixed(3).replace(/\.?0+$/,"")+"em"; + } + else if (this.toMathMLvariants[value]) {return this.toMathMLvariants[value]} + return this.toMathMLquote(value); + }, + toMathMLvariants: { + "-tex-caligraphic": MML.VARIANT.SCRIPT, + "-tex-caligraphic-bold": MML.VARIANT.BOLDSCRIPT, + "-tex-oldstyle": MML.VARIANT.NORMAL, + "-tex-oldstyle-bold": MML.VARIANT.BOLD, + "-tex-mathit": MML.VARIANT.ITALIC + }, + + toMathMLquote: function (string) { + string = String(string).split(""); + for (var i = 0, m = string.length; i < m; i++) { + var n = string[i].charCodeAt(0); + if (n <= 0xD7FF || 0xE000 <= n) { + // Code points U+0000 to U+D7FF and U+E000 to U+FFFF. + // They are directly represented by n. + if (n > 0x7E || (n < 0x20 && n !== 0x0A && n !== 0x0D && n !== 0x09)) { + string[i] = "&#x"+n.toString(16).toUpperCase()+";"; + } else { + var c = + {'&':'&', '<':'<', '>':'>', '"':'"'}[string[i]]; + if (c) {string[i] = c} + } + } else if (i+1 < m) { + // Code points U+10000 to U+10FFFF. + // n is the lead surrogate, let's read the trail surrogate. + var trailSurrogate = string[i+1].charCodeAt(0); + var codePoint = (((n-0xD800)<<10)+(trailSurrogate-0xDC00)+0x10000); + string[i] = "&#x"+codePoint.toString(16).toUpperCase()+";"; + string[i+1] = ""; + i++; + } else { + // n is a lead surrogate without corresponding trail surrogate: + // remove that character. + string[i] = ""; + } + } + return string.join(""); + } + }); + + // + // Override math.toMathML in order to add semantics tag + // for the input format, if the user requests that in the + // Show As menu. + // + MML.math.Augment({ + toMathML: function (space,jax) { + var annotation; + if (space == null) {space = ""} + if (jax && jax.originalText && SETTINGS.semantics) + {annotation = MathJax.InputJax[jax.inputJax].annotationEncoding} + var nested = (this.data[0] && this.data[0].data.length > 1); + var tag = this.type, attr = this.toMathMLattributes(); + var data = [], SPACE = space + (annotation ? " " + (nested ? " " : "") : "") + " "; + for (var i = 0, m = this.data.length; i < m; i++) { + if (this.data[i]) {data.push(this.data[i].toMathML(SPACE))} + else {data.push(SPACE+"<mrow />")} + } + if (data.length === 0 || (data.length === 1 && data[0] === "")) { + if (!annotation) {return "<"+tag+attr+" />"} + data.push(SPACE+"<mrow />"); + } + if (annotation) { + if (nested) {data.unshift(space+" <mrow>"); data.push(space+" </mrow>")} + data.unshift(space+" <semantics>"); + var xmlEscapedTex = jax.originalText.replace(/[&<>]/g, function(item) { + return { '>': '>', '<': '<','&': '&' }[item] + }); + data.push(space+' <annotation encoding="'+this.toMathMLquote(annotation)+'">'+xmlEscapedTex+"</annotation>"); + data.push(space+" </semantics>"); + } + return space+"<"+tag+attr+">\n"+data.join("\n")+"\n"+space+"</"+tag+">"; + } + }); + + MML.msubsup.Augment({ + toMathML: function (space) { + var tag = this.type; + if (this.data[this.sup] == null) {tag = "msub"} + if (this.data[this.sub] == null) {tag = "msup"} + var attr = this.toMathMLattributes(); + delete this.data[0].inferred; + var data = []; + for (var i = 0, m = this.data.length; i < m; i++) + {if (this.data[i]) {data.push(this.data[i].toMathML(space+" "))}} + return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">"; + } + }); + + MML.munderover.Augment({ + toMathML: function (space) { + var tag = this.type; + var base = this.data[this.base]; + if (base && base.isa(MML.TeXAtom) && base.movablelimits && !base.Get("displaystyle")) { + type = "msubsup"; + if (this.data[this.under] == null) {tag = "msup"} + if (this.data[this.over] == null) {tag = "msub"} + } else { + if (this.data[this.under] == null) {tag = "mover"} + if (this.data[this.over] == null) {tag = "munder"} + } + var attr = this.toMathMLattributes(); + delete this.data[0].inferred; + var data = []; + for (var i = 0, m = this.data.length; i < m; i++) + {if (this.data[i]) {data.push(this.data[i].toMathML(space+" "))}} + return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">"; + } + }); + + MML.TeXAtom.Augment({ + toMathML: function (space) { + // FIXME: Handle spacing using mpadded? + var attr = this.toMathMLattributes(); + if (!attr && this.data[0].data.length === 1) {return space.substr(2) + this.data[0].toMathML(space)} + return space+"<mrow"+attr+">\n" + this.data[0].toMathML(space+" ")+"\n"+space+"</mrow>"; + } + }); + + MML.chars.Augment({ + toMathML: function (space) {return (space||"") + this.toMathMLquote(this.toString())} + }); + + MML.entity.Augment({ + toMathML: function (space) {return (space||"") + "&"+this.toMathMLquote(this.data[0])+";<!-- "+this.toString()+" -->"} + }); + + MML.xml.Augment({ + toMathML: function (space) {return (space||"") + this.toString()} + }); + + MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () { + MML.TeXmathchoice.Augment({ + toMathML: function (space) {return this.Core().toMathML(space)} + }); + }); + + MathJax.Hub.Startup.signal.Post("toMathML Ready"); + +}); + +MathJax.Ajax.loadComplete("[MathJax]/extensions/toMathML.js"); +// @license-end |