Abstract
Static
adaptorThe DOMAdaptor instance (created after everything is loaded)
Static
constructorsThe constructors (or other data) registered by the loaded packages
Static
defaultThe default OptionError function
Static
documentThe MathDocument instance being used (based on the browser DOM or configuration value)
Static
elementsThe elements to process (set when typeset or conversion method is called)
Static
extensionsThe array of handler extensions
Static
handlerThe Handler instance (created after everything is loaded)
Static
hasThis is true when MathJax.typeset() or MathJax.typesetPromise() have been called (used by the menu code to tell if a rerender action is needed when a component is loaded dynamically).
Static
inputThe array of InputJax instances (created after everything is loaded)
Static
outputThe OutputJax instance (created after everything is loaded)
Static
pageA promise that is resolved when the page contents are available for processing.
Static
promiseThe promise for the startup process (the initial typesetting). It is resolved or rejected in the ready() function.
Static
promiseThe function that rejects the first promise defined below (called in the defaultReady() function when MathJax's initial typesetting fails)
Static
promiseThe function that resolves the first promise defined below (called in the defaultReady() function when MathJax is finished with its initial typesetting)
Static
defaultThe default pageReady() function called when the page is ready to be processed, which returns a promise that does any initial font loading, plus the initial typesetting, if needed.
Setting Mathjax.startup.pageReady in the configuration will override this.
Promise resolving when page is ready to process.
Static
defaultThe default ready() function called when all the packages have been loaded, which creates the various objects needed by MathJax, creates the methods based on the loaded components, and does the initial typesetting.
Setting MathJax.startup.ready in the configuration will override this, but you can call MathJax.startup.defaultReady() within your own ready function if needed, or can use the individual methods below to perform portions of the default startup actions.
Static
extendA function to extend the handler class
The priority of the extension
Static
getThe instance of the registered DOMAdator (the registered constructor in this case is a function that creates the adaptor, not a class)
Static
getCreate the instances of the registered components
Static
getCreate the document with the given input and output jax
The Document to use as the root document (or null to use the configured document)
The MathDocument with the configured input and output jax
Static
getThe instance of the registered Handler, extended by the registered extensions
Static
getThe array of instances of the registered input jax
Static
getThe instance of the registered output jax
Static
makeMake the typeset and conversion methods based on the registered components
If there are both input and output jax, Make Typeset() and TypesetPromise() methods using the given jax, and TypesetClear() to clear the existing math items For each input jax Make input2mml() and input2mmlPromise() conversion methods and inputReset() method If there is a registered output jax Make input2output() and input2outputPromise conversion methods and outputStylesheet() method Create the MathJax.done() method. Create the MathJax.whenReady() method.
Static
makeMake the input2mml(math, options?) and input2mmlPromise(math, options?) methods, where "input" is replaced by the name of the input jax (e.g., "tex2mml").
These convert the math to its serialized MathML representation. The second wraps the conversion in handleRetriesFor() and returns the resulting promise.
The name of the input jax
The input jax itself
Static
makeMake the input2output(math, options?) and input2outputPromise(math, options?) methods, and outputStylesheet() method, where "input" and "output" are replaced by the jax names (e.g., tex2chtml() and chtmlStyleSheet()).
The first two perform the document's convert() call, with the Promise version wrapped in handlerRetriesFor() and returning the resulting promise. The return value is the DOM object for the converted math. Use MathJax.startup.adaptor.outerHTML(result) to get the serialized string version of the output.
The outputStylesheet() method returns the styleSheet object for the output. Use MathJax.startup.adaptor.innerHTML(MathJax.outputStylesheet()) to get the serialized version of the stylesheet. The getMetricsFor(node, display) method returns the metric data for the given node
The name of the input jax
The name of the output jax
The input jax instance
Static
makeCreates the inputReset() method, where "input" is replaced by the input jax name (e.g., "texReset()).
The texReset() method clears the equation numbers and labels
The name of the input jax
The input jax itself
Static
makeCreate the Typeset(elements?), TypesetPromise(elements?), and TypesetClear() methods.
The first two call the document's render() function, the latter wrapped in handleRetriesFor() and returning the resulting promise.
TypeseClear() clears all the MathItems from the document.
Static
registerThe identifier for the constructor
The constructor function for the named object
Static
toThe root of the tree to convert to serialized MathML
The serialized MathML from the tree
Static
typesetPerform the typesetting with handling of retries
The list of elements to typeset
The promise that resolves when elements are typeset
Static
useThe identifier for the DOMAdaptor to use
True to force the DOMAdaptor to be used even if one is already registered
Static
useThe identifier for the Handler to use
True to force the Handler to be used even if one is already registered
Static
useThe identifier for the InputJax to use
True to force the InputJax to be used even if the configuration already included an array of input jax
Static
useThe identifier for the OutputJax to use
True to force the OutputJax to be used even if one is already registered
The implementation of the startup module