Class: ParseError  - X-Ref

This is the ParseError class, which is the main error thrown by Temml
functions when something has gone wrong. This is used to distinguish internal
errors from errors in the expression that the user provided.

If possible, a caller should provide a Token or ParseNode with information
about where in the source string the problem occurred.

Class: Settings  - X-Ref

The main Settings object

Class: DocumentFragment  - X-Ref

This node represents a document fragment, which contains elements, but when
placed into the DOM doesn't have any representation itself. It only contains
children and doesn't have any DOM node properties.

Class: Span  - X-Ref

This node represents a span node, with a className, a list of children, and
an inline style.

Class: AnchorNode  - X-Ref

Class: Img  - X-Ref

Class: MathNode  - X-Ref

This node represents a general purpose MathML node of any type,
for example, `"mo"` or `"mspace"`, corresponding to `<mo>` and
`<mspace>` tags).

Class: TextNode  - X-Ref

This node represents a piece of text.

Class: SourceLocation  - X-Ref

Lexing or parsing positional information for error reporting.
This object is immutable.

Class: Token  - X-Ref

The resulting token returned from `lex`.

It consists of the token text plus some position information.
The position information is essentially a range in an input string,
but instead of referencing the bare input string, we refer to the lexer.
That way it is possible to attach extra metadata to the input string,
like for example a file name or similar.

The position information is optional, so it is OK to construct synthetic
tokens if appropriate. Not providing available position information may
lead to degraded error reporting, though.

Class: Lexer  - X-Ref

Class: Namespace  - X-Ref

A `Namespace` refers to a space of nameable things like macros or lengths,
which can be `set` either globally or local to a nested group, using an
undo stack similar to how TeX implements this functionality.
Performance-wise, `get` and local `set` take constant time, while global
`set` takes time proportional to the depth of group nesting.

Class: MacroExpander  - X-Ref

Class: Parser  - X-Ref

This file contains the parser used to parse out a TeX expression from the
input. Since TeX isn't context-free, standard parsers don't work particularly
well.

The strategy of this parser is as such:

The main functions (the `.parse...` ones) take a position in the current
parse string to parse tokens from. The lexer (found in Lexer.js, stored at
this.gullet.lexer) also supports pulling out tokens at arbitrary places. When
individual tokens are needed at a position, the lexer is called to pull out a
token, which is then used.

The parser has a property called "mode" indicating the mode that
the parser is currently in. Currently it has to be one of "math" or
"text", which denotes whether the current environment is a math-y
one or a text-y one (e.g. inside \text). Currently, this serves to
limit the functions which can be used in text mode.

The main functions then return an object which contains the useful data that
was parsed at its given point, and a new position at the end of the parsed
data. The main functions can call each other and continue the parsing by
using the returned position as a new starting point.

There are also extra `.handle...` functions, which pull out some reused
functionality into self-contained functions.

The functions return ParseNodes.

Class: Style  - X-Ref

This is the main Style class. It contains the current style.level, color, and font.

Style objects should not be modified. To create a new Style with
different properties, call a `.with*` method.