spec.txt

# CMSM

> 🪦 **Archived**: this document is not maintained.
> This document was made jointly with `micromark`,
> which was later also turned into `markdown-rs`.
> At present,
> I don’t have the bandwidth to maintain 2 reference parsers
> *and* a spec.

***

> Common markup state machine.

Together, the parsing rules described below define what is referred to as a
Common Markup parser.

> This document is currently in progress.
> It is developed jointly with a reference parser:
> [`micromark`](https://github.com/micromark/micromark).
> Contributions are welcome.
>
> Some parts that are still in progress:
>
> *   Adapters
> *   Define the regular constructs
> *   Adapter for rich text to check whether emphasis, strong, resource, or
>     reference sequences make up syntax or text
> *   Tokenizing the input stream in reverse (GFM allows `asd@asd.com`, so it
>     seems we need to somehow allow to match the `@` and parse backwards)
> *   Add an appendix of extensions

## Table of contents

## Background

The common markup parser parses a markup language that is commonly known as
*Markdown*.

The first definition of this format gave several examples of how it worked,
showing input Markdown and output HTML, and came with a reference implementation
(known as Markdown.pl).
When new implementations followed, they mostly followed the first definition,
but deviated from the first implementation, thus making the format a family of
formats.

Some years later, an attempt was made to standardize the differences between
implementations, by specifying how several edge cases should be handled, through
more input and output examples.
This attempt is known as CommonMark, and many implementations now follow it.

This document defines a more formal format, based on CommonMark, by documenting
how to parse it, instead of documenting input and output examples.
This format is:

*   **strict**, as it defines a state machine, which leaves significantly less
    room for interpretation
*   **agnostic** of HTML, as it does not show examples of output, which lets
    the format be used in new ways
*   **streaming**, because coupling with HTML is what requires a whole stream to
    be buffered as references can resolve to later definitions
*   **complete**, as it defines different types of tokens and how they are
    grouped, which allows the format to be represented as a concrete syntax tree
*   **extensible**, because the format is often used in combination with new
    and custom constructs

The origin story of Markdown is similar to that of HTML, which at a time was
also a family of formats.
Through incredible efforts of the WHATWG, a Living Standard was created on how
to parse the format, by defining a state machine.

## Overview

The common markup parser receives input, typically coming over the network or
from the local file system.
This input is represented as characters in the input stream.
Depending on a character, certain effects occur, such as that a new token is
created, one state is switched to another, or something is labelled.
Each line is made up of tokens, such as whitespace, markers, sequences, and
content, and labels, that are both enqueued.
At a certain point, it is known what to do with the queue, whether to discard it
or to use it, in which case it is adapted.

The parser parses in three stages: flow, content, and text, respectively coming
with their own state machines ([flow state machine][], [content state machine][],
[text state machine][]), and their own adapters.

## Infra

> *This section defines the fundamental concepts upon which this document is
> built.*

A variable is declared in the shared state with `let`, cleared with `unset`, or
changed with `set`, `increment`, `decrement`, `append` or `prepend`.

## Characters

A character is a Unicode code point and is represented as a four to six digit
hexadecimal number, prefixed with `U+` (**\[UNICODE]**).

### Character groups

An [ASCII digit](#) is a character in the inclusive range c:0 to c:9.

An [ASCII upper hex digit](#) a character in the inclusive range c:A to c:F.

An [ASCII lower hex digit](#) a character in the inclusive range c:a to c:f.

An [ASCII hex digit](#) is an [ASCII digit][], [ASCII upper hex digit][], or an
[ASCII lower hex digit][]

An [ASCII upper alpha](#) is a character in the inclusive range c:A to c:Z.

An [ASCII lower alpha](#) is a character in the inclusive range c:a to c:z.

An [ASCII alpha](#) is an [ASCII upper alpha][] or [ASCII lower alpha][].

An [ASCII alphanumeric](#) is an [ASCII digit][] or [ASCII alpha][].

An [ASCII punctuation](#) is a character in the inclusive ranges c:! to c:/, c::
to c:@, c:[ to c:`, or c:{ to c:~.

An [ASCII control](#) is a character in the inclusive range c:NUL to c:US, or
c:DEL.

A [Unicode whitespace](#) is a character in the Unicode `Zs` (Separator, Space)
category, or c:HT, c:LF, c:FF, or c:CR (**\[UNICODE]**).

A [Unicode punctuation](#) is a character in the Unicode `Pc` (Punctuation,
Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
(Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
(Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an [ASCII
punctuation][] (**\[UNICODE]**).

An [atext](#) is an [ASCII alphanumeric][], or a character in the inclusive
ranges c:# to c:', c:*, c:+, c:-, c:/, c:=, c:?, c:^ to c:`, or c:{ to c:~
(**\[RFC5322]**).

To [ASCII-lowercase](#) a character, is to increase it by `0x20`, if it an
[ASCII upper alpha][].

To [digitize](#) a character, is to decrease it by `0x30`, `0x37`, or `0x57`,
if it is an [ASCII digit][], [ASCII upper hex digit][], or
[ASCII lower hex digit][], respectively.

### Conceptual characters

A [c:VS](#) character is a conceptual character representing an expanded column
size of a c:HT.

An [c:EOL](#) character is a conceptual character representing a break between
two lines.

An [c:EOF](#) character is a conceptual character representing the end of the
input.

c:VS, c:EOL, and c:EOF are not real characters, but rather represent a character
increase the size of a character, a break between characters, or the lack of any
further characters.

### Tabs

Tabs (c:HT) are typically not expanded into spaces, but do behave as if they
were replaced by spaces with a tab stop of 4 characters.
These character increments are represented by [c:VS] characters.

For the following markup (where `␉` represent a tab):

```markdown
>␉␉a
```

We have the characters: c:>, c:HT, c:VS, c:VS, c:HT, c:VS, c:VS, c:VS, and c:a.

When transforming to an output format, tab characters that are not part of
syntax should be present in the output format.
When the tab itself (and zero or more c:VS characters) are part of syntax, but
some c:VS characters are not, the remaining c:VS characters should be considered
a prefix of the content.

## Input stream

The [input stream](#) consists of the characters pushed into it.

The [input character](#) is the first character in the [input stream][] that has
not yet been consumed.
Initially, the input character is the first character in the input.
When the last character in a line is consumed, the input character is an
[c:EOL][].
Finally, when all character are consumed, the input character is an [c:EOF][].

Any occurrences of c:HT in the [input stream][] is represented by that
character and 0-3 [c:VS][] characters.

### Preprocessing the input stream

The [input stream][] consists of the characters pushed into it as the input is
decoded.

The input, when decoded, is preprocessed and pushed into the input stream as
described in the following algorithm:

*   Let `tabSize` be `4`
*   Let `line` be `1`
*   Let `column` be `1`
*   Let `offset` be `0`
*   *Check*:

    If `offset` is equal to the length of the document, push an c:EOF into the
    [input stream][] representing the lack of any further characters, and return

    Otherwise, if the current character is:

    *   ↪ **c:NUL**

        Increment `offset` by `1`, increment `column` by `1`, push a c:� into
        the [input stream][], and go to the step labelled *check*
    *   ↪ **c:HT**

        Set `count` to the result of calculating `(tabSize - 1) - (column %
        tabSize)`.
        Increment `offset` by `1`, increment `column` by `1`, and push the
        character into the [input stream][].

        Perform the following steps `count` times: increment `column` by `1` and
        push a c:VS into the [input stream][] representing the size increase.

        Finally, go to the step labelled *check*
    *   ↪ **c:LF**

        Increment `offset` by `1`, increment `line` by `1`, and set `column` to
        `1`, push an c:EOL into the [input stream][] representing the character,
        and go to the step labelled *check*
    *   ↪ **c:CR**

        Increment `offset` by `1`, increment `line` by `1`, set `column` to `1`,
        and go to the step labelled *carriage return check*
    *   ↪ **Anything else**

        Increment `offset` by `1`, increment `column` by `1`, push the character
        into the [input stream][], and go to the step labelled *check*
*   *Carriage return check*: if the current character is:

    *   ↪ **c:LF**

        Increment `offset` by `1` and push an c:EOL into the [input stream][]
        representing the previous and current characters
    *   ↪ **Anything else**

        Push an c:EOL into the [input stream][] representing the previous
        character and perform the step labelled *check* on the current character

## Parsing

The states of state machines have certain effects, such as that they create
items in the [queue][] (tokens and labels).
The queue is used by tree adapters, in case a valid construct is found.
After using the queue, or when in a bogus construct is found, the queue is
discarded.

The [shared space][] is accessed and mutated by both the tree adapter and the
states of the state machine.

[Construct][]s are registered by hooking a case (one or more characters or
character groups) into certain states.
Upon registration, they define the states used to parse a construct, and the
adapter used to handle the construct.

### Tokenization

Implementations must act as if they use several state machines to tokenize
common markup.
The [flow state machine][] is used to tokenize the line constructs that make up
the structure of the document.
The [content state machine][] is used to tokenize the inline constructs part of
content blocks.
The [text state machine][] is used to tokenize the inline constructs part of
rich or plain text.

Most states [consume][] the [input character][], and either remain in the state
to consume the next character, [reconsume][] the input character in a different
state, or [switch][] to a different state to consume the next character.
States [enqueue][] tokens and labels.

### State

The [shared space](#) is a map of key/value pairs.

The [queue](#) is a list of tokens and labels that are enqueued.
The [current token](#) is the last token in the [queue][].

### Constructs

Markup is parsed per [construct](#).
Some constructs are considered regular (those from CommonMark, such as ATX
headings) and other constructs are extensions (such as YAML frontmatter or MDX).

> ❗️ Define constructs.

### Effects

#### Switch

To [switch](#) to a state is to wait for the next character in the given state.

#### Consume

To [consume](#) the [input character][] affects the [current token][].
Due to the nature of the state machine, it is not possible to consume if there
is no current token.

#### Reconsume

To [reconsume](#) is to [switch][] to the given state, and [consume][] the
[input character][] there.

#### Enqueue

To [enqueue](#) a label is to mark a point between two tokens with a semantic
name, at which point there is no [current token][].

To enqueue a token is to add a new token of the given type to the [queue][],
making it the new [current token][].

#### Ensure

To ensure a token is to enqueue that token if the [current token][] is not of
the given type, and otherwise do nothing.

## Flow state machine

The [flow state machine](#) is used to tokenize the line constructs that make up
the structure of the document (such as headings or thematic breaks) and must
start in the s:flow-prefix-start.

### Flow prefix start state

*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:flow-start

### Flow start state

> **Hookable**, there are no regular hooks

*   ↪ **Anything else**

    Reconsume in the s:flow-initial

### Flow prefix initial state

*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:flow-initial

### Flow initial state

> ❗️ Todo: Indented code v.s. content

> **Hookable**, the regular hooks are:
>
> *   [x] **[c:EOL][]**: s:blank-line
> *   [x] **c:#**: s:atx-heading-start
> *   [x] **c:***: s:thematic-break-asterisk-start
> *   [ ] **c:***: <!-- s:list-item-asterisk-start -->
> *   [ ] **c:+**: <!-- s:list-item-plus-start -->
> *   [x] **c:-**: s:setext-heading-underline-dash-start
> *   [x] **c:-**: s:thematic-break-dash-start
> *   [ ] **c:-**: <!-- s:list-item-dash-start -->
> *   [x] **c:<**: s:flow-html-start
> *   [x] **c:=**: s:setext-heading-underline-equals-to-start
> *   [ ] **c:>**: <!-- s:blockquote-start -->
> *   [x] **c:_**: s:thematic-break-underscore-start
> *   [x] **c:`**: s:fenced-code-grave-accent-start
> *   [x] **c:~**: s:fenced-code-tilde-start
> *   [ ] **[ASCII digit][]**: <!-- s:list-item-digit-start -->

> ❗️ Todo, continuation:
> *   [x] s:flow-html-continuation
> *   [x] s:fenced-code-grave-accent-continuation
> *   [x] s:fenced-code-tilde-continuation

*   ↪ **[c:EOF][]**

    Enqueue an t:end-of-file
*   ↪ **Anything else**

    Reconsume in the s:flow-content

### Blank line state

*   ↪ **[c:EOL][]**

    Enqueue a l:blank-line-end, enqueue an t:end-of-line, and consume
*   ↪ **Anything else**

    Enqueue a l:nok

### ATX heading start state

*   ↪ **c:#**

    Let `sizeFence` be `1`, enqueue an l:atx-heading-start, enqueue an
    l:atx-heading-fence-start, enqueue a t:sequence, consume, and switch to the
    s:atx-heading-fence-open-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### ATX heading fence open inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Unset `sizeFence`, enqueue an l:atx-heading-fence-end and reconsume in the
    s:atx-heading-inside
*   ↪ **c:#**

    If `sizeFence` is not `6`, increment `sizeScheme` by `1` and consume

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Unset `sizeFence` and enqueue a l:nok

### ATX heading inside state

*   ↪ **[c:EOF][]**

    Enqueue an l:atx-heading-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an l:atx-heading-end, enqueue an t:end-of-line, consume, and switch
    to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:#**

    Ensure a t:sequence and consume
*   ↪ **Anything else**

    Ensure a t:content and consume

### Thematic break asterisk start state

*   ↪ **c:***

    Let `sizeTotalSequence` be `1`, enqueue a l:thematic-break-start, enqueue a
    t:sequence, consume, and switch to the s:thematic-break-asterisk-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Thematic break asterisk inside state

*   ↪ **[c:EOF][]**

    If `sizeTotalSequence` is greater than or equal to `3`, unset
    `sizeTotalSequence`, enqueue a l:thematic-break-end, and enqueue an
    t:end-of-file

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:EOL][]**

    If `sizeTotalSequence` is greater than or equal to `3`, unset
    `sizeTotalSequence`, enqueue a l:thematic-break-end, enqueue an
    t:end-of-line, consume, and switch to the s:flow-prefix-initial

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:***

    Increment `sizeTotalSequence` by `1`, ensure a t:sequence, and consume
*   ↪ **Anything else**

    Unset `sizeTotalSequence` and enqueue a l:nok

### Setext heading underline dash start state

> ❗️ Todo: exit if not preceded by content

*   ↪ **c:-**

    Enqueue a l:setext-heading-underline-start, enqueue a t:sequence, consume,
    and switch to the s:setext-heading-underline-dash-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Setext heading underline dash inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:setext-heading-underline-dash-after
*   ↪ **c:-**

    Consume
*   ↪ **Anything else**

    Enqueue a l:nok

### Setext heading underline dash after state

> ❗️ Todo: Close content if ok, create a new content if nok

*   ↪ **[c:EOF][]**

    Enqueue a l:setext-heading-underline-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue a l:setext-heading-underline-end, enqueue an t:end-of-line, consume,
    and switch to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Enqueue a l:nok

### Thematic break dash start state

*   ↪ **c:-**

    Let `sizeTotalSequence` be `1`, enqueue a l:thematic-break-start, enqueue a
    t:sequence, consume, and switch to the s:thematic-break-dash-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Thematic break dash inside state

*   ↪ **[c:EOF][]**

    If `sizeTotalSequence` is greater than or equal to `3`, unset
    `sizeTotalSequence`, enqueue a l:thematic-break-end, and enqueue an
    t:end-of-file

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:EOL][]**

    If `sizeTotalSequence` is greater than or equal to `3`, unset
    `sizeTotalSequence`, enqueue a l:thematic-break-end, enqueue an
    t:end-of-line, consume, and switch to the s:flow-prefix-initial

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:-**

    Increment `sizeTotalSequence` by `1`, ensure a t:sequence, and consume
*   ↪ **Anything else**

    Unset `sizeTotalSequence` and enqueue a l:nok

### Flow HTML start state

*   ↪ **c:<**

    Let `kind` be `0`, let `endTag` be `null`, let `tagName` be the empty
    string, enqueue a t:content, consume, and switch to the s:flow-html-tag-open
*   ↪ **Anything else**

    Enqueue a l:nok

### Flow HTML tag open state

*   ↪ **c:!**

    Consume and switch to the s:flow-html-markup-declaration-open
*   ↪ **c:/**

    Set `endTag` to `true`, consume, and switch to the s:flow-html-end-tag-open
*   ↪ **c:?**

    Set `kind` to `3`, unset `endTag`, consume, and switch to the
    s:flow-html-continuation-declaration-before
*   ↪ **[ASCII alpha][]**

    Append the [ASCII-lowercase][]d character to `tagName`, consume, and switch
    to the s:flow-html-tag-name
*   ↪ **Anything else**

    Unset `kind`, `endTag`, and `tagName`, and enqueue a l:nok

### Flow HTML markup declaration open state

*   ↪ **`--` (two c:- characters)**

    Set `kind` to `2`, unset `endTag`, consume, and switch to the
    s:flow-html-continuation-declaration-before
*   ↪ **`[CDATA[` (the five upper letters “CDATA” with a c:[ before and
    after)**

    Set `kind` to `5`, unset `endTag`, consume, and switch to the
    s:flow-html-continuation
*   ↪ **[ASCII alpha][]**

    Set `kind` to `4`, unset `endTag`, consume, and switch to the
    s:flow-html-continuation
*   ↪ **Anything else**

    Unset `kind`, `endTag`, and `tagName`, and enqueue a l:nok

### Flow HTML end tag open state

*   ↪ **[ASCII alpha][]**

    Append the [ASCII-lowercase][]d character to `tagName`, consume, and switch
    to the s:flow-html-tag-name
*   ↪ **Anything else**

    Unset `kind`, `endTag`, and `tagName`, and enqueue a l:nok

### Flow HTML tag name state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**

    If `tagName` is a [raw tag][] and `endTag` is not `true`, set `kind` to `1`,
    unset `tagName`, unset `endTag`, and reconsume in the
    s:flow-html-continuation

    Otherwise, if `tagName` is a [basic tag][], set `kind` to `6`, unset
    `tagName`, unset `endTag`, and reconsume in the s:flow-html-continuation

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    If `tagName` is a [raw tag][] and `endTag` is not `true`, set `kind` to `1`,
    unset `tagName`, unset `endTag`, and switch to the s:flow-html-continuation

    > ❗️ Todo: ignore this check if interrupting content.

    Otherwise, if `tagName` is not a [raw tag][], unset `tagName`, consume, and
    switch to the s:flow-html-complete-attribute-name-before

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:-**

    Append the character to `tagName` and consume
*   ↪ **c:/**

    If `tagName` is a [basic tag][], unset `tagName`, consume, and switch to the
    s:flow-html-basic-self-closing

    > ❗️ Todo: ignore this check if interrupting content.

    Otherwise, if `tagName` is not a [raw tag][] and `endTag` is not `true`,
    unset `tagName`, consume, and switch to the
    s:flow-html-complete-self-closing

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:>**

    If `tagName` is a [raw tag][] and `endTag` is not `true`, set `kind` to `1`,
    unset `tagName`, unset `endTag`, consume, and switch to the
    s:flow-html-continuation

    Otherwise, if `tagName` is a [basic tag][], set `kind` to `6`, unset
    `tagName`, unset `endTag`, and reconsume in the s:flow-html-continuation

    > ❗️ Todo: ignore this check if interrupting content.

    Otherwise, if `tagName` is not a [raw tag][], unset `tagName`, consume, and
    switch to the s:flow-html-complete-tag-after

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[ASCII alphanumeric][]**

    Append the [ASCII-lowercase][]d character to `tagName` and consume
*   ↪ **Anything else**

    Unset `kind`, `endTag`, and `tagName`, and enqueue a l:nok

### Flow HTML basic self closing state

*   ↪ **c:>**

    Set `kind` to `6`, unset `endTag`, consume, and switch to the
    s:flow-html-continuation
*   ↪ **Anything else**

    Unset `kind` and `endTag` and enqueue a l:nok

### Flow HTML complete attribute name before state

*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:/**

    If `endTag` is not `true`, consume and switch to the
    s:flow-html-complete-self-closing

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c::**\
    ↪ **c:_**\
    ↪ **[ASCII alpha][]**

    If `endTag` is not `true`, consume and switch to the
    s:flow-html-complete-attribute-name

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:>**

    Consume and switch to the s:flow-html-complete-tag-after
*   ↪ **Anything else**

    Unset `kind` and `endTag` and enqueue a l:nok

### Flow HTML complete attribute name state

*   ↪ **c:-**\
    ↪ **c:.**\
    ↪ **c::**\
    ↪ **c:_**\
    ↪ **[ASCII alphanumeric][]**

    Consume
*   ↪ **Anything else**

    Reconsume in the s:flow-html-complete-attribute-name-after

### Flow HTML complete attribute name after state

*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:/**

    If `endTag` is not `true`, consume and switch to the
    s:flow-html-complete-self-closing

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:=**

    Consume and switch to the s:flow-html-complete-attribute-value-before
*   ↪ **c:>**

    Consume and switch to the s:flow-html-complete-tag-after
*   ↪ **Anything else**

    Unset `kind` and `endTag` and enqueue a l:nok

### Flow HTML complete attribute value before state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **c:<**\
    ↪ **c:=**\
    ↪ **c:>**\
    ↪ **c:`**

    Unset `kind` and `endTag` and enqueue a l:nok
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:"**

    Consume and switch to the s:flow-html-complete-attribute-value-double-quoted
*   ↪ **c:'**

    Consume and switch to the s:flow-html-complete-attribute-value-single-quoted
*   ↪ **Anything else**

    Consume and switch to the s:flow-html-complete-attribute-value-unquoted

### Flow HTML complete attribute value double quoted state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**

    Unset `kind` and `endTag` and enqueue a l:nok
*   ↪ **c:"**

    Consume and switch to the s:flow-html-complete-attribute-name-before
*   ↪ **Anything else**

    Consume

### Flow HTML complete attribute value single quoted state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**

    Unset `kind` and `endTag` and enqueue a l:nok
*   ↪ **c:'**

    Consume and switch to the s:flow-html-complete-attribute-name-before
*   ↪ **Anything else**

    Consume

### Flow HTML complete attribute value unquoted state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**\
    ↪ **c:"**\
    ↪ **c:'**\
    ↪ **c:<**\
    ↪ **c:=**\
    ↪ **c:>**\
    ↪ **c:`**

    Reconsume in the s:flow-html-complete-attribute-name-after
*   ↪ **Anything else**

    Consume

### Flow HTML complete self closing state

*   ↪ **c:>**

    Consume and switch to the s:flow-html-complete-tag-after
*   ↪ **Anything else**

    Unset `kind` and `endTag` and enqueue a l:nok

### Flow HTML complete tag after state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Set `kind` to `7`, unset `endTag`, and reconsume in the
    s:flow-html-continuation
*   ↪ **Anything else**

    Unset `kind` and `endTag` and enqueue a l:nok

### Flow HTML continuation state

*   ↪ **[c:EOF][]**

    Unset `kind`, enqueue an l:html-end, and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line, consume, and switch to the s:flow-prefix-initial
*   ↪ **c:-**

    If `kind` is `7`, consume and switch to the
    s:flow-html-continuation-comment-inside

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:<**

    If `kind` is `1`, consume and switch to the
    s:flow-html-continuation-raw-tag-open

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:>**

    If `kind` is `4`, consume and switch to the s:flow-html-continuation-close

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:?**

    If `kind` is `3`, consume and switch to the
    s:flow-html-continuation-declaration-before

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:]**

    If `kind` is `5`, consume and switch to the
    s:flow-html-continuation-character-data-inside.

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Consume

### Flow HTML continuation comment inside state

*   ↪ **c:-**

    Consume and switch to the s:flow-html-continuation-declaration-before
*   ↪ **Anything else**

    Reconsume in the s:flow-html-continuation

### Flow HTML continuation raw tag open state

*   ↪ **c:/**

    Let `tagName` be the empty string, consume, and switch to the
    s:flow-html-continuation-raw-end-tag
*   ↪ **Anything else**

    Reconsume in the s:flow-html-continuation

### Flow HTML continuation raw end tag state

> **Note**: This state can be optimized by either imposing a maximum size (the
> size of the longest possible raw tag name) or by using a trie of the possible
> raw tag names.

*   ↪ **[ASCII alphanumeric][]**

    Append the [ASCII-lowercase][]d character to `tagName` and consume
*   ↪ **c:>**

    If `tagName` is a [raw tag][], unset `tagName, consume, and switch to the
    s:flow-html-continuation-close

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Unset `tagName and reconsume in the s:flow-html-continuation

### Flow HTML continuation character data inside state

*   ↪ **c:]**

    Consume and switch to the s:flow-html-continuation-declaration-before
*   ↪ **Anything else**

    Reconsume in the s:flow-html-continuation

### Flow HTML continuation declaration before state

*   ↪ **c:>**

    Consume and switch to the s:flow-html-continuation-close
*   ↪ **Anything else**

    Reconsume in the s:flow-html-continuation

### Flow HTML continuation close state

*   ↪ **[c:EOF][]**

    Unset `kind`, enqueue an l:html-end, and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Unset `kind`, enqueue an l:html-end, and enqueue an t:end-of-line, consume,
    and switch to the s:flow-prefix-initial
*   ↪ **Anything else**

    Consume

### Setext heading underline equals to start state

> ❗️ Todo: exit if not preceded by content

*   ↪ **c:=**

    Enqueue a l:setext-heading-underline-start, enqueue a t:sequence, consume,
    and switch to the s:setext-heading-underline-equals-to-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Setext heading underline equals to inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:setext-heading-underline-equals-to-after
*   ↪ **c:=**

    Consume
*   ↪ **Anything else**

    Enqueue a l:nok

### Setext heading underline equals to after state

> ❗️ Todo: Close content if ok, create a new content if nok

*   ↪ **[c:EOF][]**

    Enqueue a l:setext-heading-underline-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue a l:setext-heading-underline-end, enqueue an t:end-of-line, consume,
    and switch to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Enqueue a l:nok

### Thematic break underscore start state

*   ↪ **c:_**

    Let `sizeTotalSequence` be `1`, enqueue a l:thematic-break-start, enqueue a
    t:sequence, consume, and switch to the s:thematic-break-underscore-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Thematic break underscore inside state

*   ↪ **[c:EOF][]**

    If `sizeTotalSequence` is greater than or equal to `3`, unset
    `sizeTotalSequence`, enqueue a l:thematic-break-end, and enqueue an
    t:end-of-file

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:EOL][]**

    If `sizeTotalSequence` is greater than or equal to `3`, unset
    `sizeTotalSequence`, enqueue a l:thematic-break-end, enqueue an
    t:end-of-line, consume, and switch to the s:flow-prefix-initial

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:_**

    Increment `sizeTotalSequence` by `1`, ensure a t:sequence, and consume
*   ↪ **Anything else**

    Unset `sizeTotalSequence` and enqueue a l:nok

### Fenced code grave accent start state

*   ↪ **c:`**

    Let `sizeOpen` be `1`, enqueue a l:fenced-code-start, enqueue a
    l:fenced-code-fence-start, enqueue a l:fenced-code-fence-sequence-start,
    enqueue a t:sequence, consume, and switch to the
    s:fenced-code-grave-accent-open-fence-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Fenced code grave accent open fence inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    If `sizeOpen` is greater than or equal to `3`, enqueue a
    l:fenced-code-fence-sequence-end, and reconsume in the
    s:fenced-code-grave-accent-open-fence-after

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:`**

    Increment `sizeOpen` by `1` and consume
*   ↪ **Anything else**

    Unset `sizeOpen` and enqueue a l:nok

### Fenced code grave accent open fence after state

*   ↪ **[c:EOF][]**

    Enqueue a l:fenced-code-fence-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue a l:fenced-code-fence-end, enqueue an t:end-of-line, consume, and
    switch to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:`**

    Unset `sizeOpen` and enqueue a l:nok
*   ↪ **Anything else**

    Ensure a t:content and consume

### Fenced code grave accent continuation state

*   ↪ **c:`**

    Let `sizeClose` be `1`, enqueue a l:fenced-code-fence-sequence-start,
    enqueue a t:sequence, consume, and switch to the
    s:fenced-code-grave-accent-close-fence-inside
*   ↪ **Anything else**

    Reconsume in the s:fenced-code-grave-accent-continuation-inside

### Fenced code grave accent close fence inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    If `sizeClose` is greater than or equal to `sizeOpen`, enqueue a
    l:fenced-code-fence-sequence-end and reconsume in the
    s:fenced-code-grave-accent-close-fence-after

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:`**

    Increment `sizeClose` by `1` and consume
*   ↪ **Anything else**

    Unset `sizeClose` and reconsume in the
    s:fenced-code-grave-accent-continuation-inside

### Fenced code grave accent close fence after state

*   ↪ **[c:EOF][]**

    Unset `sizeOpen`, unset `sizeClose`, enqueue a l:fenced-code-fence-end,
    enqueue a l:fenced-code-end, and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Unset `sizeOpen`, unset `sizeClose`, enqueue a l:fenced-code-fence-end,
    enqueue a l:fenced-code-end, enqueue an t:end-of-line, consume, and switch
    to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:fenced-code-grave-accent-continuation-inside

### Fenced code grave accent continuation inside state

*   ↪ **[c:EOF][]**

    Unset `sizeOpen`, unset `sizeClose`, enqueue a l:fenced-code-fence-end,
    enqueue a l:fenced-code-end, and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line, consume, and switch to the s:flow-prefix-initial
*   ↪ **Anything else**

    Ensure a t:content and consume

### Fenced code tilde start state

*   ↪ **c:~**

    Let `sizeOpen` be `1`, enqueue a l:fenced-code-start, enqueue a
    l:fenced-code-fence-start, enqueue a l:fenced-code-fence-sequence-start,
    enqueue a t:sequence, consume, and switch to the
    s:fenced-code-tilde-open-fence-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Fenced code tilde open fence inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    If `sizeOpen` is greater than or equal to `3`, enqueue a
    l:fenced-code-fence-sequence-end, and reconsume in the
    s:fenced-code-tilde-open-fence-after

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:~**

    Increment `sizeOpen` by `1` and consume
*   ↪ **Anything else**

    Unset `sizeOpen` and enqueue a l:nok

### Fenced code tilde open fence after state

*   ↪ **[c:EOF][]**

    Enqueue a l:fenced-code-fence-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue a l:fenced-code-fence-end, enqueue an t:end-of-line, consume, and
    switch to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Ensure a t:content and consume

### Fenced code tilde continuation state

*   ↪ **c:~**

    Let `sizeClose` be `1`, enqueue a l:fenced-code-fence-sequence-start,
    enqueue a t:sequence, consume, and switch to the
    s:fenced-code-tilde-close-fence-inside
*   ↪ **Anything else**

    Reconsume in the s:fenced-code-tilde-continuation-inside

### Fenced code tilde close fence inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    If `sizeClose` is greater than or equal to `sizeOpen`, enqueue a
    l:fenced-code-fence-sequence-end, and reconsume in the
    s:fenced-code-tilde-close-fence-after

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:~**

    Increment `sizeClose` by `1` and consume
*   ↪ **Anything else**

    Unset `sizeClose` and reconsume in the
    s:fenced-code-tilde-continuation-inside

### Fenced code tilde close fence after state

*   ↪ **[c:EOF][]**

    Unset `sizeOpen`, unset `sizeClose`, enqueue a l:fenced-code-fence-end,
    enqueue a l:fenced-code-end, and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Unset `sizeOpen`, unset `sizeClose`, enqueue a l:fenced-code-fence-end,
    enqueue a l:fenced-code-end, enqueue an t:end-of-line, consume, and switch
    to the s:flow-prefix-initial
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:fenced-code-tilde-continuation-inside

### Fenced code tilde continuation inside state

*   ↪ **[c:EOF][]**

    Unset `sizeOpen`, unset `sizeClose`, enqueue a l:fenced-code-fence-end,
    enqueue a l:fenced-code-end, and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line, consume, and switch to the s:flow-prefix-initial
*   ↪ **Anything else**

    Ensure a t:content and consume

### Flow content state

*   ↪ **[c:EOF][]**

    Enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line, consume, and switch to the s:flow-prefix-initial
*   ↪ **Anything else**

    Consume

## Content state machine

The [content state machine](#) is used to tokenize the inline constructs part of
content blocks in a document (such as regular definitions and phrasing) and must
start in the s:content-start.

### Content start state

> **Hookable**, the regular hooks are:
>
> *   **c:[**: s:definition-label-start

*   ↪ **Anything else**

    Reconsume in the s:content-initial

### Content initial state

> **Hookable**, there are no regular hooks.

*   ↪ **Anything else**

    Reconsume in the s:phrasing-content

### Definition label start state

*   ↪ **c:[**

    Enqueue a l:content-definition-start, enqueue a
    l:content-definition-label-start, enqueue a t:marker, consume, enqueue a
    l:content-definition-label-open, and switch to the s:definition-label-before
*   ↪ **Anything else**

    Enqueue a l:nok

### Definition label before state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:]**

    Enqueue a l:nok
*   ↪ **Anything else**

    Enqueue a t:content, consume, and switch to the s:definition-label-inside

### Definition label inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:definition-label-between
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the s:definition-label-escape
*   ↪ **c:]**

    Enqueue a l:content-definition-label-close, enqueue a t:marker, consume,
    enqueue a l:content-definition-label-end, and switch to the
    s:definition-label-after
*   ↪ **Anything else**

    Ensure a t:content and consume

### Definition label between state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:definition-label-inside

### Definition label escape state

*   ↪ **U+005C BACKSLASH (`\`)**\
    ↪ **c:]**

    Consume and switch to the s:definition-label-inside
*   ↪ **Anything else**

    Reconsume in the s:definition-label-inside

### Definition label after state

*   ↪ **c::**

    Enqueue a t:marker, consume, and switch to the
    s:definition-destination-before
*   ↪ **Anything else**

    Enqueue a l:nok

### Definition destination before state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:<**

    Enqueue a l:content-definition-destination-start, enqueue a t:marker,
    enqueue a l:content-definition-destination-quoted-open, consume, and switch
    to the s:definition-destination-quoted-inside
*   ↪ **[ASCII control][]**

    Enqueue a l:nok
*   ↪ **Anything else**

    Let `balance` be `0`, enqueue a l:content-definition-destination-start,
    enqueue a l:content-definition-destination-unquoted-open, enqueue a
    t:content, and reconsume in the s:definition-destination-unquoted-inside

### Definition destination quoted inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **c:<**

    Enqueue a l:nok
*   ↪ **c:>**

    Enqueue a l:content-definition-destination-quoted-close, enqueue a t:marker,
    consume, enqueue a l:content-definition-destination-end, and switch to the
    s:definition-destination-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:definition-destination-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Definition destination quoted escape state

*   ↪ **c:<**\
    ↪ **c:>**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:definition-destination-quoted-inside
*   ↪ **Anything else**

    Reconsume in the s:definition-destination-quoted-inside

### Definition destination unquoted inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Unset `balance`, enqueue a l:content-definition-destination-unquoted-close,
    enqueue a l:content-definition-destination-end, and reconsume in the
    s:definition-title-before
*   ↪ **c:(**

    Increment `balance` by `1`, ensure a t:content, and consume
*   ↪ **c:)**

    If `balance` is `0`, treat it as per the “ASCII control” entry below

    Otherwise, decrement `balance` by `1`, ensure a t:content, and consume
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:definition-destination-unquoted-escape
*   ↪ **[ASCII control][]**

    Unset `balance` and enqueue a l:nok
*   ↪ **Anything else**

    Ensure a t:content and consume

### Definition destination unquoted escape state

*   ↪ **c:(**\
    ↪ **c:)**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:definition-destination-unquoted-inside
*   ↪ **Anything else**

    Reconsume in the s:definition-destination-unquoted-inside

### Definition destination after state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:definition-title-before
*   ↪ **Anything else**

    Enqueue a l:nok

### Definition title before state

*   ↪ **[c:EOL][]**

    Enqueue a l:content-definition-partial, enqueue an t:end-of-line, consume,
    and switch to the s:definition-title-or-label-before
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:[**

    Enqueue a l:nok
*   ↪ **Anything else**

    Reconsume in the s:definition-title-or-label-before

### Definition title or label before state

*   ↪ **[c:EOF][]**

    Enqueue a l:content-definition-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:"**

    Enqueue a l:content-definition-title-start, enqueue a t:marker, consume,
    enqueue a l:content-definition-title-open, and switch to the
    s:definition-title-double-quoted
*   ↪ **c:'**

    Enqueue a l:content-definition-title-start, enqueue a t:marker, consume,
    enqueue a l:content-definition-title-open, and switch to the
    s:definition-title-single-quoted
*   ↪ **c:(**

    Enqueue a l:content-definition-title-start, enqueue a t:marker, consume,
    enqueue a l:content-definition-title-open, and switch to the
    s:definition-title-paren-quoted
*   ↪ **Anything else**

    Reconsume in the s:content-start

### Definition title double quoted state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:definition-title-double-quoted-between
*   ↪ **c:"**

    Enqueue a l:content-definition-title-close, enqueue a t:marker, consume,
    enqueue a l:content-definition-title-end, and switch to the
    s:definition-title-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:definition-title-double-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Definition title double quoted between state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:definition-title-double-quoted

### Definition title double quoted escape state

*   ↪ **c:"**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:definition-title-double-quoted
*   ↪ **Anything else**

    Reconsume in the s:definition-title-double-quoted

### Definition title single quoted state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:definition-title-single-quoted-between
*   ↪ **c:'**

    Enqueue a l:content-definition-title-close, enqueue a t:marker, consume,
    enqueue a l:content-definition-title-end, and switch to the
    s:definition-title-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:definition-title-single-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Definition title single quoted between state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:definition-title-single-quoted

### Definition title single quoted escape state

*   ↪ **c:'**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:definition-title-single-quoted
*   ↪ **Anything else**

    Reconsume in the s:definition-title-single-quoted

### Definition title paren quoted state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:definition-title-paren-quoted-between
*   ↪ **c:)**

    Enqueue a l:content-definition-title-close, enqueue a t:marker, consume,
    enqueue a l:content-definition-title-end, and switch to the
    s:definition-title-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:definition-title-paren-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Definition title paren quoted between state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:definition-title-paren-quoted

### Definition title paren quoted escape state

*   ↪ **c:)**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:definition-title-paren-quoted
*   ↪ **Anything else**

    Reconsume in the s:definition-title-paren-quoted

### Definition title after state

*   ↪ **[c:EOF][]**

    Enqueue a l:content-definition-end and enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue a l:content-definition-end, enqueue an t:end-of-line, consume, and
    switch to the s:content-start
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Enqueue a l:nok

### Phrasing content state

*   ↪ **[c:EOF][]**

    Enqueue an t:end-of-file
*   ↪ **[c:EOL][]**

    Enqueue an t:end-of-line, consume, and switch to the s:content-initial
*   ↪ **Anything else**

    Consume

## Text state machine

The [text state machine](#) is used to tokenize the inline constructs part of
rich text (such as regular resources and emphasis) or plain text (such as
regular character escapes or character references) in a document and must start
in the s:text-start.

If text is parsed as plain text, the s:text-start, s:text-initial, and s:text
all forward to the s:plain-text.

If text is parsed as rich text, an additional variable `prev` must be tracked.
Initial set to [c:EOF][], it must be set to the [input character][] right before
a character is consumed.

### Text start state

> **Hookable**, there are no regular hooks.

*   ↪ **Anything else**

    Reconsume in the s:text-initial

### Text initial state

> **Hookable**, there are no regular hooks.

*   ↪ **Anything else**

    Reconsume in the s:text

### Text state

> **Hookable**, the regular hooks are:
>
> *   **[c:EOL][]**: s:end-of-line
> *   **c:!**: s:image-label-start
> *   **c:&**: s:character-reference
> *   **c:***: s:delimiter-run-asterisk-start
> *   **c:<**: s:autolink
> *   **c:<**: s:html
> *   **c:[**: s:link-label-start
> *   **U+005C BACKSLASH (`\`)**: s:character-escape
> *   **U+005C BACKSLASH (`\`)**: s:break-escape
> *   **c:]**: s:label-resource-close
> *   **c:]**: s:label-reference-close
> *   **c:]**: s:label-reference-shortcut-close
> *   **c:_**: s:delimiter-run-underscore-start
> *   **c:`**: s:code-start

*   ↪ **[c:EOF][]**

    Enqueue an t:end-of-file
*   ↪ **Anything else**

    Ensure a t:content and consume

### Plain text state

> **Hookable**, the regular hooks are:
>
> *   **[c:EOL][]**: s:plain-end-of-line
> *   **c:&**: s:character-reference
> *   **U+005C BACKSLASH (`\`)**: s:character-escape

*   ↪ **[c:EOF][]**

    Enqueue an t:end-of-file
*   ↪ **Anything else**

    Ensure a t:content and consume

### End-of-line state

*   ↪ **[c:EOL][]**

    If the break represented by the character starts with two or more of
    [c:VS][], c:HT, or c:SP, enqueue a l:hard-break, enqueue an t:end-of-line,
    consume, and switch to the s:text-initial

    Otherwise, enqueue a l:soft-break, enqueue an t:end-of-line, consume,
    and switch to the s:text-initial
*   ↪ **Anything else**

    Enqueue a l:nok

### Plain end-of-line state

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and switch to the
    s:text-initial
*   ↪ **Anything else**

    Enqueue a l:nok

### Image label start state

*   ↪ **c:!**

    Enqueue an l:image-label-start, enqueue a t:marker, consume, and switch to
    the s:image-label-start-after
*   ↪ **Anything else**

    Enqueue a l:nok

### Image label start after state

*   ↪ **c:[**

    Enqueue a t:marker, consume, enqueue an l:image-label-open, and switch to
    the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Character reference state

*   ↪ **c:&**

    Enqueue a l:character-reference-start, enqueue a t:marker, consume, and
    switch to the s:character-reference-start-after
*   ↪ **Anything else**

    Enqueue a l:nok

### Character reference start after state

*   ↪ **c:#**

    Enqueue a t:marker, consume, and switch to the s:character-reference-numeric
*   ↪ **[ASCII alphanumeric][]**

    Let `entityName` be the empty string, append the character to `entityName`,
    enqueue a t:content, consume, and switch to the s:character-reference-named
*   ↪ **Anything else**

    Enqueue a l:nok

### Character reference named state

> **Note**: This state can be optimized by either imposing a maximum size (the
> size of the longest possible named character reference) or by using a trie of
> the possible named character references.

*   ↪ **c:;**

    If `entityName` is a [character reference name][], unset `entityName`,
    enqueue a t:marker, consume, enqueue a l:character-reference-end, and switch
    to the s:text

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[ASCII alphanumeric][]**

    Append the character to `entityName` and consume
*   ↪ **Anything else**

    Unset `entityName` and enqueue a l:nok

### Character reference numeric state

*   ↪ **c:X**\
    ↪ **c:x**

    Let `characterReferenceCode` be `0`, enqueue a t:marker, consume, and switch
    to the s:character-reference-hexadecimal-start
*   ↪ **[ASCII digit][]**

    Let `characterReferenceCode` be `0`, enqueue a t:content and reconsume in
    the s:character-reference-decimal
*   ↪ **Anything else**

    Enqueue a l:nok

### Character reference hexadecimal start state

*   ↪ **[ASCII hex digit][]**

    Enqueue a t:content and reconsume in the s:character-reference-hexadecimal
*   ↪ **Anything else**

    Unset `characterReferenceCode` and enqueue a l:nok

### Character reference hexadecimal state

> **Note**: This state can be optimized by imposing a maximum size (the size of
> the longest possible valid hexadecimal character reference, 6).

*   ↪ **c:;**

    Unset `characterReferenceCode`, enqueue a t:marker, consume, enqueue a
    l:character-reference-end, and switch to the s:text
*   ↪ **[ASCII digit][]**

    Multiply `characterReferenceCode` by `0x10`, add the [digitize][]d
    [input character][] to `characterReferenceCode`, and consume
*   ↪ **[ASCII upper hex digit][]**

    Multiply `characterReferenceCode` by `0x10`, add the [digitize][]d
    [input character][] to `characterReferenceCode`, and consume
*   ↪ **[ASCII lower hex digit][]**

    Multiply `characterReferenceCode` by `0x10`, add the [digitize][]d
    [input character][] to `characterReferenceCode`, and consume
*   ↪ **Anything else**

    Unset `characterReferenceCode` and enqueue a l:nok

### Character reference decimal state

> **Note**: This state can be optimized by imposing a maximum size (the size of
> the longest possible valid decimal character reference, 7).

*   ↪ **c:;**

    Unset `characterReferenceCode`, enqueue a t:marker, consume, enqueue a
    l:character-reference-end, and switch to the s:text
*   ↪ **[ASCII digit][]**

    Multiply `characterReferenceCode` by `10`, add the [digitize][]d
    [input character][] to `characterReferenceCode`, and consume
*   ↪ **Anything else**

    Unset `characterReferenceCode` and enqueue a l:nok

### Delimiter run asterisk start state

*   ↪ **c:***

    Let `delimiterRunAfter` be `null` and let `delimiterRunBefore` be
    `'whitespace'` if `prev` is [c:EOF][], [c:EOL][], or [Unicode whitespace][],
    `'punctuation'` if it is [Unicode punctuation][], or `null` otherwise

    Enqueue a l:delimiter-run-start, enqueue a t:sequence, consume, and switch
    to the s:delimiter-run-asterisk
*   ↪ **Anything else**

    Enqueue a l:nok

### Delimiter run asterisk state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[Unicode whitespace][]**

    Let `delimiterRunAfter` be `'whitespace'` and treat it as per the “anything
    else” entry below
*   ↪ **c:***

    Consume
*   ↪ **[Unicode punctuation][]**

    Let `delimiterRunAfter` be `'punctuation'` and treat it as per the “anything
    else” entry below
*   ↪ **Anything else**

    Let `leftFlanking` be whether both `delimiterRunAfter` is not
    `'whitespace'`, and that either `delimiterRunAfter` is not `'punctuation'`
    or that `delimiterRunBefore` is not `null`

    Let `rightFlanking` be whether both `delimiterRunBefore` is not
    `'whitespace'`, and that either `delimiterRunBefore` is not `'punctuation'`
    or that `delimiterRunAfter` is not `null`

    Unset `delimiterRunBefore`, unset `delimiterRunAfter`, enqueue a
    l:delimiter-run-end, and reconsume in the s:text

### Autolink state

*   ↪ **c:<**

    Enqueue an l:autolink-start, enqueue a t:marker, consume, enqueue an
    l:autolink-open, and switch to the s:autolink-open
*   ↪ **Anything else**

    Enqueue a l:nok

### Autolink open state

*   ↪ **[ASCII alpha][]**

    Consume, let `sizeScheme` be `1`, and switch to the
    s:autolink-scheme-or-email-atext
*   ↪ **[atext][]**\
    ↪ **c:.**

    Consume and switch to the s:autolink-email-atext
*   ↪ **Anything else**

    Enqueue a l:nok

### Autolink email atext state

*   ↪ **c:@**

    Enqueue a t:marker, consume, let `sizeLabel` be `1`, enqueue a t:content,
    and switch to the s:autolink-email-at-sign-or-dot
*   ↪ **[atext][]**\
    ↪ **c:.**

    Consume
*   ↪ **Anything else**

    Enqueue a l:nok

### Autolink email label state

*   ↪ **c:-**

    If `sizeLabel` is not `63`, increment `sizeLabel` by `1`, consume, and
    switch to the s:autolink-email-dash

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:.**

    If `sizeLabel` is not `63`, increment `sizeLabel` by `1`, consume, and
    switch to the s:autolink-email-at-sign-or-dot

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **c:>**

    Unset `sizeLabel`, enqueue an l:autolink-email-close, enqueue a t:marker,
    consume, enqueue an l:autolink-email-end, and switch to the s:text
*   ↪ **[ASCII alphanumeric][]**

    If `sizeLabel` is not `63`, increment `sizeLabel` by `1` and consume

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Unset `sizeLabel` and enqueue a l:nok

### Autolink email at sign or dot state

*   ↪ **[ASCII alphanumeric][]**

    If `sizeLabel` is not `63`, increment `sizeLabel` by `1`, consume, and
    switch to the s:autolink-email-label

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Unset `sizeLabel` and enqueue a l:nok

### Autolink email dash state

*   ↪ **c:-**

    If `sizeLabel` is not `63`, increment `sizeLabel` by `1` and consume

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **[ASCII alphanumeric][]**

    If `sizeLabel` is not `63`, increment `sizeLabel` by `1`, consume, and
    switch to the s:autolink-email-label

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Unset `sizeLabel` and enqueue a l:nok

### Autolink scheme or email atext state

*   ↪ **c:+**\
    ↪ **c:.**\
    ↪ **c:-**\
    ↪ **[ASCII alphanumeric][]**

    Increment `sizeScheme` by `1`, consume, and switch to the
    s:autolink-scheme-inside-or-email-atext
*   ↪ **[atext][]**

    Unset `sizeScheme`, consume, and switch to the s:autolink-email-atext
*   ↪ **Anything else**

    Unset `sizeScheme` and enqueue a l:nok

### Autolink scheme inside or email atext state

*   ↪ **c::**

    Unset `sizeScheme`, enqueue a t:marker, consume, enqueue a t:content, and
    switch to the s:autolink-uri-inside
*   ↪ **c:@**

    Unset `sizeScheme`, enqueue a t:marker, consume, let `sizeLabel` be `1`,
    enqueue a t:content, and switch to the s:autolink-email-at-sign-or-dot
*   ↪ **c:+**\
    ↪ **c:.**\
    ↪ **c:-**\
    ↪ **[ASCII alphanumeric][]**

    If `sizeScheme` is not `32`, increment `sizeScheme` by `1` and consume

    Otherwise, treat it as per the “atext” entry below
*   ↪ **[atext][]**

    Unset `sizeScheme`, consume, and switch to the s:autolink-email-atext
*   ↪ **Anything else**

    Unset `sizeScheme` and enqueue a l:nok

### Autolink URI inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[ASCII control][]**\
    ↪ **c:SP**\
    ↪ **c:<**

    Enqueue a l:nok
*   ↪ **c:>**

    Enqueue an l:autolink-uri-close, enqueue a t:marker, consume, enqueue an
    l:autolink-uri-end, and switch to the s:text
*   ↪ **Anything else**

    Consume

### HTML state

*   ↪ **c:<**

    Enqueue an l:html-start, enqueue a t:content, consume, and switch to the
    s:html-open
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML open state

*   ↪ **c:!**

    Consume and switch to the s:html-declaration-start
*   ↪ **c:/**

    Consume and switch to the s:html-tag-close-start
*   ↪ **c:?**

    Consume and switch to the s:html-instruction-inside
*   ↪ **[ASCII alpha][]**

    Consume and switch to the s:html-tag-open-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML declaration start state

*   ↪ **c:-**

    Consume and switch to the s:html-comment-open-inside
*   ↪ **`[CDATA[` (the five upper letters “CDATA” with a c:[ before and
    after)**

    Consume and switch to the s:html-cdata-inside
*   ↪ **[ASCII alpha][]**

    Reconsume in the s:html-declaration-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML comment open inside state

*   ↪ **c:-**

    Consume and switch to the s:html-comment-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML comment inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **c:-**

    Consume and switch to the s:html-comment-close-inside
*   ↪ **Anything else**

    Consume

### HTML comment close inside state

*   ↪ **c:-**

    Consume and switch to the s:html-comment-close
*   ↪ **Anything else**

    Reconsume in the s:html-comment-inside

### HTML comment close state

> **Note**: a CM comment may not contain two dashes (`--`), and may not end in a
> dash (which would result in `--->`).
> Here we have seen two dashes, so we can either be at the end of a comment, or
> no longer in a comment.

*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML CDATA inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **`]]>` (two of c:], with a c:> after)**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Consume

### HTML declaration inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Consume

### HTML instruction inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **c:?**

    Consume and switch to the s:html-instruction-close
*   ↪ **Anything else**

    Consume

### HTML instruction close state

*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Reconsume in the s:html-instruction-inside

### HTML tag close start state

*   ↪ **[ASCII alpha][]**

    Consume and switch to the s:html-tag-close-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag close inside state

*   ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:html-tag-close-between
*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **[ASCII alphanumeric][]**\
    ↪ **c:-**

    Consume
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag close between state

> **Note**: an EOL is technically allowed here, but as a `>` after an EOL would
> start a blockquote, practically it’s not possible.

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag open inside state

*   ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:html-tag-open-between
*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **[ASCII alphanumeric][]**\
    ↪ **c:-**

    Consume
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag open between state

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:/**

    Consume and switch to the s:html-tag-open-self-closing
*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **[ASCII alpha][]**\
    ↪ **c::**\
    ↪ **c:_**

    Consume and switch to the s:html-tag-open-attribute-name
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag open self closing state

*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag open attribute name state

*   ↪ **[ASCII alphanumeric][]**\
    ↪ **c:-**\
    ↪ **c:.**\
    ↪ **c::**\
    ↪ **c:_**

    Consume
*   ↪ **Anything else**

    Reconsume in the s:html-tag-open-attribute-name-after

### HTML tag open attribute name after state

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:/**

    Consume and switch to the s:html-tag-open-self-closing
*   ↪ **c:=**

    Consume and switch to the s:html-tag-open-attribute-before
*   ↪ **c:>**

    Consume, enqueue an l:html-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### HTML tag open attribute before state

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Consume
*   ↪ **c:"**

    Consume and switch to the s:html-tag-open-double-quoted-attribute
*   ↪ **c:'**

    Consume and switch to the s:html-tag-open-single-quoted-attribute
*   ↪ **c:<**\
    ↪ **c:=**\
    ↪ **c:>**\
    ↪ **c:`**

    Enqueue a l:nok
*   ↪ **Anything else**

    Consume and switch to the s:html-tag-open-unquoted-attribute

### HTML tag open double quoted attribute state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **c:"**

    Consume and switch to the s:html-tag-open-between
*   ↪ **Anything else**

    Consume

### HTML tag open single quoted attribute state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, consume, and enqueue a
    t:content
*   ↪ **c:'**

    Consume and switch to the s:html-tag-open-between
*   ↪ **Anything else**

    Consume

### HTML tag open unquoted attribute state

*   ↪ **[c:EOF][]**\
    ↪ **c:"**\
    ↪ **c:'**\
    ↪ **c:<**\
    ↪ **c:=**\
    ↪ **c:`**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**\
    ↪ **c:>**

    Reconsume in the s:html-tag-open-between
*   ↪ **Anything else**

    Consume

### Link label start state

*   ↪ **c:[**

    Enqueue a l:link-label-start, enqueue a t:marker, consume, enqueue a
    l:link-label-open, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Character escape state

*   ↪ **U+005C BACKSLASH (`\`)**

    Enqueue a l:character-escape-start, enqueue a t:marker, consume, and switch
    to the s:character-escape-after
*   ↪ **Anything else**

    Enqueue a l:nok

### Character escape after state

*   ↪ **[ASCII punctuation][]**

    Enqueue a t:content, consume, enqueue a l:character-escape-end, and switch
    to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Break escape state

*   ↪ **U+005C BACKSLASH (`\`)**

    Enqueue a l:break-escape-start, enqueue a l:hard-break, enqueue a t:marker,
    consume, and switch to the s:break-escape-after
*   ↪ **Anything else**

    Enqueue a l:nok

### Break escape after state

*   ↪ **[c:EOL][]**

    If the break represented by the character does not start with a [c:VS][],
    c:HT, or c:SP, enqueue an t:end-of-line, consume, enqueue a
    l:break-escape-end, and switch to the s:text-initial

    Otherwise, treat it as per the “anything else” entry below
*   ↪ **Anything else**

    Enqueue a l:nok

### Label resource close state

*   ↪ **c:]**

    Enqueue a l:label-close, enqueue a t:marker, consume, enqueue a l:label-end,
    and switch to the s:label-resource-end-after
*   ↪ **Anything else**

    Enqueue a l:nok

### Label resource end after state

*   ↪ **c:(**

    Enqueue a l:resource-information-start, enqueue a t:marker, consume, enqueue
    a l:resource-information-open, and switch to the s:resource-information-open
*   ↪ **Anything else**

    Enqueue a l:nok

### Resource information open state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:)**

    Enqueue a l:resource-information-close, enqueue a t:marker, consume, enqueue
    a l:resource-information-end, and switch to the s:text
*   ↪ **c:<**

    Enqueue a l:resource-information-destination-quoted-start, enqueue a
    t:marker, consume, enqueue a l:resource-information-destination-quoted-open,
    and switch to the s:resource-information-destination-quoted-inside
*   ↪ **[ASCII control][]**

    Enqueue a l:nok
*   ↪ **Anything else**

    Enqueue a l:resource-information-destination-unquoted-start, enqueue a
    t:content, consume, enqueue a
    l:resource-information-destination-unquoted-open, and switch to the
    s:resource-information-destination-unquoted-inside

### Resource information destination quoted inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **c:<**

    Enqueue a l:nok
*   ↪ **c:>**

    Enqueue a l:resource-information-destination-quoted-close, enqueue a
    t:marker, consume, enqueue a l:resource-information-destination-quoted-end,
    and switch to the s:resource-information-destination-quoted-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:resource-information-destination-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Resource information destination quoted escape state

*   ↪ **c:<**\
    ↪ **c:>**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:resource-information-destination-quoted-inside
*   ↪ **Anything else**

    Reconsume in the s:resource-information-destination-quoted-inside

### Resource information destination quoted after state

*   ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**\
    ↪ **c:>**

    Reconsume in the s:resource-information-between
*   ↪ **c:)**

    Enqueue a l:resource-information-close, enqueue a t:marker, consume, enqueue
    a l:resource-information-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Resource information destination unquoted inside state

*   ↪ **[c:EOF][]**

    Unset `balance` and enqueue a l:nok
*   ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**\
    ↪ **c:>**

    Enqueue a l:resource-information-destination-unquoted-close, enqueue a
    l:resource-information-destination-unquoted-end, and reconsume in the
    s:resource-information-between
*   ↪ **c:(**

    Increment `balance` by `1` and consume
*   ↪ **c:)**

    If `balance` is `0`, unset `balance`, enqueue a
    l:resource-information-destination-unquoted-close, enqueue a
    l:resource-information-destination-unquoted-end, and reconsume in the
    s:resource-information-between

    Otherwise, decrement `balance` by `1`, and consume
*   ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:resource-information-destination-unquoted-escape
*   ↪ **[ASCII control][]**

    Unset `balance` and enqueue a l:nok
*   ↪ **Anything else**

    Consume

### Resource information destination unquoted escape state

*   ↪ **c:(**\
    ↪ **c:)**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:resource-information-destination-unquoted-inside
*   ↪ **Anything else**

    Reconsume in the s:resource-information-destination-unquoted-inside

### Resource information between state

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:"**

    Enqueue a l:resource-information-title-start, enqueue a t:marker, consume,
    enqueue a l:resource-information-title-open, and switch to the
    s:resource-information-title-double-quoted-inside
*   ↪ **c:'**

    Enqueue a l:resource-information-title-start, enqueue a t:marker, consume,
    enqueue a l:resource-information-title-open, and switch to the
    s:resource-information-title-single-quoted-inside
*   ↪ **c:(**

    Enqueue a l:resource-information-title-start, enqueue a t:marker, consume,
    enqueue a l:resource-information-title-open, and switch to the
    s:resource-information-title-paren-quoted-inside
*   ↪ **c:)**

    Enqueue a l:resource-information-close, enqueue a t:marker, consume, enqueue
    a l:resource-information-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Resource information title double quoted inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **c:"**

    Enqueue a l:resource-information-title-close, enqueue a t:marker, consume,
    enqueue a l:resource-information-title-end, and switch to the
    s:resource-information-title-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:resource-information-title-double-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Resource information title double quoted escape state

*   ↪ **c:"**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:resource-information-title-double-quoted-inside
*   ↪ **Anything else**

    Reconsume in the s:resource-information-title-double-quoted-inside

### Resource information title single quoted inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **c:'**

    Enqueue a l:resource-information-title-close, enqueue a t:marker, consume,
    enqueue a l:resource-information-title-end, and switch to the
    s:resource-information-title-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:resource-information-title-single-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Resource information title single quoted escape state

*   ↪ **c:'**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:resource-information-title-single-quoted-inside
*   ↪ **Anything else**

    Reconsume in the s:resource-information-title-single-quoted-inside

### Resource information title paren quoted inside state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **c:)**

    Enqueue a l:resource-information-title-close, enqueue a t:marker, consume,
    enqueue a l:resource-information-title-end, and switch to the
    s:resource-information-title-after
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the
    s:resource-information-title-paren-quoted-escape
*   ↪ **Anything else**

    Ensure a t:content and consume

### Resource information title paren quoted escape state

*   ↪ **c:)**\
    ↪ **U+005C BACKSLASH (`\`)**

    Consume and switch to the s:resource-information-title-paren-quoted-inside
*   ↪ **Anything else**

    Reconsume in the s:resource-information-title-paren-quoted-inside

### Resource information title after state

*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:)**

    Enqueue a l:resource-information-close, enqueue a t:marker, consume, enqueue
    a l:resource-information-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Label reference close state

*   ↪ **c:]**

    Enqueue a l:label-close, enqueue a t:marker, consume, enqueue a l:label-end,
    and switch to the s:label-reference-end-after
*   ↪ **Anything else**

    Enqueue a l:nok

### Label reference end after state

*   ↪ **c:[**

    Enqueue a l:reference-label-start, enqueue a t:marker, consume, enqueue a
    l:reference-label-open, and switch to the s:reference-label-open
*   ↪ **Anything else**

    Enqueue a l:nok

### Reference label open state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **c:]**

    Enqueue a l:reference-label-collapsed-close, enqueue a t:marker, consume,
    enqueue a l:reference-label-end, and switch to the s:text
*   ↪ **Anything else**

    Enqueue a t:content, consume, and switch to the s:reference-label-inside

### Reference label inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:reference-label-between
*   ↪ **U+005C BACKSLASH (`\`)**

    Ensure a t:content, consume, and switch to the s:reference-label-escape
*   ↪ **c:]**

    Enqueue a l:reference-label-full-close, enqueue a t:marker, consume, enqueue
    a l:reference-label-end, and switch to the s:text
*   ↪ **Anything else**

    Ensure a t:content and consume

### Reference label between state

*   ↪ **[c:EOF][]**

    Enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:reference-label-inside

### Reference label escape state

*   ↪ **U+005C BACKSLASH (`\`)**\
    ↪ **c:]**

    Consume and switch to the s:reference-label-inside
*   ↪ **Anything else**

    Reconsume in the s:reference-label-inside

### Label reference shortcut close state

*   ↪ **c:]**

    Enqueue a l:label-close, enqueue a t:marker, consume, enqueue a l:label-end,
    and switch to the s:text
*   ↪ **Anything else**

    Enqueue a l:nok

### Delimiter run underscore start state

*   ↪ **c:_**

    Let `delimiterRunAfter` be `null` and let `delimiterRunBefore` be
    `'whitespace'` if `prev` is [c:EOF][], [c:EOL][], or [Unicode whitespace][],
    `'punctuation'` if it is [Unicode punctuation][], or `null` otherwise

    Enqueue a l:delimiter-run-start, enqueue a t:sequence, consume, and switch
    to the s:delimiter-run-underscore
*   ↪ **Anything else**

    Enqueue a l:nok

### Delimiter run underscore state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[Unicode whitespace][]**

    Let `delimiterRunAfter` be `'whitespace'` and treat it as per the “anything
    else” entry below
*   ↪ **c:_**

    Consume
*   ↪ **[Unicode punctuation][]**

    Let `delimiterRunAfter` be `'punctuation'` and treat it as per the “anything
    else” entry below
*   ↪ **Anything else**

    Let `leftFlanking` be whether both `delimiterRunAfter` is not
    `'whitespace'`, and that either `delimiterRunAfter` is not `'punctuation'`
    or that `delimiterRunBefore` is not `null`

    Let `rightFlanking` be whether both `delimiterRunBefore` is not
    `'whitespace'`, and that either `delimiterRunBefore` is not `'punctuation'`
    or that `delimiterRunAfter` is not `null`

    Unset `delimiterRunBefore`, unset `delimiterRunAfter`, enqueue a
    l:delimiter-run-end, and reconsume in the s:text

### Code start state

*   ↪ **c:`**

    Let `sizeOpen` be `1`, enqueue a l:code-start, enqueue a l:code-fence-start,
    enqueue a t:marker, consume, and switch to the s:code-open-fence-inside
*   ↪ **Anything else**

    Enqueue a l:nok

### Code open fence inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Enqueue a l:code-fence-end and reconsume in the s:code-between
*   ↪ **c:`**

    Increment `sizeOpen` by `1` and consume
*   ↪ **Anything else**

    Enqueue a l:code-fence-end, enqueue a t:content, consume, and switch to the
    s:code-inside

### Code between state

*   ↪ **[c:EOF][]**

    Unset `sizeOpen` and enqueue a l:nok
*   ↪ **[c:EOL][]**

    Enqueue a l:soft-break, enqueue an t:end-of-line, and consume
*   ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Ensure a t:whitespace and consume
*   ↪ **Anything else**

    Reconsume in the s:code-inside

### Code inside state

*   ↪ **[c:EOF][]**\
    ↪ **[c:EOL][]**\
    ↪ **[c:VS][]**\
    ↪ **c:HT**\
    ↪ **c:SP**

    Reconsume in the s:code-between
*   ↪ **c:`**

    Let `sizeClose` be `1`, enqueue a l:code-fence-start, enqueue a t:marker,
    consume, and switch to the s:code-close-fence-inside
*   ↪ **Anything else**

    Ensure a t:content and consume

### Code close fence inside state

*   ↪ **c:`**

    Increment `sizeClose` by `1` and consume
*   ↪ **Anything else**

    If `sizeOpen` is `sizeClose`, unset `sizeOpen`, unset `sizeClose`, enqueue a
    l:code-fence-end, enqueue a l:code-end, and reconsume in the s:text

    Otherwise, unset `sizeClose` and reconsume in the s:code-inside

## Labels

### NOK label

### Blank line end label

### ATX heading start label

### ATX heading fence start label

### ATX heading fence end label

### ATX heading end label

### Thematic break start label

### Thematic break end label

### Setext heading underline start label

### Setext heading underline end label

### Fenced code start label

### Fenced code fence start label

### Fenced code fence sequence start label

### Fenced code fence sequence end label

### Fenced code fence end label

### Fenced code end label


### Content definition partial label

### Content definition start label

### Content definition label start label

### Content definition label open label

### Content definition label close label

### Content definition label end label

### Content definition destination start label

### Content definition destination quoted open label

### Content definition destination quoted close label

### Content definition destination unquoted open label

### Content definition destination unquoted close label

### Content definition destination end label

### Content definition title start label

### Content definition title open label

### Content definition title close label

### Content definition title end label

### Content definition end label

### Hard break label

### Soft break label

### Image label start label

### Image label open label

### Character reference start label

### Character reference end label

### Delimiter run start label

### Delimiter run end label

### Autolink start label

### Autolink open label

### Autolink email close label

### Autolink email end label

### Autolink uri close label

### Autolink uri end label

### HTML start label

### HTML end label

### Link label start label

### Link label open label

### Character escape start label

### Character escape end label

### Break escape start label

### Break escape end label

### Label close label

### Label end label

### Resource information start label

### Resource information open label

### Resource information destination quoted start label

### Resource information destination quoted open label

### Resource information destination quoted close label

### Resource information destination quoted end label

### Resource information destination unquoted start label

### Resource information destination unquoted open label

### Resource information destination unquoted close label

### Resource information destination unquoted end label

### Resource information title start label

### Resource information title open label

### Resource information title close label

### Resource information title end label

### Resource information close label

### Resource information end label

### Reference label start label

### Reference label open label

### Reference label collapsed close label

### Reference label full close label

### Reference label end label

### Code start label

### Code fence start label

### Code fence end label

### Code end label

## Tokens

### Whitespace token

A t:whitespace represents inline whitespace that is part of syntax instead
of content.

```idl
interface Whitespace <: Token {
  size: number
  used: number
  characters: [Character]
}
```

```js
{
  type: 'whitespace',
  characters: [9],
  size: 3,
  used: 0
}
```

### Line terminator token

A t:line-terminator represents a line break.

```idl
interface LineEnding <: Token {}
```

```js
{type: 'lineEnding'}
```

### End-of-file token

An t:end-of-file represents the end of the syntax.

```idl
interface EndOfFile <: Token {}
```

```js
{type: 'endOfFile'}
```

### End-of-line token

An t:end-of-line represents a point between two runs of text in content.

```idl
interface EndOfLine <: Token {}
```

```js
{type: 'endOfLine'}
```

### Marker token

A t:marker represents one punctuation character that is part of syntax instead
of content.

```idl
interface Marker <: Token {}
```

```js
{type: 'marker'}
```

### Sequence token

A t:sequence represents one or more of the same punctuation characters that are
part of syntax instead of content.

```idl
interface Sequence <: Token {
  size: number
}
```

```js
{type: 'sequence', size: 3}
```

### Content token

A t:content represents content.

```idl
interface Content <: Token {
  prefix: string
}
```

```js
{type: 'content', prefix: '  '}
```

## Appendix

### Raw tags

A [raw tag](#) is one of: `script`, `pre`, and `style`.

### Basic tags

A [basic tag](#) is one of: `address`, `article`, `aside`, `base`, `basefont`,
`blockquote`, `body`, `caption`, `center`, `col`, `colgroup`, `dd`, `details`,
`dialog`, `dir`, `div`, `dl`, `dt`, `fieldset`, `figcaption`, `figure`,
`footer`, `form`, `frame`, `frameset`, `h1`, `h2`, `h3`, `h4`, `h5`, `h6`,
`head`, `header`, `hr`, `html`, `iframe`, `legend`, `li`, `link`, `main`,
`menu`, `menuitem`, `nav`, `noframes`, `ol`, `optgroup`, `option`, `p`,
`param`, `section`, `source`, `summary`, `table`, `tbody`, `td`, `tfoot`, `th`,
`thead`, `title`, `tr`, `track`, and `ul`.

### Named character references

A [character reference name](#) is one of:
`AEli`, `AElig`, `AM`, `AMP`, `Aacut`, `Aacute`,
`Abreve`, `Acir`, `Acirc`, `Acy`, `Afr`, `Agrav`, `Agrave`, `Alpha`, `Amacr`,
`And`, `Aogon`, `Aopf`, `ApplyFunction`, `Arin`, `Aring`, `Ascr`, `Assign`,
`Atild`, `Atilde`, `Aum`, `Auml`, `Backslash`, `Barv`, `Barwed`, `Bcy`,
`Because`, `Bernoullis`, `Beta`, `Bfr`, `Bopf`, `Breve`, `Bscr`, `Bumpeq`,
`CHcy`, `COP`, `COPY`, `Cacute`, `Cap`, `CapitalDifferentialD`, `Cayleys`,
`Ccaron`, `Ccedi`, `Ccedil`, `Ccirc`, `Cconint`, `Cdot`, `Cedilla`, `CenterDot`,
`Cfr`, `Chi`, `CircleDot`, `CircleMinus`, `CirclePlus`, `CircleTimes`,
`ClockwiseContourIntegral`, `CloseCurlyDoubleQuote`, `CloseCurlyQuote`, `Colon`,
`Colone`, `Congruent`, `Conint`, `ContourIntegral`, `Copf`, `Coproduct`,
`CounterClockwiseContourIntegral`, `Cross`, `Cscr`, `Cup`, `CupCap`, `DD`,
`DDotrahd`, `DJcy`, `DScy`, `DZcy`, `Dagger`, `Darr`, `Dashv`, `Dcaron`, `Dcy`,
`Del`, `Delta`, `Dfr`, `DiacriticalAcute`, `DiacriticalDot`,
`DiacriticalDoubleAcute`, `DiacriticalGrave`, `DiacriticalTilde`, `Diamond`,
`DifferentialD`, `Dopf`, `Dot`, `DotDot`, `DotEqual`, `DoubleContourIntegral`,
`DoubleDot`, `DoubleDownArrow`, `DoubleLeftArrow`, `DoubleLeftRightArrow`,
`DoubleLeftTee`, `DoubleLongLeftArrow`, `DoubleLongLeftRightArrow`,
`DoubleLongRightArrow`, `DoubleRightArrow`, `DoubleRightTee`, `DoubleUpArrow`,
`DoubleUpDownArrow`, `DoubleVerticalBar`, `DownArrow`, `DownArrowBar`,
`DownArrowUpArrow`, `DownBreve`, `DownLeftRightVector`, `DownLeftTeeVector`,
`DownLeftVector`, `DownLeftVectorBar`, `DownRightTeeVector`, `DownRightVector`,
`DownRightVectorBar`, `DownTee`, `DownTeeArrow`, `Downarrow`, `Dscr`, `Dstrok`,
`ENG`, `ET`, `ETH`, `Eacut`, `Eacute`, `Ecaron`, `Ecir`, `Ecirc`, `Ecy`, `Edot`,
`Efr`, `Egrav`, `Egrave`, `Element`, `Emacr`, `EmptySmallSquare`,
`EmptyVerySmallSquare`, `Eogon`, `Eopf`, `Epsilon`, `Equal`, `EqualTilde`,
`Equilibrium`, `Escr`, `Esim`, `Eta`, `Eum`, `Euml`, `Exists`, `ExponentialE`,
`Fcy`, `Ffr`, `FilledSmallSquare`, `FilledVerySmallSquare`, `Fopf`, `ForAll`,
`Fouriertrf`, `Fscr`, `G`, `GJcy`, `GT`, `Gamma`, `Gammad`, `Gbreve`, `Gcedil`,
`Gcirc`, `Gcy`, `Gdot`, `Gfr`, `Gg`, `Gopf`, `GreaterEqual`, `GreaterEqualLess`,
`GreaterFullEqual`, `GreaterGreater`, `GreaterLess`, `GreaterSlantEqual`,
`GreaterTilde`, `Gscr`, `Gt`, `HARDcy`, `Hacek`, `Hat`, `Hcirc`, `Hfr`,
`HilbertSpace`, `Hopf`, `HorizontalLine`, `Hscr`, `Hstrok`, `HumpDownHump`,
`HumpEqual`, `IEcy`, `IJlig`, `IOcy`, `Iacut`, `Iacute`, `Icir`, `Icirc`, `Icy`,
`Idot`, `Ifr`, `Igrav`, `Igrave`, `Im`, `Imacr`, `ImaginaryI`, `Implies`, `Int`,
`Integral`, `Intersection`, `InvisibleComma`, `InvisibleTimes`, `Iogon`, `Iopf`,
`Iota`, `Iscr`, `Itilde`, `Iukcy`, `Ium`, `Iuml`, `Jcirc`, `Jcy`, `Jfr`, `Jopf`,
`Jscr`, `Jsercy`, `Jukcy`, `KHcy`, `KJcy`, `Kappa`, `Kcedil`, `Kcy`, `Kfr`,
`Kopf`, `Kscr`, `L`, `LJcy`, `LT`, `Lacute`, `Lambda`, `Lang`, `Laplacetrf`,
`Larr`, `Lcaron`, `Lcedil`, `Lcy`, `LeftAngleBracket`, `LeftArrow`,
`LeftArrowBar`, `LeftArrowRightArrow`, `LeftCeiling`, `LeftDoubleBracket`,
`LeftDownTeeVector`, `LeftDownVector`, `LeftDownVectorBar`, `LeftFloor`,
`LeftRightArrow`, `LeftRightVector`, `LeftTee`, `LeftTeeArrow`, `LeftTeeVector`,
`LeftTriangle`, `LeftTriangleBar`, `LeftTriangleEqual`, `LeftUpDownVector`,
`LeftUpTeeVector`, `LeftUpVector`, `LeftUpVectorBar`, `LeftVector`,
`LeftVectorBar`, `Leftarrow`, `Leftrightarrow`, `LessEqualGreater`,
`LessFullEqual`, `LessGreater`, `LessLess`, `LessSlantEqual`, `LessTilde`,
`Lfr`, `Ll`, `Lleftarrow`, `Lmidot`, `LongLeftArrow`, `LongLeftRightArrow`,
`LongRightArrow`, `Longleftarrow`, `Longleftrightarrow`, `Longrightarrow`,
`Lopf`, `LowerLeftArrow`, `LowerRightArrow`, `Lscr`, `Lsh`, `Lstrok`, `Lt`,
`Map`, `Mcy`, `MediumSpace`, `Mellintrf`, `Mfr`, `MinusPlus`, `Mopf`, `Mscr`,
`Mu`, `NJcy`, `Nacute`, `Ncaron`, `Ncedil`, `Ncy`, `NegativeMediumSpace`,
`NegativeThickSpace`, `NegativeThinSpace`, `NegativeVeryThinSpace`,
`NestedGreaterGreater`, `NestedLessLess`, `NewLine`, `Nfr`, `NoBreak`,
`NonBreakingSpace`, `Nopf`, `Not`, `NotCongruent`, `NotCupCap`,
`NotDoubleVerticalBar`, `NotElement`, `NotEqual`, `NotEqualTilde`, `NotExists`,
`NotGreater`, `NotGreaterEqual`, `NotGreaterFullEqual`, `NotGreaterGreater`,
`NotGreaterLess`, `NotGreaterSlantEqual`, `NotGreaterTilde`, `NotHumpDownHump`,
`NotHumpEqual`, `NotLeftTriangle`, `NotLeftTriangleBar`, `NotLeftTriangleEqual`,
`NotLess`, `NotLessEqual`, `NotLessGreater`, `NotLessLess`, `NotLessSlantEqual`,
`NotLessTilde`, `NotNestedGreaterGreater`, `NotNestedLessLess`, `NotPrecedes`,
`NotPrecedesEqual`, `NotPrecedesSlantEqual`, `NotReverseElement`,
`NotRightTriangle`, `NotRightTriangleBar`, `NotRightTriangleEqual`,
`NotSquareSubset`, `NotSquareSubsetEqual`, `NotSquareSuperset`,
`NotSquareSupersetEqual`, `NotSubset`, `NotSubsetEqual`, `NotSucceeds`,
`NotSucceedsEqual`, `NotSucceedsSlantEqual`, `NotSucceedsTilde`, `NotSuperset`,
`NotSupersetEqual`, `NotTilde`, `NotTildeEqual`, `NotTildeFullEqual`,
`NotTildeTilde`, `NotVerticalBar`, `Nscr`, `Ntild`, `Ntilde`, `Nu`, `OElig`,
`Oacut`, `Oacute`, `Ocir`, `Ocirc`, `Ocy`, `Odblac`, `Ofr`, `Ograv`, `Ograve`,
`Omacr`, `Omega`, `Omicron`, `Oopf`, `OpenCurlyDoubleQuote`, `OpenCurlyQuote`,
`Or`, `Oscr`, `Oslas`, `Oslash`, `Otild`, `Otilde`, `Otimes`, `Oum`, `Ouml`,
`OverBar`, `OverBrace`, `OverBracket`, `OverParenthesis`, `PartialD`, `Pcy`,
`Pfr`, `Phi`, `Pi`, `PlusMinus`, `Poincareplane`, `Popf`, `Pr`, `Precedes`,
`PrecedesEqual`, `PrecedesSlantEqual`, `PrecedesTilde`, `Prime`, `Product`,
`Proportion`, `Proportional`, `Pscr`, `Psi`, `QUO`, `QUOT`, `Qfr`, `Qopf`,
`Qscr`, `RBarr`, `RE`, `REG`, `Racute`, `Rang`, `Rarr`, `Rarrtl`, `Rcaron`,
`Rcedil`, `Rcy`, `Re`, `ReverseElement`, `ReverseEquilibrium`,
`ReverseUpEquilibrium`, `Rfr`, `Rho`, `RightAngleBracket`, `RightArrow`,
`RightArrowBar`, `RightArrowLeftArrow`, `RightCeiling`, `RightDoubleBracket`,
`RightDownTeeVector`, `RightDownVector`, `RightDownVectorBar`, `RightFloor`,
`RightTee`, `RightTeeArrow`, `RightTeeVector`, `RightTriangle`,
`RightTriangleBar`, `RightTriangleEqual`, `RightUpDownVector`,
`RightUpTeeVector`, `RightUpVector`, `RightUpVectorBar`, `RightVector`,
`RightVectorBar`, `Rightarrow`, `Ropf`, `RoundImplies`, `Rrightarrow`, `Rscr`,
`Rsh`, `RuleDelayed`, `SHCHcy`, `SHcy`, `SOFTcy`, `Sacute`, `Sc`, `Scaron`,
`Scedil`, `Scirc`, `Scy`, `Sfr`, `ShortDownArrow`, `ShortLeftArrow`,
`ShortRightArrow`, `ShortUpArrow`, `Sigma`, `SmallCircle`, `Sopf`, `Sqrt`,
`Square`, `SquareIntersection`, `SquareSubset`, `SquareSubsetEqual`,
`SquareSuperset`, `SquareSupersetEqual`, `SquareUnion`, `Sscr`, `Star`, `Sub`,
`Subset`, `SubsetEqual`, `Succeeds`, `SucceedsEqual`, `SucceedsSlantEqual`,
`SucceedsTilde`, `SuchThat`, `Sum`, `Sup`, `Superset`, `SupersetEqual`,
`Supset`, `THOR`, `THORN`, `TRADE`, `TSHcy`, `TScy`, `Tab`, `Tau`, `Tcaron`,
`Tcedil`, `Tcy`, `Tfr`, `Therefore`, `Theta`, `ThickSpace`, `ThinSpace`,
`Tilde`, `TildeEqual`, `TildeFullEqual`, `TildeTilde`, `Topf`, `TripleDot`,
`Tscr`, `Tstrok`, `Uacut`, `Uacute`, `Uarr`, `Uarrocir`, `Ubrcy`, `Ubreve`,
`Ucir`, `Ucirc`, `Ucy`, `Udblac`, `Ufr`, `Ugrav`, `Ugrave`, `Umacr`, `UnderBar`,
`UnderBrace`, `UnderBracket`, `UnderParenthesis`, `Union`, `UnionPlus`, `Uogon`,
`Uopf`, `UpArrow`, `UpArrowBar`, `UpArrowDownArrow`, `UpDownArrow`,
`UpEquilibrium`, `UpTee`, `UpTeeArrow`, `Uparrow`, `Updownarrow`,
`UpperLeftArrow`, `UpperRightArrow`, `Upsi`, `Upsilon`, `Uring`, `Uscr`,
`Utilde`, `Uum`, `Uuml`, `VDash`, `Vbar`, `Vcy`, `Vdash`, `Vdashl`, `Vee`,
`Verbar`, `Vert`, `VerticalBar`, `VerticalLine`, `VerticalSeparator`,
`VerticalTilde`, `VeryThinSpace`, `Vfr`, `Vopf`, `Vscr`, `Vvdash`, `Wcirc`,
`Wedge`, `Wfr`, `Wopf`, `Wscr`, `Xfr`, `Xi`, `Xopf`, `Xscr`, `YAcy`, `YIcy`,
`YUcy`, `Yacut`, `Yacute`, `Ycirc`, `Ycy`, `Yfr`, `Yopf`, `Yscr`, `Yuml`,
`ZHcy`, `Zacute`, `Zcaron`, `Zcy`, `Zdot`, `ZeroWidthSpace`, `Zeta`, `Zfr`,
`Zopf`, `Zscr`, `aacut`, `aacute`, `abreve`, `ac`, `acE`, `acd`, `acir`,
`acirc`, `acut`, `acute`, `acy`, `aeli`, `aelig`, `af`, `afr`, `agrav`,
`agrave`, `alefsym`, `aleph`, `alpha`, `am`, `amacr`, `amalg`, `amp`, `and`,
`andand`, `andd`, `andslope`, `andv`, `ang`, `ange`, `angle`, `angmsd`,
`angmsdaa`, `angmsdab`, `angmsdac`, `angmsdad`, `angmsdae`, `angmsdaf`,
`angmsdag`, `angmsdah`, `angrt`, `angrtvb`, `angrtvbd`, `angsph`, `angst`,
`angzarr`, `aogon`, `aopf`, `ap`, `apE`, `apacir`, `ape`, `apid`, `apos`,
`approx`, `approxeq`, `arin`, `aring`, `ascr`, `ast`, `asymp`, `asympeq`,
`atild`, `atilde`, `aum`, `auml`, `awconint`, `awint`, `bNot`, `backcong`,
`backepsilon`, `backprime`, `backsim`, `backsimeq`, `barvee`, `barwed`,
`barwedge`, `bbrk`, `bbrktbrk`, `bcong`, `bcy`, `bdquo`, `becaus`, `because`,
`bemptyv`, `bepsi`, `bernou`, `beta`, `beth`, `between`, `bfr`, `bigcap`,
`bigcirc`, `bigcup`, `bigodot`, `bigoplus`, `bigotimes`, `bigsqcup`, `bigstar`,
`bigtriangledown`, `bigtriangleup`, `biguplus`, `bigvee`, `bigwedge`, `bkarow`,
`blacklozenge`, `blacksquare`, `blacktriangle`, `blacktriangledown`,
`blacktriangleleft`, `blacktriangleright`, `blank`, `blk12`, `blk14`, `blk34`,
`block`, `bne`, `bnequiv`, `bnot`, `bopf`, `bot`, `bottom`, `bowtie`, `boxDL`,
`boxDR`, `boxDl`, `boxDr`, `boxH`, `boxHD`, `boxHU`, `boxHd`, `boxHu`, `boxUL`,
`boxUR`, `boxUl`, `boxUr`, `boxV`, `boxVH`, `boxVL`, `boxVR`, `boxVh`, `boxVl`,
`boxVr`, `boxbox`, `boxdL`, `boxdR`, `boxdl`, `boxdr`, `boxh`, `boxhD`, `boxhU`,
`boxhd`, `boxhu`, `boxminus`, `boxplus`, `boxtimes`, `boxuL`, `boxuR`, `boxul`,
`boxur`, `boxv`, `boxvH`, `boxvL`, `boxvR`, `boxvh`, `boxvl`, `boxvr`, `bprime`,
`breve`, `brvba`, `brvbar`, `bscr`, `bsemi`, `bsim`, `bsime`, `bsol`, `bsolb`,
`bsolhsub`, `bull`, `bullet`, `bump`, `bumpE`, `bumpe`, `bumpeq`, `cacute`,
`cap`, `capand`, `capbrcup`, `capcap`, `capcup`, `capdot`, `caps`, `caret`,
`caron`, `ccaps`, `ccaron`, `ccedi`, `ccedil`, `ccirc`, `ccups`, `ccupssm`,
`cdot`, `cedi`, `cedil`, `cemptyv`, `cen`, `cent`, `centerdot`, `cfr`, `chcy`,
`check`, `checkmark`, `chi`, `cir`, `cirE`, `circ`, `circeq`, `circlearrowleft`,
`circlearrowright`, `circledR`, `circledS`, `circledast`, `circledcirc`,
`circleddash`, `cire`, `cirfnint`, `cirmid`, `cirscir`, `clubs`, `clubsuit`,
`colon`, `colone`, `coloneq`, `comma`, `commat`, `comp`, `compfn`, `complement`,
`complexes`, `cong`, `congdot`, `conint`, `cop`, `copf`, `coprod`, `copy`,
`copysr`, `crarr`, `cross`, `cscr`, `csub`, `csube`, `csup`, `csupe`, `ctdot`,
`cudarrl`, `cudarrr`, `cuepr`, `cuesc`, `cularr`, `cularrp`, `cup`, `cupbrcap`,
`cupcap`, `cupcup`, `cupdot`, `cupor`, `cups`, `curarr`, `curarrm`,
`curlyeqprec`, `curlyeqsucc`, `curlyvee`, `curlywedge`, `curre`, `curren`,
`curvearrowleft`, `curvearrowright`, `cuvee`, `cuwed`, `cwconint`, `cwint`,
`cylcty`, `dArr`, `dHar`, `dagger`, `daleth`, `darr`, `dash`, `dashv`,
`dbkarow`, `dblac`, `dcaron`, `dcy`, `dd`, `ddagger`, `ddarr`, `ddotseq`, `de`,
`deg`, `delta`, `demptyv`, `dfisht`, `dfr`, `dharl`, `dharr`, `diam`, `diamond`,
`diamondsuit`, `diams`, `die`, `digamma`, `disin`, `div`, `divid`, `divide`,
`divideontimes`, `divonx`, `djcy`, `dlcorn`, `dlcrop`, `dollar`, `dopf`, `dot`,
`doteq`, `doteqdot`, `dotminus`, `dotplus`, `dotsquare`, `doublebarwedge`,
`downarrow`, `downdownarrows`, `downharpoonleft`, `downharpoonright`, `drbkarow`,
`drcorn`, `drcrop`, `dscr`, `dscy`, `dsol`, `dstrok`, `dtdot`, `dtri`, `dtrif`,
`duarr`, `duhar`, `dwangle`, `dzcy`, `dzigrarr`, `eDDot`, `eDot`, `eacut`,
`eacute`, `easter`, `ecaron`, `ecir`, `ecir`, `ecirc`, `ecolon`, `ecy`, `edot`,
`ee`, `efDot`, `efr`, `eg`, `egrav`, `egrave`, `egs`, `egsdot`, `el`,
`elinters`, `ell`, `els`, `elsdot`, `emacr`, `empty`, `emptyset`, `emptyv`,
`emsp`, `emsp13`, `emsp14`, `eng`, `ensp`, `eogon`, `eopf`, `epar`, `eparsl`,
`eplus`, `epsi`, `epsilon`, `epsiv`, `eqcirc`, `eqcolon`, `eqsim`, `eqslantgtr`,
`eqslantless`, `equals`, `equest`, `equiv`, `equivDD`, `eqvparsl`, `erDot`,
`erarr`, `escr`, `esdot`, `esim`, `et`, `eta`, `eth`, `eum`, `euml`, `euro`,
`excl`, `exist`, `expectation`, `exponentiale`, `fallingdotseq`, `fcy`,
`female`, `ffilig`, `fflig`, `ffllig`, `ffr`, `filig`, `fjlig`, `flat`, `fllig`,
`fltns`, `fnof`, `fopf`, `forall`, `fork`, `forkv`, `fpartint`, `frac1`,
`frac1`, `frac12`, `frac13`, `frac14`, `frac15`, `frac16`, `frac18`, `frac23`,
`frac25`, `frac3`, `frac34`, `frac35`, `frac38`, `frac45`, `frac56`, `frac58`,
`frac78`, `frasl`, `frown`, `fscr`, `g`, `gE`, `gEl`, `gacute`, `gamma`,
`gammad`, `gap`, `gbreve`, `gcirc`, `gcy`, `gdot`, `ge`, `gel`, `geq`, `geqq`,
`geqslant`, `ges`, `gescc`, `gesdot`, `gesdoto`, `gesdotol`, `gesl`, `gesles`,
`gfr`, `gg`, `ggg`, `gimel`, `gjcy`, `gl`, `glE`, `gla`, `glj`, `gnE`, `gnap`,
`gnapprox`, `gne`, `gneq`, `gneqq`, `gnsim`, `gopf`, `grave`, `gscr`, `gsim`,
`gsime`, `gsiml`, `gt`, `gtcc`, `gtcir`, `gtdot`, `gtlPar`, `gtquest`,
`gtrapprox`, `gtrarr`, `gtrdot`, `gtreqless`, `gtreqqless`, `gtrless`, `gtrsim`,
`gvertneqq`, `gvnE`, `hArr`, `hairsp`, `half`, `hamilt`, `hardcy`, `harr`,
`harrcir`, `harrw`, `hbar`, `hcirc`, `hearts`, `heartsuit`, `hellip`, `hercon`,
`hfr`, `hksearow`, `hkswarow`, `hoarr`, `homtht`, `hookleftarrow`,
`hookrightarrow`, `hopf`, `horbar`, `hscr`, `hslash`, `hstrok`, `hybull`,
`hyphen`, `iacut`, `iacute`, `ic`, `icir`, `icirc`, `icy`, `iecy`, `iexc`,
`iexcl`, `iff`, `ifr`, `igrav`, `igrave`, `ii`, `iiiint`, `iiint`, `iinfin`,
`iiota`, `ijlig`, `imacr`, `image`, `imagline`, `imagpart`, `imath`, `imof`,
`imped`, `in`, `incare`, `infin`, `infintie`, `inodot`, `int`, `intcal`,
`integers`, `intercal`, `intlarhk`, `intprod`, `iocy`, `iogon`, `iopf`, `iota`,
`iprod`, `iques`, `iquest`, `iscr`, `isin`, `isinE`, `isindot`, `isins`,
`isinsv`, `isinv`, `it`, `itilde`, `iukcy`, `ium`, `iuml`, `jcirc`, `jcy`,
`jfr`, `jmath`, `jopf`, `jscr`, `jsercy`, `jukcy`, `kappa`, `kappav`, `kcedil`,
`kcy`, `kfr`, `kgreen`, `khcy`, `kjcy`, `kopf`, `kscr`, `l`, `lAarr`, `lArr`,
`lAtail`, `lBarr`, `lE`, `lEg`, `lHar`, `lacute`, `laemptyv`, `lagran`,
`lambda`, `lang`, `langd`, `langle`, `lap`, `laqu`, `laquo`, `larr`, `larrb`,
`larrbfs`, `larrfs`, `larrhk`, `larrlp`, `larrpl`, `larrsim`, `larrtl`, `lat`,
`latail`, `late`, `lates`, `lbarr`, `lbbrk`, `lbrace`, `lbrack`, `lbrke`,
`lbrksld`, `lbrkslu`, `lcaron`, `lcedil`, `lceil`, `lcub`, `lcy`, `ldca`,
`ldquo`, `ldquor`, `ldrdhar`, `ldrushar`, `ldsh`, `le`, `leftarrow`,
`leftarrowtail`, `leftharpoondown`, `leftharpoonup`, `leftleftarrows`,
`leftrightarrow`, `leftrightarrows`, `leftrightharpoons`, `leftrightsquigarrow`,
`leftthreetimes`, `leg`, `leq`, `leqq`, `leqslant`, `les`, `lescc`, `lesdot`,
`lesdoto`, `lesdotor`, `lesg`, `lesges`, `lessapprox`, `lessdot`, `lesseqgtr`,
`lesseqqgtr`, `lessgtr`, `lesssim`, `lfisht`, `lfloor`, `lfr`, `lg`, `lgE`,
`lhard`, `lharu`, `lharul`, `lhblk`, `ljcy`, `ll`, `llarr`, `llcorner`,
`llhard`, `lltri`, `lmidot`, `lmoust`, `lmoustache`, `lnE`, `lnap`, `lnapprox`,
`lne`, `lneq`, `lneqq`, `lnsim`, `loang`, `loarr`, `lobrk`, `longleftarrow`,
`longleftrightarrow`, `longmapsto`, `longrightarrow`, `looparrowleft`,
`looparrowright`, `lopar`, `lopf`, `loplus`, `lotimes`, `lowast`, `lowbar`,
`loz`, `lozenge`, `lozf`, `lpar`, `lparlt`, `lrarr`, `lrcorner`, `lrhar`,
`lrhard`, `lrm`, `lrtri`, `lsaquo`, `lscr`, `lsh`, `lsim`, `lsime`, `lsimg`,
`lsqb`, `lsquo`, `lsquor`, `lstrok`, `lt`, `ltcc`, `ltcir`, `ltdot`, `lthree`,
`ltimes`, `ltlarr`, `ltquest`, `ltrPar`, `ltri`, `ltrie`, `ltrif`, `lurdshar`,
`luruhar`, `lvertneqq`, `lvnE`, `mDDot`, `mac`, `macr`, `male`, `malt`,
`maltese`, `map`, `mapsto`, `mapstodown`, `mapstoleft`, `mapstoup`, `marker`,
`mcomma`, `mcy`, `mdash`, `measuredangle`, `mfr`, `mho`, `micr`, `micro`,
`mid`, `midast`, `midcir`, `middo`, `middot`, `minus`, `minusb`, `minusd`,
`minusdu`, `mlcp`, `mldr`, `mnplus`, `models`, `mopf`, `mp`, `mscr`, `mstpos`,
`mu`, `multimap`, `mumap`, `nGg`, `nGt`, `nGtv`, `nLeftarrow`,
`nLeftrightarrow`, `nLl`, `nLt`, `nLtv`, `nRightarrow`, `nVDash`, `nVdash`,
`nabla`, `nacute`, `nang`, `nap`, `napE`, `napid`, `napos`, `napprox`, `natur`,
`natural`, `naturals`, `nbs`, `nbsp`, `nbump`, `nbumpe`, `ncap`, `ncaron`,
`ncedil`, `ncong`, `ncongdot`, `ncup`, `ncy`, `ndash`, `ne`, `neArr`, `nearhk`,
`nearr`, `nearrow`, `nedot`, `nequiv`, `nesear`, `nesim`, `nexist`, `nexists`,
`nfr`, `ngE`, `nge`, `ngeq`, `ngeqq`, `ngeqslant`, `nges`, `ngsim`, `ngt`,
`ngtr`, `nhArr`, `nharr`, `nhpar`, `ni`, `nis`, `nisd`, `niv`, `njcy`, `nlArr`,
`nlE`, `nlarr`, `nldr`, `nle`, `nleftarrow`, `nleftrightarrow`, `nleq`,
`nleqq`, `nleqslant`, `nles`, `nless`, `nlsim`, `nlt`, `nltri`, `nltrie`,
`nmid`, `no`, `nopf`, `not`, `notin`, `notinE`, `notindot`, `notinva`,
`notinvb`, `notinvc`, `notni`, `notniva`, `notnivb`, `notnivc`, `npar`,
`nparallel`, `nparsl`, `npart`, `npolint`, `npr`, `nprcue`, `npre`, `nprec`,
`npreceq`, `nrArr`, `nrarr`, `nrarrc`, `nrarrw`, `nrightarrow`, `nrtri`,
`nrtrie`, `nsc`, `nsccue`, `nsce`, `nscr`, `nshortmid`, `nshortparallel`,
`nsim`, `nsime`, `nsimeq`, `nsmid`, `nspar`, `nsqsube`, `nsqsupe`, `nsub`,
`nsubE`, `nsube`, `nsubset`, `nsubseteq`, `nsubseteqq`, `nsucc`, `nsucceq`,
`nsup`, `nsupE`, `nsupe`, `nsupset`, `nsupseteq`, `nsupseteqq`, `ntgl`, `ntild`,
`ntilde`, `ntlg`, `ntriangleleft`, `ntrianglelefteq`, `ntriangleright`,
`ntrianglerighteq`, `nu`, `num`, `numero`, `numsp`, `nvDash`, `nvHarr`, `nvap`,
`nvdash`, `nvge`, `nvgt`, `nvinfin`, `nvlArr`, `nvle`, `nvlt`, `nvltrie`,
`nvrArr`, `nvrtrie`, `nvsim`, `nwArr`, `nwarhk`, `nwarr`, `nwarrow`, `nwnear`,
`oS`, `oacut`, `oacute`, `oast`, `ocir`, `ocir`, `ocirc`, `ocy`, `odash`,
`odblac`, `odiv`, `odot`, `odsold`, `oelig`, `ofcir`, `ofr`, `ogon`, `ograv`,
`ograve`, `ogt`, `ohbar`, `ohm`, `oint`, `olarr`, `olcir`, `olcross`, `oline`,
`olt`, `omacr`, `omega`, `omicron`, `omid`, `ominus`, `oopf`, `opar`, `operp`,
`oplus`, `or`, `orarr`, `ord`, `ord`, `ord`, `order`, `orderof`, `ordf`, `ordm`,
`origof`, `oror`, `orslope`, `orv`, `oscr`, `oslas`, `oslash`, `osol`, `otild`,
`otilde`, `otimes`, `otimesas`, `oum`, `ouml`, `ovbar`, `par`, `par`, `para`,
`parallel`, `parsim`, `parsl`, `part`, `pcy`, `percnt`, `period`, `permil`,
`perp`, `pertenk`, `pfr`, `phi`, `phiv`, `phmmat`, `phone`, `pi`, `pitchfork`,
`piv`, `planck`, `planckh`, `plankv`, `plus`, `plusacir`, `plusb`, `pluscir`,
`plusdo`, `plusdu`, `pluse`, `plusm`, `plusmn`, `plussim`, `plustwo`, `pm`,
`pointint`, `popf`, `poun`, `pound`, `pr`, `prE`, `prap`, `prcue`, `pre`,
`prec`, `precapprox`, `preccurlyeq`, `preceq`, `precnapprox`, `precneqq`,
`precnsim`, `precsim`, `prime`, `primes`, `prnE`, `prnap`, `prnsim`, `prod`,
`profalar`, `profline`, `profsurf`, `prop`, `propto`, `prsim`, `prurel`, `pscr`,
`psi`, `puncsp`, `qfr`, `qint`, `qopf`, `qprime`, `qscr`, `quaternions`,
`quatint`, `quest`, `questeq`, `quo`, `quot`, `rAarr`, `rArr`, `rAtail`,
`rBarr`, `rHar`, `race`, `racute`, `radic`, `raemptyv`, `rang`, `rangd`,
`range`, `rangle`, `raqu`, `raquo`, `rarr`, `rarrap`, `rarrb`, `rarrbfs`,
`rarrc`, `rarrfs`, `rarrhk`, `rarrlp`, `rarrpl`, `rarrsim`, `rarrtl`, `rarrw`,
`ratail`, `ratio`, `rationals`, `rbarr`, `rbbrk`, `rbrace`, `rbrack`, `rbrke`,
`rbrksld`, `rbrkslu`, `rcaron`, `rcedil`, `rceil`, `rcub`, `rcy`, `rdca`,
`rdldhar`, `rdquo`, `rdquor`, `rdsh`, `re`, `real`, `realine`, `realpart`,
`reals`, `rect`, `reg`, `rfisht`, `rfloor`, `rfr`, `rhard`, `rharu`, `rharul`,
`rho`, `rhov`, `rightarrow`, `rightarrowtail`, `rightharpoondown`,
`rightharpoonup`, `rightleftarrows`, `rightleftharpoons`, `rightrightarrows`,
`rightsquigarrow`, `rightthreetimes`, `ring`, `risingdotseq`, `rlarr`, `rlhar`,
`rlm`, `rmoust`, `rmoustache`, `rnmid`, `roang`, `roarr`, `robrk`, `ropar`,
`ropf`, `roplus`, `rotimes`, `rpar`, `rpargt`, `rppolint`, `rrarr`, `rsaquo`,
`rscr`, `rsh`, `rsqb`, `rsquo`, `rsquor`, `rthree`, `rtimes`, `rtri`, `rtrie`,
`rtrif`, `rtriltri`, `ruluhar`, `rx`, `sacute`, `sbquo`, `sc`, `scE`, `scap`,
`scaron`, `sccue`, `sce`, `scedil`, `scirc`, `scnE`, `scnap`, `scnsim`,
`scpolint`, `scsim`, `scy`, `sdot`, `sdotb`, `sdote`, `seArr`, `searhk`,
`searr`, `searrow`, `sec`, `sect`, `semi`, `seswar`, `setminus`, `setmn`,
`sext`, `sfr`, `sfrown`, `sh`, `sharp`, `shchcy`, `shcy`, `shortmid`,
`shortparallel`, `shy`, `sigma`, `sigmaf`, `sigmav`, `sim`, `simdot`, `sime`,
`simeq`, `simg`, `simgE`, `siml`, `simlE`, `simne`, `simplus`, `simrarr`,
`slarr`, `smallsetminus`, `smashp`, `smeparsl`, `smid`, `smile`, `smt`, `smte`,
`smtes`, `softcy`, `sol`, `solb`, `solbar`, `sopf`, `spades`, `spadesuit`,
`spar`, `sqcap`, `sqcaps`, `sqcup`, `sqcups`, `sqsub`, `sqsube`, `sqsubset`,
`sqsubseteq`, `sqsup`, `sqsupe`, `sqsupset`, `sqsupseteq`, `squ`, `square`,
`squarf`, `squf`, `srarr`, `sscr`, `ssetmn`, `ssmile`, `sstarf`, `star`,
`starf`, `straightepsilon`, `straightphi`, `strns`, `sub`, `subE`, `subdot`,
`sube`, `subedot`, `submult`, `subnE`, `subne`, `subplus`, `subrarr`, `subset`,
`subseteq`, `subseteqq`, `subsetneq`, `subsetneqq`, `subsim`, `subsub`,
`subsup`, `succ`, `succapprox`, `succcurlyeq`, `succeq`, `succnapprox`,
`succneqq`, `succnsim`, `succsim`, `sum`, `sung`, `sup`, `sup`, `sup`, `sup`,
`sup1`, `sup2`, `sup3`, `supE`, `supdot`, `supdsub`, `supe`, `supedot`,
`suphsol`, `suphsub`, `suplarr`, `supmult`, `supnE`, `supne`, `supplus`,
`supset`, `supseteq`, `supseteqq`, `supsetneq`, `supsetneqq`, `supsim`,
`supsub`, `supsup`, `swArr`, `swarhk`, `swarr`, `swarrow`, `swnwar`, `szli`,
`szlig`, `target`, `tau`, `tbrk`, `tcaron`, `tcedil`, `tcy`, `tdot`, `telrec`,
`tfr`, `there4`, `therefore`, `theta`, `thetasym`, `thetav`, `thickapprox`,
`thicksim`, `thinsp`, `thkap`, `thksim`, `thor`, `thorn`, `tilde`, `time`,
`times`, `timesb`, `timesbar`, `timesd`, `tint`, `toea`, `top`, `topbot`,
`topcir`, `topf`, `topfork`, `tosa`, `tprime`, `trade`, `triangle`,
`triangledown`, `triangleleft`, `trianglelefteq`, `triangleq`, `triangleright`,
`trianglerighteq`, `tridot`, `trie`, `triminus`, `triplus`, `trisb`, `tritime`,
`trpezium`, `tscr`, `tscy`, `tshcy`, `tstrok`, `twixt`, `twoheadleftarrow`,
`twoheadrightarrow`, `uArr`, `uHar`, `uacut`, `uacute`, `uarr`, `ubrcy`,
`ubreve`, `ucir`, `ucirc`, `ucy`, `udarr`, `udblac`, `udhar`, `ufisht`, `ufr`,
`ugrav`, `ugrave`, `uharl`, `uharr`, `uhblk`, `ulcorn`, `ulcorner`, `ulcrop`,
`ultri`, `um`, `umacr`, `uml`, `uogon`, `uopf`, `uparrow`, `updownarrow`,
`upharpoonleft`, `upharpoonright`, `uplus`, `upsi`, `upsih`, `upsilon`,
`upuparrows`, `urcorn`, `urcorner`, `urcrop`, `uring`, `urtri`, `uscr`, `utdot`,
`utilde`, `utri`, `utrif`, `uuarr`, `uum`, `uuml`, `uwangle`, `vArr`, `vBar`,
`vBarv`, `vDash`, `vangrt`, `varepsilon`, `varkappa`, `varnothing`, `varphi`,
`varpi`, `varpropto`, `varr`, `varrho`, `varsigma`, `varsubsetneq`,
`varsubsetneqq`, `varsupsetneq`, `varsupsetneqq`, `vartheta`, `vartriangleleft`,
`vartriangleright`, `vcy`, `vdash`, `vee`, `veebar`, `veeeq`, `vellip`,
`verbar`, `vert`, `vfr`, `vltri`, `vnsub`, `vnsup`, `vopf`, `vprop`, `vrtri`,
`vscr`, `vsubnE`, `vsubne`, `vsupnE`, `vsupne`, `vzigzag`, `wcirc`, `wedbar`,
`wedge`, `wedgeq`, `weierp`, `wfr`, `wopf`, `wp`, `wr`, `wreath`, `wscr`,
`xcap`, `xcirc`, `xcup`, `xdtri`, `xfr`, `xhArr`, `xharr`, `xi`, `xlArr`,
`xlarr`, `xmap`, `xnis`, `xodot`, `xopf`, `xoplus`, `xotime`, `xrArr`, `xrarr`,
`xscr`, `xsqcup`, `xuplus`, `xutri`, `xvee`, `xwedge`, `yacut`, `yacute`,
`yacy`, `ycirc`, `ycy`, `ye`, `yen`, `yfr`, `yicy`, `yopf`, `yscr`, `yucy`,
`yum`, `yuml`, `zacute`, `zcaron`, `zcy`, `zdot`, `zeetrf`, `zeta`, `zfr`,
`zhcy`, `zigrarr`, `zopf`, `zscr`, `zwj`, or `zwnj`.

## References

*   **\[HTML]**:
    [HTML Standard](https://html.spec.whatwg.org/multipage/).
    A. van Kesteren, et al.
    WHATWG.
*   **\[RFC20]**:
    [ASCII format for network interchange](https://tools.ietf.org/html/rfc20).
    V.G. Cerf.
    October 1969.
    IETF.
*   **\[RFC5322]**:
    [Internet Message Format](https://tools.ietf.org/html/rfc5322).
    P. Resnick.
    IETF.
*   **\[UNICODE]**:
    [The Unicode Standard](https://www.unicode.org/versions/).
    Unicode Consortium.

## Acknowledgments

Thanks to John Gruber for inventing Markdown.

Thanks to John MacFarlane for defining CommonMark.

Thanks to ZEIT, Inc., Gatsby, Inc., Netlify, Inc., Holloway, Inc., and the many
organizations and individuals for financial support through
[OpenCollective](https://opencollective.com/unified)

## License

Copyright © 2019 Titus Wormer.
This work is licensed under a
[Creative Commons Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/).