fxEditor API

Creates an instance of LaTeXView for LaTeX input and associates it with an HTML element. To provide some introductory text, use the placeholder attribute as illustrated in the example below. Any introductory text is removed as soon as the user starts typing.

<div id="input" placeholder="Write LaTeX here"></div>
<script>
var ta = new EqEditor.LaTeXView('input', true);
</script>
Copy

Adds history, with undo and redo, to the LaTeXView. This requires a History menu to provide the necessary controls.

<div id="history"></div>
<div id="input"></div>
<script>
  EqEditor.LaTeXView.link('input')
    .addHistoryMenu(new EqEditor.History('history'));
</script>
Copy

Connects an Output to this LaTeXView. Every connected Output is refreshed whenever the equation changes. A mathview.MathView and a predictor.PredictorView register through this same call when they are linked to the LaTeXView, though their own addLaTeXView() is the call to make for those.

EqEditor.LaTeXView.link('input')
  .addOutput(EqEditor.Output.link('preview').setFormat('svg'))
  .addOutput(EqEditor.Output.link('code', 'html'));
Copy

Adding the same Output twice has no further effect.

Connects a Toolbar to this LaTeXView, so the toolbar's buttons insert into it. Whichever LaTeXView last had focus is the one a shared Toolbar sends its buttons to.

var tb = EqEditor.Toolbar.link('toolbar');
EqEditor.LaTeXView.link('input1').addToolbar(tb);
EqEditor.LaTeXView.link('input2').addToolbar(tb, false);
Copy

toolbar.Toolbar.addLaTeXView makes the same link from the toolbar's side.

Replaces part of the equation - the characters from from up to to - with text, as one step that one Undo takes back. Only the change is recorded in the history, not the equation.

var ta = EqEditor.LaTeXView.link('input');
ta.applyEdit({ from: 4, to: 7, text: '\\beta' });
Copy

Provides a convenient method of executing any Output class function across all of the Output areas associated with the LaTeXView. This is particularly useful when you have several outputs and need them all to change together.

For example, say you want to change the format for all the outputs:

<select id="format" onchange="textarea.callOutputs('setFormat', this.value);">
  <option value="svg">svg</option>
  <option value="png">png</option>
  <option value="gif">gif</option>
  <option value="pdf">pdf</option>
  <option value="mathml">mathml</option>
</select>
Copy

Any further arguments are passed on: textarea.callOutputs('setFormat', 'svg', false). A MathView or PredictorView linked to the LaTeXView has none of an Output's methods, and is skipped.

Clears the input box (LaTeXView), removing the equation and resetting the cursor. The LaTeXView takes focus, and every connected Output is updated. The clearing can be undone.

Call when a LaTeXView is being taken off the page - a dialog closing, say, or a per-cell editor in a table. It hides the suggestion list and removes the listeners the LaTeXView added, so that it and everything it refers to can be garbage collected. The element itself is left where it is. Closing twice is harmless.

Opens the Chemistry Structure Editor: on the \chemfig{...} the cursor is in, or on a new structure to insert at the cursor. Needs fxTeX Pro's chemfig package to show it - packages: ['chemfig'] to converter.init.

Opens the picture editor: on the picture environment the cursor is in, or on a new picture to insert at the cursor - what the toolbar's picture button calls. Needs fxTeX Pro's picture package to draw: packages: ['picture'] to converter.init.

Moves keyboard focus into this LaTeXView.

What has been typed into each slot of a locked equation, in the order the slots appear in the LaTeX - the student's answers, ready to mark. A slot left empty gives "". For \frac{}{2}=5 filled in as \frac{8}{2}=5, this returns ["8"].

var answers = textarea.getAnswers();   // e.g. ["8"]
Copy

Returns the HTML element backing this LaTeXView. Typically you will then read its textContent to retrieve the LaTeX formula.

The following example illustrates how a button onclick action can retrieve the content of a LaTeXView.

<div id="input"></div>
<button onclick="alert(textarea.getLaTeXView().textContent)">Show LaTeX</button>
<script>
  var textarea = EqEditor.LaTeXView.link('input');
</script>
Copy

Whether keyboard focus is inside this LaTeXView.

Inserts LaTeX into the LaTeXView at the current cursor position. Any text that is selected is wrapped by the insertion rather than replaced: selecting "x" and inserting \sqrt{} gives \sqrt{x}. This is what every toolbar button calls.

The following example inserts a fraction and places the cursor between the first curly braces:

<div id="input"></div>
<script>
var a = EqEditor.LaTeXView.link('input', true);
a.insert('\\frac{}{}', 6);
</script>
Copy

Returns true if the current LaTeXView is empty, false otherwise.

Formerly called isTextAreaEmpty(), which still works as an alias of this method.

Whether the equation is locked to its structure - see LaTeXView.structural_lock.

Inserts a matrix of the dimensions picked in the toolbar's matrix panel (LaTeXView.curMatrixDims), as start + \begin{typematrix}...\end{typematrix} + end. Called by the toolbar; a page has little reason to call it directly.

Inserts a block of equations, one line for each row of the dimensions picked in the toolbar's matrix panel (LaTeXView.curMatrixDims), inside \begin{type*}...\end{type*}. Called by the toolbar; a page has little reason to call it directly.

Notifies all connected History Menus of changes, so their buttons are enabled or disabled to match. The LaTeXView does this itself whenever its history changes.

Notifies all connected Outputs of changes. The LaTeXView does this itself after every edit; call it only if you have changed the editable element's content by some other means.

Records the LaTeXView's current text as a step in its undo history, if it differs from the last one recorded. Every edit made through the LaTeXView already does this; call it only after changing the editable element's content by some other means.

Only what changed is kept, not the whole equation: the span between what the text starts and ends with in common with the last step.

Reverts an undone change, i.e. redoes the most recently undone action. This is what the History menu's redo button calls.

Stops updating an Output, MathView or PredictorView added with LaTeXView.addOutput. A MathView's destroy() calls it for you; a page swapping one Output for another calls it for the old one, which the LaTeXView would otherwise go on updating and keeping alive.

textarea.removeOutput(oldOutput).addOutput(newOutput);
Copy

Enables or disables auto-insertion of matching close brackets when an open bracket is typed. It is enabled by default. The History menu carries a switch that sets the same thing.

Assigns the LaTeX commands that may be used within the formula. Any command breaking this condition is given the CSS class "CCrestricted", which by default shows it in red with a double underline. Override the CSS for "CCrestricted" to achieve alternative effects. The autosuggest list offers only the commands allowed.

EqEditor.LaTeXView.link('input')
  .setRestrictedCommands(['frac', 'sqrt', 'alpha', 'beta']);
Copy

Assigns the variables that may be used within the formula. Any variable breaking this condition is given the CSS class "CCrestricted", which by default shows it in red with a double underline. Use LaTeXView.validate to test the equation as a whole.

The words are also offered by the autosuggest list.

The following example allows the variable 'bill', and any that start with 'j' and end with 's':

var textarea = EqEditor.LaTeXView.link('latexInput', true)
  .addOutput(new EqEditor.Output('output'))
  .setRestrictedVariables(['bill', 'j\\w+s']);
Copy

Restricts keyboard input. This is useful in assessment settings, where the equation must be built from a controlled set of toolbar buttons rather than typed freely.

There are three modes:

• 0 - allows all text and key operations (the default);
• 1 - for an equation built from the toolbar: Backspace and Delete remove whole words, the arrow keys step through the equation's structure, Space opens the command list, and a backslash no longer opens it.

Any mode above 0 currently behaves as 1.

EqEditor.LaTeXView.link('input')
  .addToolbar(EqEditor.Toolbar.link('toolbar'))
  .setRestrictMode(1);
Copy

Locks the equation to its structure, or unlocks it.

Locked, the empty slots in the equation as it stands - each empty {} or [], each empty matrix cell, and each box drawn after an operator with nothing to operate on - are the only places that can be edited, and they take only plain characters and single symbols: letters, digits, "." and the like, and commands such as \alpha or \le. Nothing can be typed or deleted anywhere else, and nothing can be added that is structure of its own - no braces, brackets, scripts, or commands that take an argument. A slot stays editable once something is in it.

This is for exercises: the educator writes the structure, and the student fills it in.

var ta = EqEditor.LaTeXView.link('input');
ta.insert('\\frac{}{2}=5', 0);
ta.structural_lock(true);
Copy

A MathView linked to this LaTeXView is locked with it, by the same lock. To lock every equation on a page at once, use structural_lock.

Locking clears the undo history, so the structure cannot be undone away, and locking an equation that is already locked leaves it as it is - what has been typed into its slots stays editable. To change the structure, unlock it, change it, and lock it again.

Undoes the last action. Repeated calls unwind further changes to the input area. This is what the History menu's undo button calls. Under a structure lock the equation as it was locked cannot be undone.

Changes the dimensions of an existing selected matrix

Checks the equation to ensure it contains only the variables and commands permitted by LaTeXView.setRestrictedVariables and LaTeXView.setRestrictedCommands.

Note that every token must be a permitted variable or a permitted command: a number, operator, bracket or space anywhere in the equation also makes this false.

Static constructor.

Returns a new instance of LaTeXView linked to the specified HTML element. The advantage of this over the constructor with 'new' is that it allows you to chain additional requirements together, as shown in the example:

<div id="toolbar"></div>
<div id="input"></div>
<script>
  EqEditor.LaTeXView.link('input', true)
    .addToolbar(new EqEditor.Toolbar('toolbar'));
</script>
Copy

Creates a WYSIWYG MathML view inside the given container element, e.g.

<div id="mathview"></div>
<div id="input"></div>
<script>
  var mv = new EqEditor.MathView('mathview');
  mv.addLaTeXView(new EqEditor.LaTeXView('input'));
</script>
Copy

A MathView needs no LaTeXView: on its own it is a WYSIWYG editor, read with MathView.getLatex and loaded with MathView.setLatex.

Links this view to a LaTeXView that holds its LaTeX, so an edit in either appears at once in the other, and the two share one undo history and one structure lock. The view shows the LaTeXView's equation from its next change; to load one into both, use MathView.setLatex after linking them.

EqEditor.MathView.link('mathview')
  .addLaTeXView(EqEditor.LaTeXView.link('input'));
Copy

Connects a Toolbar to this view, the same way api.LaTeXView.addToolbar does - so the Toolbar's buttons insert into this view whenever it has focus. With a linked LaTeXView sharing the Toolbar, pass activate false to leave the buttons going to the LaTeXView until the view is clicked, as example/index.html does.

var toolbar = EqEditor.Toolbar.link('toolbar');
EqEditor.MathView.link('mathview')
  .addLaTeXView(textarea)
  .addToolbar(toolbar, false);
Copy

Empties the view, and a linked LaTeXView with it, removing the equation and resetting the cursor to the start. Takes no focus - see MathView.setLatex.

Part of the contract api.LaTeXView.addOutput expects. Does nothing: the LaTeXView is handed over by MathView.addLaTeXView.

Formerly called connectTextArea(), which still works as an alias of this method.

Takes this view off the page and lets it go: removes what it added to its element, stops listening to the window and to the linked LaTeXView's pane, and unlinks it from that LaTeXView so the LaTeXView no longer updates it. For a page that builds editors and later removes them - a dialog, a single-page app - where every one ever built would otherwise go on receiving the window's mouse and resize events for the life of the page.

The element it was linked to stays; it is the page's. Calling this twice does nothing. A toolbar that was driving it should be given another target, or destroyed with it.

const view = EqEditor.MathView.link('mathview').addLaTeXView(textarea);
// ... later, when the dialog closes:
view.destroy();
Copy

Opens the Chemistry Structure Editor: on the \chemfig{...} the cursor is in, or on a new structure to insert at the cursor. What the chemistry panel's editor button calls; a double-click on a structure in the view opens it the same way. Needs fxTeX Pro's chemfig package to show it - packages: ['chemfig'] to converter.init.

Opens the picture editor: on the picture the cursor is in, or on a new one to insert at the cursor. What the toolbar's picture button calls; a double-click on a picture in the view opens it the same way. Needs fxTeX Pro's picture package to draw - packages: ['picture'] to converter.init.

Moves keyboard focus into this view.

What has been typed into each slot of a locked equation, in the order the slots appear in the LaTeX - the student's answers - the same as api.LaTeXView.getAnswers. A slot left empty gives "".

Where the cursor is, as a character offset into the LaTeX getLatex() returns.

The same number the linked LaTeXView reports, because both panes count into the same string - so anything following the editor can ask either one. Provided for a view used on its own, with no markup pane to ask instead.

Returns the equation's current LaTeX. This is the value to read when submitting a form, or when handing the equation to a rendering service.

Whether keyboard focus is inside this view.

Inserts LaTeX into the equation at the cursor, wrapping anything selected - the same as api.LaTeXView.insert, and what every toolbar button calls when this view is the toolbar's target.

mathview.insert('\\frac{}{}');      // the cursor goes into the numerator
Copy

Inserts an empty fraction, \frac{}{}, leaving the cursor in the numerator.

Inserts an integral with empty limits, \int_{}^{}, leaving the cursor in the lower one.

Inserts an auto-sized bracket pair, \left({}\right).

Inserts an empty superscript, ^{}, leaving the cursor inside it.

Inserts an empty square root, \sqrt{}.

Whether the equation is locked to its structure - see MathView.structural_lock.

Inserts a matrix from the toolbar's matrix panel - see api.LaTeXView.makeArrayMatrix. Works only in a view linked to a LaTeXView.

Inserts a block of equations from the toolbar's matrix panel - see api.LaTeXView.makeEquationsMatrix. Works only in a view linked to a LaTeXView.

Notifies the Outputs of the linked LaTeXView, if there is one, of a change.

Shows the equation as an inline one or as a display one, the same distinction output.Output.setInline makes for the exported formats.

The visible difference is display="block" on the <math> root: a display equation gets its own centred line, an inline one sits where it is put, on the baseline of whatever text surrounds it. Call it alongside Output.setInline() so what is on screen and what gets exported agree.

Display style is left on either way - full-size fraction numerators, and a large operator's limits above and below rather than beside. That is deliberate and it is about editing rather than presentation: in text style MathML drops an <mfrac>'s numerator and denominator a script level, so a fraction inside a fraction is drawn smaller than the one containing it, and the inner one is exactly what somebody is usually trying to click into.

mathview.setInline(true);
Copy

Replaces the equation wholesale and puts the cursor at the end. Use this to pre-load the view with an existing equation. A linked LaTeXView is given the same equation.

EqEditor.MathView.link('mathview').setLatex('x^2+y^2=r^2');
Copy

Loading an equation is not editing it, so this takes no focus - a view that has focus keeps it, and one that has not is left alone. To put the reader in the view as well, pass true to MathView.link or call focus().

Locks the equation to its structure, or unlocks it - see api.LaTeXView.structural_lock, which this is the same as. Locked, only the slots that are empty now can be edited, and they take only plain characters and single symbols.

A view linked to a LaTeXView shares its lock: locking either one locks both. A view on its own has a lock of its own. To lock every equation on a page at once, use api.structural_lock.

var mv = EqEditor.MathView.link('mathview');
mv.setLatex('\\frac{}{2}=5');
mv.structural_lock(true);
Copy

Re-renders this view from the linked LaTeXView's current LaTeX, and puts this view's cursor where that LaTeXView's is. The LaTeXView calls this after every change.

Static constructor. Returns a new instance of MathView linked to the specified element, allowing chained setup, e.g.

<div id="mathview"></div>
<div id="input"></div>
<script>
  EqEditor.MathView.link('mathview')
    .addLaTeXView(EqEditor.LaTeXView.link('input'));
</script>
Copy

Creates an Output, which presents the equation from an associated LaTeXView in an HTML element on the page, e.g.:

<div id="entry"></div>
<img id="output"/>
<script>
   EqEditor.LaTeXView.link('entry')
       .addOutput(new EqEditor.Output('output'));
</script>
Copy

An img element always shows the rendered equation. Any other element shows the equation written out by the wrapper - see Output.setWrapper.

Connects an export area to this Output. The named element is filled with the equation written out by a wrapper, and refreshed whenever the equation changes - which is how a page offers a "copy this into your forum post" box beside the preview. A textarea or input has its value set; any other element its text.

   EqEditor.Output.link('output')
       .addExportArea('forum-code', '[tex]%1[/tex]')
       .addExportArea('page-code', 'html');
Copy

Links this Output to a LaTeXView, so it displays the formatted equation for that text. You will not usually call this directly - api.LaTeXView.addOutput does it for you.

Downloads the current equation as a file in the Output's current format, from the rendering service (see Output.getEquationURL).

<button onclick="output.setFormat('pdf').download()">Download PDF</button>
Copy

Returns the current equation written out by the wrapper - see Output.setWrapper - ready to paste into a web page, a forum or a document. An empty equation gives an empty string.

An Output with no element of its own is enough to read from:

var out = EqEditor.Output.link().setFormat('mathml').setWrapper('html');
EqEditor.LaTeXView.link('input').addOutput(out);
...
var mathml = out.getCode();
Copy

Returns the URL that renders the current equation in the current format, size, DPI, background and inline setting. The equation is fully URL encoded, so the URL can be used as it is in an img element, a link or a stylesheet.

Returns true if the equation is being rendered inline (vertically aligned with the surrounding text) rather than as a display equation.

Returns the equation's LaTeX in a compact form, with every redundant space removed - see compactLatex. An empty equation, or an Output not yet attached to a LaTeXView, gives an empty string.

This equation's size on the page against a normal one - see Output.setScale.

Returns the supported background colours, as an array of {value, desc} pairs.

Returns the formats Output.setFormat accepts: ['mathml', 'svg', 'png', 'gif', 'pdf'].

Returns the sizes Output.setSize accepts, smallest first: the LaTeX size commands ['tiny', 'scriptsize', 'footnotesize', 'small', 'normalsize', 'large', 'Large', 'LARGE', 'huge', 'Huge'].

The equation as an <img class="fxtex">, sized by Output.imageSize - for a caller that can wait for it before inserting. When no size can be read it is the plain <img>.

The size, in em, to give an <img> of the equation's image (Output.getEquationURL): its natural size - the image server's 16px to the em, so a normal equation is 1em of the text around it - times the equation's scale (see Output.setScale). In em, so it follows the site's .fxtex rule and the text it is in, where the SVG's own pixel size would not.

Fetches the SVG to read its size; the image's own request then comes from the cache.

output.imageSize().then(function (size) {
  if (size) { img.style.width = size.width; img.style.height = size.height; }
});
Copy

Sets the background colour of the rendered equation. Leave it empty for a transparent background, which is usually what you want when the equation sits on a coloured page.

   EqEditor.Output.link('output')
       .setBackground('red');
Copy

Any colour the rendering service reads will do: a CSS colour name ('red', 'lavender') or hex ('#ffe4e1', 'ffe4e1', '#fee'). Output.getSupportedColors lists a few, for a menu.

Sets the resolution of a PNG, in dots per inch, where 96 is the equation's normal size on screen and 288 three times as sharp. It applies to the 'png' format only: SVG and MathML have no resolution, and the rendering service draws GIF and PDF at a fixed one.

The rendering service reads it from a \dpi{N} it is sent ahead of the equation - see Output.getEquationURL. Until this is called none is sent and the service uses its own default.

   EqEditor.Output.link('output')
       .setFormat('png')
       .setDpi(300);
Copy

Sets the colour the rendered equation is drawn in - what a \\color in the equation itself then overrides. Leave it empty for the service's default, black.

   EqEditor.Output.link('output')
       .setForeground('#1c7ed6');
Copy

Sets the format the equation is rendered as:

• mathml - MathML, which carries the mathematics rather than a picture of it;
• svg - a scalable vector image (the default);
• png - a bitmap image, at the resolution set by Output.setDpi;
• gif - a bitmap image;
• pdf - a PDF document.

MathML and SVG include generated spoken text by default, so a screen reader reads the mathematics rather than spelling out the LaTeX. Pass speech false to leave it out, for a smaller result.

   EqEditor.Output.link('output')
       .setFormat('svg', false);
Copy

An img element can only show an svg, png or gif.

Sets the inline mode of the Output. An inline equation is vertically aligned to sit on the baseline of the surrounding text, rather than being rendered as a standalone display equation. It also changes what the 'latex' wrapper writes: $...$ rather than \[...\].

   EqEditor.Output.link('output')
       .setInline(true);
Copy

Sets the URL of the rendering service used to draw the equation. The default is 'https://fxtex.codecogs.com'; you would typically change this to point at your own installation of the rendering service.

<div id="entry"></div>
<img id="output"/>
<script>
   EqEditor.LaTeXView.link('entry')
       .addOutput(EqEditor.Output.link('output')
           .setRenderURL('https://fxtex.example.com')
           .setFormat('png'));
</script>
Copy

Sets this equation's size on the page, against a normal equation: 1 (the default) is the normal size, 1.5 half as big again. Unlike Output.setSize it does not change what the equation is drawn at, only how big it is shown.

Normal is whatever the page makes it - every inserted equation carries class="fxtex", so a site sizes all of them with one rule (.fxtex { font-size: 120% }) - and this scales one equation on top of that. It applies to:

• MathML from the 'html' wrapper, which is put inside <mstyle mathsize="150%">;
• the size Output.imageSize and Output.imageHtml give an image, in em.

It does not change the image URL, so an img the Output is linked to is unaffected, and it does not refresh the Output by itself. Output.scaleOf reads it back from an equation already on the page.

Sets the size the equation is drawn at, as one of the LaTeX size commands - see Output.getSupportedSizes. 'normalsize' is the default.

   EqEditor.Output.link('output')
       .setSize('Large');
Copy

The size goes in front of the equation wherever it is written out: the rendered picture's URL, the MathML (as \Large x^2 would be) and the latex wrapper's \[\Large x^2\].

To scale an equation on a page without changing what it is drawn at, use Output.setScale instead.

Sets how the equation is written out, by Output.getCode and in any element other than an img. Either one of the core wrappers:

• latex - the LaTeX, inside \[...\], or $...$ when the Output is inline (the default);
• url - the URL of the rendered equation - see Output.getEquationURL;
• html - HTML for a web page: an img element showing the rendered equation, or for the 'mathml' format the MathML itself;

or a template of your own, in which these placeholders are replaced:

• %1 - the LaTeX as it is, e.g. a<b & c;
• %2 - the LaTeX HTML encoded, e.g. a<b & c, for an HTML attribute or element;
• %3 - the LaTeX fully URL encoded, e.g. a%3Cb%20%26%20c, for a URL of your own;
• %4 - the URL of the rendered equation, as Output.getEquationURL returns it.

Templates for some common systems:

   EqEditor.Output.link('code')
       .setWrapper('[latex]%1[/latex]');
Copy

Remember to escape a backslash in a JavaScript string: the Doxygen template is written '\\f[%1\\f]'.

Updates the Output to show the equation as it is now, in the LaTeXView it is attached to - including an edit made through a mathview.MathView linked to that LaTeXView - along with every export area added with Output.addExportArea.

You will not usually call this directly: the LaTeXView calls it after every change to the equation. Typing is batched, so the Output catches up a second after the last keystroke rather than on every one.

Converts a LaTeX string straight to presentation MathML, without needing an Output bound to a LaTeXView first - for example in a CKEditor or TinyMCE plugin that stores the source LaTeX and regenerates its markup on the way out. The conversion is fxTeX Pro's, so call it once converter.init has resolved; before that it gives MathML saying so.

await EqEditor.init({ licence: 'fx_pk_...' });
var mathml = EqEditor.Output.latexToMathML('\\frac{a}{b}', true);
Copy

Static constructor. Returns a new Output linked to the given element, the same as new EqEditor.Output(...), in a form that reads well with settings chained onto it:

<div id="entry"></div>
<img id="output"/>
<script>
  EqEditor.LaTeXView.link('entry')
    .addOutput(EqEditor.Output.link('output')
      .setFormat('png')
      .setSize('LARGE'));
</script>
Copy

The scale an inserted equation was given - see Output.setScale - read back from it, for an editor reopening it: an <img> from its width in em against its natural width (so the image must have loaded); MathML from the <mstyle mathsize> around its content.

var out = EqEditor.Output.link().setScale(EqEditor.Output.scaleOf(equationElement));
Copy

Creates an instance of History and renders its buttons into the given element.

Connects the History buttons to the given LaTeXView. You will not usually call this directly - LaTeXView.addHistoryMenu does it for you, and a LaTeXView calls it again whenever it gains focus.

Converts one LaTeX string, with the settings made so far, and returns the markup: a <math> element, or a <span> around one when spoken text is attached as 'hidden' or 'wrapper'. Put it in the page with innerHTML.

LaTeX that cannot be read comes back as MathML holding an <merror>. So does every equation when init() has not finished, or failed, with the reason in place of the maths.

The spoken text of the most recent convert, or "" when speech is off. Read it straight after converting: converters share one engine, so another converter's next convert() replaces it.

Where the caret is in the LaTeX, as a character offset, or -1 for none (the default). A command whose name ends exactly there is left as typed, so \frac is not a fraction until the caret has moved on. For a page that follows someone typing; otherwise leave it at -1.

true sets an inline equation at full size, as a block one is - a fraction's numerator and denominator are not shrunk to fit the line. Off by default.

Marks every part of the output with the position in the LaTeX it came from, and draws each empty argument as a box to type into. The editor's own maths view uses it; a page displaying finished equations leaves it off. Off by default.

true for an equation that sits in a line of text; false (the default) for a block equation set on its own line.

Adds spoken text to each equation for screen readers, and chooses how much: 'terse' (the default) or 'verbose'. Off by default. setSpeechMarkup chooses how the text is attached; getSpeech returns it.

How the spoken text is attached to the markup convert returns, when speech is on:

• 'hidden' (the default) - a visually hidden <span> beside the <math>, which screen readers read in its place.
• 'wrapper' - a <span role="math"> around the <math>, with the text as its aria-label.
• 'label' - an aria-label on the <math> element itself.
• 'none' - nothing attached; read it from getSpeech and use it yourself.