new MathAtom(mode: string, type: string, body: string,Array.<MathAtom>, fontFamilyopt, nullable: string, extrasopt, nullable: Object) → MathAtomprivate
An atom is an object encapsulating an elementary mathematical unit, independent of its graphical representation.
It keeps track of the content, while the dimensions, position and style
are tracked by Span objects which are created by the
bodystring | Array.<MathAtom>
fontFamilystring optional nullable = "main"
extrasObject optional nullable = null
A set of additional properties to append to the atom
Type can be one of:
mord: ordinary symbol, e.g.
textord: ordinary characters used in text mode
mop: operators, including special functions,
mbin: binary operator:
mrel: relational operator:
mopen: opening fence:
mclose: closing fence:
minner: special layout cases, overlap,
In addition to these basic types, which correspond to the TeX atom types, some atoms represent more complex compounds, including:
spacing: blank space between atoms
mathstyle: to change the math style used:
text. The layout rules are different for each, the latter being more compact and intended to be incorporated with surrounding non-math text.
root: a group, which has no parent (only one per formula)
group: a simple group of atoms, for example from a
font: set the font used. Used by
sizing: set the size of the font used
color: set the foreground color
rule: draw a line, for the
line: used by
box: a border drawn around an expression and change its background color
overlap: display a symbol over another
overunder: displays an annotation above or below a symbol
array: a group, which has children arranged in rows. Used by environments such as
genfrac: a generalized fraction: a numerator and denominator, separated by an optional line, and surrounded by optional fences
surd: a surd, aka root
leftright: used by the
delim: some delimiter
sizeddelim: a delimiter that can grow
The following types are used by the editor:
commandindicate a command being entered. The text is displayed in blue in the editor.
error: indicate a command that is unknown, for example
\xyzy. The text is displayed with a wavy red underline in the editor.
placeholder: indicate a temporary item. Placeholders are displayed as a dashed square in the editor.
first: a special, empty, atom put as the first atom in math lists in order to be able to position the caret before the first element. Aside from the caret, they display nothing.
bodystring | Array.<MathAtom>
if true, this atom does not let its
children be selected. Used by the
\enclose annotations, for example.
if true, when the caret reaches the first position in this element's body, it automatically moves to the outside of the element. Conversely, when the caret reaches the position right after this element, it automatically moves to the last position inside this element.
toSpeakableText(atomsopt: Array.<MathAtom>, optionsopt: Object.<string, any>)static
The atoms to represent as speakable text.
this is used.
optionsObject.<string, any> optional
Add an ID attribute to both the span and this atom so that the atom can be retrieved from the span later on (e.g. when the span is clicked on)
Return a representation of this, but decomposed in an array of Spans
Font variant, size, color, etc...
phantomBaseArray.<Span> optional = null
If not null, the spans to use to calculate the placement of the supsub
GENFRAC -- Generalized fraction
Decompose fractions, binomials, and in general anything made of two expressions on top of each other, optionally separated by a bar, and optionally surrounded by fences (parentheses, brackets, etc...)
Depending on the type of fraction the mathstyle is either display math or inline math (which is indicated by 'textstyle'). This value can also be set to 'auto', which indicates it should use the current mathstyle
Note that we can encounter malformed \left...\right, for example a \left without a matching \right or vice versa. In that case, the leftDelim (resp. rightDelim) will be undefined. We still need to handle those cases.
\overline and \underline
filter() → Array.<MathAtom>
Iterate over all the child atoms of this atom, this included, and return an array of all the atoms for which the predicate callback is true.