Document Options

The options below control the operation of the MathDocument object created by MathJax to process the mathematics in your web page. They are listed with their default values. To set any of these options, include an options section in your MathJax global object.

The Configuration Block

MathJax = {
  options: {
    skipHtmlTags: [            //  HTML tags that won't be searched for math
        'script', 'noscript', 'style', 'textarea', 'pre',
        'code', 'annotation', 'annotation-xml'
    ],
    includeHtmlTags: {         //  HTML tags that can appear within math
        br: '\n', wbr: '', '#comment': ''
    },
    ignoreHtmlClass: 'tex2jax_ignore',    //  class that marks tags not to search
    processHtmlClass: 'tex2jax_process',  //  class that marks tags that should be searched
    compileError: function (doc, math, err) {doc.compileError(math, err)},
    typesetError: function (doc, math, err) {doc.typesetError(math, err)},
    renderActions: {...}
  }
};

Option Descriptions

skipHtmlTags: ['script', 'noscript', 'style', 'textarea',

'pre', 'code', 'annotation', 'annotation-xml']

This array lists the names of the tags whose contents should not be processed by MathJaX (other than to look for ignore/process classes as listed below). You can add to (or remove from) this list to prevent MathJax from processing mathematics in specific contexts. E.g.,

skipHtmlTags: {'[-]': ['code', 'pre'], '[+]': ['li']}

would remove 'code' and 'pre' tags from the list, while adding 'li' tags to the list.

includeHtmlTags: {br: '\n', wbr: '', '#comment': ''}: This object specifies what tags can appear within a math expression, and what text to replace them by within the math. The default is to allow <br>, which becomes a newline, and <wbr> and HTML comments, which are removed entirely.

ignoreHtmlClass: 'mathjax_ignore': This is the class name used to mark elements whose contents should not be processed by MathJax (other than to look for the processHtmlClass pattern below). Note that this is a regular expression, and so you need to be sure to quote any regexp special characters. The pattern is inserted into one that requires your pattern to match a complete word, so setting ignoreHtmlClass: 'class2' would cause it to match an element with class='class1 class2 class3' but not class='myclass2'. Note that you can assign several classes by separating them by the vertical line character (|). For instance, with ignoreHtmlClass: 'class1|class2' any element assigned a class of either class1 or class2 will be skipped. This could also be specified by ignoreHtmlClass: 'class[12]', which matches class followed by either a 1 or a 2.

processHtmlClass: 'mathjax_process': This is the class name used to mark elements whose contents should be processed by MathJax. This is used to restart processing within tags that have been marked as ignored via the ignoreHtmlClass or to cause a tag that appears in the skipHtmlTags list to be processed rather than skipped. Note that this is a regular expression, and so you need to be sure to quote any regexp special characters. The pattern is inserted into one that requires your pattern to match a complete word, so setting processHtmlClass: 'class2' would cause it to match an element with class='class1 class2 class3' but not class='myclass2'. Note that you can assign several classes by separating them by the vertical line character (|). For instance, with processHtmlClass: 'class1|class2' any element assigned a class of either class1 or class2 will have its contents processed. This could also be specified by processHtmlClass: 'class[12]', which matches class followed by either a 1 or a 2.

compileError: function (doc, math, err) {doc.compileError(math, err)}: This is the function called whenever there is an uncaught error while an input jax is running (i.e., during the document’s compile() call). The arguments are the MathDocument in which the error occurred, the MathItem for the expression where it occurred, and the Error object for the uncaught error. The default action is to call the document’s default compileError() function, which sets math.root to a math element containing an error message (i.e., <math><merror><mtext>Math input error<mtext></merror></math>). You can replace this with your own function for trapping run-time errors in the input processors.

typesetError: function (doc, math, err) {doc.typesetError(math, err)}: This is the function called whenever there is an uncaught error while an output jax is running (i.e., during the document’s typeset() call). The arguments are the MathDocument in which the error occurred, the MathItem for the expression where it occurred, and the Error object for the uncaught error. The default action is to call the document’s default typesetError() function, which sets math.typesetRoot to a <span> element containing the text Math output error. You can replace this with your own function for trapping run-time errors in the output processors.

renderActions: {...}

This is an object that specifies the actions to take during the MathJax.typeset() (and its underlying MathJax.startup.document.render() call), and the various conversion functions, such as MathJax.tex2svg() (and their underlying MathJax.startup.document.convert() call). The structure of the object is name: value pairs separated by commas, where the name gives an identifier for each action, and the value is an array consisting of a number and zero, one, or two functions, followed optionally by a boolean value.

The number gives the priority of the action (lower numbers are executed first when the actions are performed). The first function gives the action to perform when a document is rendered as a whole, and the second a function to perform when an individual expression is converted or re-rendered. These can be given either as an explicit function, or as a string giving the name of a method to call (the first should be a method of a MathDocument, and the second of a MathItem). If either is an empty string, that action is not performed. If the function is missing, the method name is taken from the name of the action. The boolean value tells whether the second function should be performed during a convert() call (when true) or only during a rerender() call (when false).

For example,

MathJax = {
  options: {
    renderActions: {
      compile: [MathItem.STATE.COMPILED],
      metrics: [MathItem.STATE.METRICS, 'getMetrics', '', false]
    }
  }
};

specifies two actions, the first called compile that uses the compile() method of the MathDocument and MathItem, and the second called metrics that uses the getMetric() call for the MathDocument when the document is rendered, but does nothing during a rerender() or convert() call or an individual MathItem.

If the first function is given explicitly, it should take one argument, the MathDocument on which it is running. If the second function is given explicitly, it should take two arguments, the MathItem that is being processed, and the MathDocument in which it exists.

The default value includes actions for the main calls needed to perform rendering of math: find, compile, metrics, typeset, update, and reset. These find the math in the document, call the input jax on the math that was located, obtain the metric information for the location of the math, call the output jax to convert the internal format to the output format, insert the output into the document, and finally reset the internal flags so that a subsequent typesetting action will process properly.

You can add your own actions by adding new named actions to the renderActions object, or override existing ones by re-using an existing name from above. See the MathML Support section for an example of doing this. The priority number tells where in the list your actions will be performed.

Loading extensions may cause additional actions to be inserted into the list. For example, the ui/menu component inserts an action to add the menu event handlers to the math after it is inserted into the page.

Developer Options

OutputJax: null: The OutputJax object instance to use for this MathDocument. If you are using MathJax components, the startup component will create this automatically. If you are writing a Node application accessing MathJax code directly, you will need to create the output jax yourself and pass it to the document through this option.

InputJax: null: The InputJax object instance to use for this MathDocument. If you are using MathJax components, the startup component will create this automatically. If you are writing a Node application accessing MathJax code directly, you will need to create the input jax yourself and pass it to the document through this option.

MmlFactory: null: The MmlFactory object instance to use for creating the internal MathML objects. This allows you to create a subclass of MmlFactory and pass that to the document. A null value means use the default MmlFactory class and make a new instance of that.

MathList: DefaultMathList: The MathList object class to use for managing the list of MathItem objects associated with the MathDocument. This allows you to create a subclass of MathList and pass that to the document.

MathItem: DefaultMathItem: The MathItem object class to use for maintaining the information about a single expression in a MathDocument. This allows you to create a subclass of MathItem and pass that to the document. The document Handler object may define its own subclass of MathItem and use that as the default instead. For example, the HTML handler uses HTMLMathItem objects for this option.