Add support for definitions

*   Add definitions
*   Add partials for label, destination, title
*   Add `go`, to attempt something, and do something else on `ok`

5 files changed, 714 insertions, 2 deletions

diff --git a/src/construct/definition.rs b/src/construct/definition.rs
new file mode 100644
index 0000000..e540b44
--- /dev/null
+++ b/src/construct/definition.rs
@@ -0,0 +1,318 @@
+//! Definition is a construct that occurs in the [flow] content type.
+//!
+//! They’re formed with the following BNF:
+//!
+//! ```bnf
+//! definition ::= label ':' whitespace destination [ whitespace title ] [ space_or_tab ]
+//!
+//! ; Restriction: maximum `999` codes allowed between brackets.
+//! ; Restriction: no blank lines.
+//! ; Restriction: at least 1 non-space and non-eol code must exist.
+//! label ::= '[' *( label_text | label_escape ) ']'
+//! label_text ::= code - '[' - '\\' - ']'
+//! label_escape ::= '\\' [ '[' | '\\' | ']' ]
+//!
+//! destination ::= destination_enclosed | destination_raw
+//! destination_enclosed ::= '<' *( destination_enclosed_text | destination_enclosed_escape ) '>'
+//! destination_enclosed_text ::= code - '<' - '\\' - eol
+//! destination_enclosed_escape ::= '\\' [ '<' | '\\' | '>' ]
+//! destination_raw ::= 1*( destination_raw_text | destination_raw_escape )
+//! ; Restriction: unbalanced `)` characters are not allowed.
+//! destination_raw_text ::= code - '\\' - ascii_control - space_or_tab - eol
+//! destination_raw_escape ::= '\\' [ '(' | ')' | '\\' ]
+//!
+//! ; Restriction: no blank lines.
+//! ; Restriction: markers must match (in case of `(` with `)`).
+//! title ::= marker [  *( code - '\\' | '\\' [ marker ] ) ] marker
+//! marker ::= '"' | '\'' | '('
+//!
+//! whitespace ::= eol *whitespace | 1*space_or_tab [ eol *whitespace ]
+//! space_or_tab ::= ' ' | '\t'
+//! ```
+//!
+//! Definitions in markdown to not, on their own, relate to anything in HTML.
+//! When connected with a link (reference), they together relate to the `<a>`
+//! element in HTML.
+//! The definition forms its `href`, and optionally `title`, attributes.
+//! See [*§ 4.5.1 The `a` element*][html] in the HTML spec for more info.
+//!
+//! The `label`, `destination`, and `title` parts are interpreted as the
+//! [string][] content type.
+//! That means that character escapes and character reference are allowed.
+//!
+//! ## References
+//!
+//! *   [`definition.js` in `micromark`](https://github.com/micromark/micromark/blob/main/packages/micromark-core-commonmark/dev/lib/definition.js)
+//! *   [*§ 4.7 Link reference definitions* in `CommonMark`](https://spec.commonmark.org/0.30/#link-reference-definitions)
+//!
+//! [flow]: crate::content::flow
+//! [string]: crate::content::string
+//! [html]: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-a-element
+//!
+//! <!-- To do: link link (reference) -->
+//!
+//! <!-- To do: describe how references and definitions match -->
+
+use crate::construct::{
+    partial_destination::start as destination, partial_label::start as label,
+    partial_title::start as title, partial_whitespace::start as whitespace,
+};
+use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer};
+
+/// At the start of a definition.
+///
+/// ```markdown
+/// |[a]: b "c"
+/// ```
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::Char('[') => {
+            tokenizer.enter(TokenType::Definition);
+            tokenizer.go(label, label_after)(tokenizer, code)
+        }
+        _ => (State::Nok, None),
+    }
+}
+
+/// After the label of a definition.
+///
+/// ```markdown
+/// [a]|: b "c"
+/// ```
+pub fn label_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    // To do: get the identifier:
+    // identifier = normalizeIdentifier(
+    //   self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
+    // )
+
+    match code {
+        Code::Char(':') => {
+            tokenizer.enter(TokenType::DefinitionMarker);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::DefinitionMarker);
+            (State::Fn(Box::new(marker_after)), None)
+        }
+        _ => (State::Nok, None),
+    }
+}
+
+/// After the marker of a definition.
+///
+/// ```markdown
+/// [a]:| b "c"
+///
+/// [a]:| ␊
+///  b "c"
+/// ```
+pub fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(marker_after_optional_whitespace),
+    )(tokenizer, code)
+}
+
+/// After the marker, after whitespace.
+///
+/// ```markdown
+/// [a]: |b "c"
+///
+/// [a]: |␊
+///  b "c"
+/// ```
+pub fn marker_after_optional_whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            tokenizer.enter(TokenType::LineEnding);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::LineEnding);
+            (State::Fn(Box::new(marker_after_optional_line_ending)), None)
+        }
+        _ => destination_before(tokenizer, code),
+    }
+}
+
+/// After the marker, after a line ending.
+///
+/// ```markdown
+/// [a]:
+/// | b "c"
+/// ```
+pub fn marker_after_optional_line_ending(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(destination_before),
+    )(tokenizer, code)
+}
+
+/// Before a destination.
+///
+/// ```markdown
+/// [a]: |b "c"
+///
+/// [a]:
+///  |b "c"
+/// ```
+pub fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    let event = tokenizer.events.last().unwrap();
+    // Blank line not ok.
+    let char_nok = matches!(
+        code,
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n')
+    );
+
+    if !char_nok
+        && (event.token_type == TokenType::LineEnding || event.token_type == TokenType::Whitespace)
+    {
+        tokenizer.go(destination, destination_after)(tokenizer, code)
+    } else {
+        (State::Nok, None)
+    }
+}
+
+/// After a destination.
+///
+/// ```markdown
+/// [a]: b| "c"
+///
+/// [a]: b| ␊
+///  "c"
+/// ```
+pub fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    tokenizer.attempt(title_before, |_ok| Box::new(after))(tokenizer, code)
+}
+
+/// After a definition.
+///
+/// ```markdown
+/// [a]: b|
+/// [a]: b "c"|
+/// ```
+pub fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(after_whitespace),
+    )(tokenizer, code)
+}
+
+/// After a definition, after optional whitespace.
+///
+/// ```markdown
+/// [a]: b |
+/// [a]: b "c"|
+/// ```
+pub fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            tokenizer.exit(TokenType::Definition);
+            (State::Ok, Some(vec![code]))
+        }
+        _ => (State::Nok, None),
+    }
+}
+
+/// After a destination, presumably before a title.
+///
+/// ```markdown
+/// [a]: b| "c"
+///
+/// [a]: b| ␊
+///  "c"
+/// ```
+pub fn title_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(title_before_after_optional_whitespace),
+    )(tokenizer, code)
+}
+
+/// Before a title, after optional whitespace.
+///
+/// ```markdown
+/// [a]: b |"c"
+///
+/// [a]: b |␊
+///  "c"
+/// ```
+pub fn title_before_after_optional_whitespace(
+    tokenizer: &mut Tokenizer,
+    code: Code,
+) -> StateFnResult {
+    match code {
+        Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            tokenizer.enter(TokenType::LineEnding);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::LineEnding);
+            (
+                State::Fn(Box::new(title_before_after_optional_line_ending)),
+                None,
+            )
+        }
+        _ => title_before_marker(tokenizer, code),
+    }
+}
+
+/// Before a title, after a line ending.
+///
+/// ```markdown
+/// [a]: b␊
+/// | "c"
+/// ```
+pub fn title_before_after_optional_line_ending(
+    tokenizer: &mut Tokenizer,
+    code: Code,
+) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(title_before_marker),
+    )(tokenizer, code)
+}
+
+/// Before a title, after a line ending.
+///
+/// ```markdown
+/// [a]: b␊
+/// | "c"
+/// ```
+pub fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    let event = tokenizer.events.last().unwrap();
+
+    if event.token_type == TokenType::LineEnding || event.token_type == TokenType::Whitespace {
+        tokenizer.go(title, title_after)(tokenizer, code)
+    } else {
+        (State::Nok, None)
+    }
+}
+
+/// After a title.
+///
+/// ```markdown
+/// [a]: b "c"|
+///
+/// [a]: b␊
+/// "c"|
+/// ```
+pub fn title_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(title_after_after_optional_whitespace),
+    )(tokenizer, code)
+}
+
+/// After a title, after optional whitespace.
+///
+/// ```markdown
+/// [a]: b "c"|
+///
+/// [a]: b "c" |
+/// ```
+pub fn title_after_after_optional_whitespace(
+    _tokenizer: &mut Tokenizer,
+    code: Code,
+) -> StateFnResult {
+    match code {
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            (State::Ok, Some(vec![code]))
+        }
+        _ => (State::Nok, None),
+    }
+}
diff --git a/src/construct/mod.rs b/src/construct/mod.rs
index ca1149f..fb79f68 100644
--- a/src/construct/mod.rs
+++ b/src/construct/mod.rs
@@ -16,7 +16,7 @@
 //! The following constructs are found in markdown:
 //!
 //! *   attention (strong, emphasis) (text)
-//! *   [autolink][autolink]
+//! *   [autolink][]
 //! *   [blank line][blank_line]
 //! *   block quote
 //! *   [character escape][character_escape]
@@ -25,7 +25,7 @@
 //! *   [code (indented)][code_indented]
 //! *   [code (text)][code_text]
 //! *   content
-//! *   definition
+//! *   [definition][]
 //! *   [hard break (escape)][hard_break_escape]
 //! *   [hard break (trailing)][hard_break_trailing]
 //! *   [heading (atx)][heading_atx]
@@ -61,11 +61,15 @@ pub mod character_reference;
 pub mod code_fenced;
 pub mod code_indented;
 pub mod code_text;
+pub mod definition;
 pub mod hard_break_escape;
 pub mod hard_break_trailing;
 pub mod heading_atx;
 pub mod heading_setext;
 pub mod html_flow;
 pub mod html_text;
+pub mod partial_destination;
+pub mod partial_label;
+pub mod partial_title;
 pub mod partial_whitespace;
 pub mod thematic_break;
diff --git a/src/construct/partial_destination.rs b/src/construct/partial_destination.rs
new file mode 100644
index 0000000..8cf5b77
--- /dev/null
+++ b/src/construct/partial_destination.rs
@@ -0,0 +1,154 @@
+// To do: pass token types in.
+
+use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer};
+
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::Char('<') => {
+            tokenizer.enter(TokenType::DefinitionDestination);
+            tokenizer.enter(TokenType::DefinitionDestinationLiteral);
+            tokenizer.enter(TokenType::DefinitionDestinationLiteralMarker);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::DefinitionDestinationLiteralMarker);
+            (State::Fn(Box::new(enclosed_before)), None)
+        }
+        Code::None | Code::CarriageReturnLineFeed | Code::VirtualSpace | Code::Char(')') => {
+            (State::Nok, None)
+        }
+        Code::Char(char) if char.is_ascii_control() => (State::Nok, None),
+        Code::Char(_) => {
+            tokenizer.enter(TokenType::DefinitionDestination);
+            tokenizer.enter(TokenType::DefinitionDestinationRaw);
+            tokenizer.enter(TokenType::DefinitionDestinationString);
+            // To do: link.
+            tokenizer.enter(TokenType::ChunkString);
+            raw(tokenizer, code, 0)
+        }
+    }
+}
+
+/// To do.
+fn enclosed_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    if let Code::Char('>') = code {
+        tokenizer.enter(TokenType::DefinitionDestinationLiteralMarker);
+        tokenizer.consume(code);
+        tokenizer.exit(TokenType::DefinitionDestinationLiteralMarker);
+        tokenizer.exit(TokenType::DefinitionDestinationLiteral);
+        tokenizer.exit(TokenType::DefinitionDestination);
+        (State::Ok, None)
+    } else {
+        tokenizer.enter(TokenType::DefinitionDestinationString);
+        // To do: link.
+        tokenizer.enter(TokenType::ChunkString);
+        enclosed(tokenizer, code)
+    }
+}
+
+/// To do.
+fn enclosed(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::Char('>') => {
+            tokenizer.exit(TokenType::ChunkString);
+            tokenizer.exit(TokenType::DefinitionDestinationString);
+            enclosed_before(tokenizer, code)
+        }
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n' | '<') => {
+            (State::Nok, None)
+        }
+        Code::Char('\\') => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(enclosed_escape)), None)
+        }
+        _ => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(enclosed)), None)
+        }
+    }
+}
+
+/// To do.
+fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::Char('<' | '>' | '\\') => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(enclosed)), None)
+        }
+        _ => enclosed(tokenizer, code),
+    }
+}
+
+/// To do.
+// To do: these arms can be improved?
+fn raw(tokenizer: &mut Tokenizer, code: Code, balance: usize) -> StateFnResult {
+    // To do: configurable.
+    let limit = usize::MAX;
+
+    match code {
+        Code::Char('(') if balance >= limit => (State::Nok, None),
+        Code::Char('(') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| raw(t, c, balance + 1))),
+                None,
+            )
+        }
+        Code::Char(')') if balance == 0 => {
+            tokenizer.exit(TokenType::ChunkString);
+            tokenizer.exit(TokenType::DefinitionDestinationString);
+            tokenizer.exit(TokenType::DefinitionDestinationRaw);
+            tokenizer.exit(TokenType::DefinitionDestination);
+            (State::Ok, Some(vec![code]))
+        }
+        Code::Char(')') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| raw(t, c, balance - 1))),
+                None,
+            )
+        }
+        Code::None
+        | Code::CarriageReturnLineFeed
+        | Code::VirtualSpace
+        | Code::Char('\t' | '\r' | '\n' | ' ')
+            if balance > 0 =>
+        {
+            (State::Nok, None)
+        }
+        Code::None
+        | Code::CarriageReturnLineFeed
+        | Code::VirtualSpace
+        | Code::Char('\t' | '\r' | '\n' | ' ') => {
+            tokenizer.exit(TokenType::ChunkString);
+            tokenizer.exit(TokenType::DefinitionDestinationString);
+            tokenizer.exit(TokenType::DefinitionDestinationRaw);
+            tokenizer.exit(TokenType::DefinitionDestination);
+            (State::Ok, Some(vec![code]))
+        }
+        Code::Char(char) if char.is_ascii_control() => (State::Nok, None),
+        Code::Char('\\') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| raw_escape(t, c, balance))),
+                None,
+            )
+        }
+        Code::Char(_) => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(move |t, c| raw(t, c, balance))), None)
+        }
+    }
+}
+
+/// To do.
+fn raw_escape(tokenizer: &mut Tokenizer, code: Code, balance: usize) -> StateFnResult {
+    match code {
+        Code::Char('(' | ')' | '\\') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| raw(t, c, balance + 1))),
+                None,
+            )
+        }
+        _ => raw(tokenizer, code, balance),
+    }
+}
diff --git a/src/construct/partial_label.rs b/src/construct/partial_label.rs
new file mode 100644
index 0000000..c772c56
--- /dev/null
+++ b/src/construct/partial_label.rs
@@ -0,0 +1,100 @@
+// To do: pass token types in.
+
+use crate::constant::LINK_REFERENCE_SIZE_MAX;
+use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer};
+
+/// To do.
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::Char('[') => {
+            tokenizer.enter(TokenType::DefinitionLabel);
+            tokenizer.enter(TokenType::DefinitionLabelMarker);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::DefinitionLabelMarker);
+            tokenizer.enter(TokenType::DefinitionLabelData);
+            (State::Fn(Box::new(|t, c| at_break(t, c, false, 0))), None)
+        }
+        // To do: allow?
+        _ => unreachable!("expected `[` at start of label"),
+    }
+}
+
+/// To do.
+fn at_break(tokenizer: &mut Tokenizer, code: Code, data: bool, size: usize) -> StateFnResult {
+    match code {
+        Code::None | Code::Char('[') => (State::Nok, None),
+        Code::Char(']') if !data => (State::Nok, None),
+        _ if size > LINK_REFERENCE_SIZE_MAX => (State::Nok, None),
+        Code::Char(']') => {
+            tokenizer.exit(TokenType::DefinitionLabelData);
+            tokenizer.enter(TokenType::DefinitionLabelMarker);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::DefinitionLabelMarker);
+            tokenizer.exit(TokenType::DefinitionLabel);
+            (State::Ok, None)
+        }
+        Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            tokenizer.enter(TokenType::LineEnding);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::LineEnding);
+            (
+                State::Fn(Box::new(move |t, c| at_break(t, c, data, size))),
+                None,
+            )
+        }
+        _ => {
+            tokenizer.enter(TokenType::ChunkString);
+            // To do: link.
+            label(tokenizer, code, data, size)
+        }
+    }
+}
+
+/// To do.
+fn label(tokenizer: &mut Tokenizer, code: Code, data: bool, size: usize) -> StateFnResult {
+    match code {
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n' | '[' | ']') => {
+            tokenizer.exit(TokenType::ChunkString);
+            at_break(tokenizer, code, data, size)
+        }
+        _ if size > LINK_REFERENCE_SIZE_MAX => {
+            tokenizer.exit(TokenType::ChunkString);
+            at_break(tokenizer, code, data, size)
+        }
+        Code::VirtualSpace | Code::Char('\t' | ' ') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| label(t, c, data, size + 1))),
+                None,
+            )
+        }
+        Code::Char('/') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| escape(t, c, true, size + 1))),
+                None,
+            )
+        }
+        Code::Char(_) => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| label(t, c, true, size + 1))),
+                None,
+            )
+        }
+    }
+}
+
+/// To do.
+fn escape(tokenizer: &mut Tokenizer, code: Code, data: bool, size: usize) -> StateFnResult {
+    match code {
+        Code::Char('[' | '\\' | ']') => {
+            tokenizer.consume(code);
+            (
+                State::Fn(Box::new(move |t, c| label(t, c, true, size + 1))),
+                None,
+            )
+        }
+        _ => label(tokenizer, code, data, size),
+    }
+}
diff --git a/src/construct/partial_title.rs b/src/construct/partial_title.rs
new file mode 100644
index 0000000..4c7b527
--- /dev/null
+++ b/src/construct/partial_title.rs
@@ -0,0 +1,136 @@
+// To do: pass token types in.
+
+use crate::construct::partial_whitespace::start as whitespace;
+use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer};
+
+/// Type of quote, if we’re in an attribure, in complete (condition 7).
+#[derive(Debug, Clone, PartialEq)]
+enum TitleKind {
+    /// In a parenthesised (`(` and `)`) title.
+    Paren,
+    /// In a double quoted (`"`) title.
+    Double,
+    /// In a single quoted (`"`) title.
+    Single,
+}
+
+fn kind_to_marker(kind: &TitleKind) -> char {
+    match kind {
+        TitleKind::Double => '"',
+        TitleKind::Single => '\'',
+        TitleKind::Paren => ')',
+    }
+}
+
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    let kind = match code {
+        Code::Char('"') => Some(TitleKind::Double),
+        Code::Char('\'') => Some(TitleKind::Single),
+        Code::Char('(') => Some(TitleKind::Paren),
+        _ => None,
+    };
+
+    if let Some(kind) = kind {
+        tokenizer.enter(TokenType::DefinitionTitle);
+        tokenizer.enter(TokenType::DefinitionTitleMarker);
+        tokenizer.consume(code);
+        tokenizer.exit(TokenType::DefinitionTitleMarker);
+        (State::Fn(Box::new(|t, c| at_first_break(t, c, kind))), None)
+    } else {
+        (State::Nok, None)
+    }
+}
+
+/// To do.
+fn at_first_break(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult {
+    match code {
+        Code::Char(char) if char == kind_to_marker(&kind) => {
+            tokenizer.enter(TokenType::DefinitionTitleMarker);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::DefinitionTitleMarker);
+            tokenizer.exit(TokenType::DefinitionTitle);
+            (State::Ok, None)
+        }
+        _ => {
+            tokenizer.enter(TokenType::DefinitionTitleString);
+            at_break(tokenizer, code, kind)
+        }
+    }
+}
+
+/// To do.
+fn at_break(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult {
+    match code {
+        Code::Char(char) if char == kind_to_marker(&kind) => {
+            tokenizer.exit(TokenType::DefinitionTitleString);
+            at_first_break(tokenizer, code, kind)
+        }
+        Code::None => (State::Nok, None),
+        Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            tokenizer.enter(TokenType::LineEnding);
+            tokenizer.consume(code);
+            tokenizer.exit(TokenType::LineEnding);
+            (
+                State::Fn(Box::new(|t, c| at_break_line_start(t, c, kind))),
+                None,
+            )
+        }
+        _ => {
+            // To do: link.
+            tokenizer.enter(TokenType::ChunkString);
+            title(tokenizer, code, kind)
+        }
+    }
+}
+
+fn at_break_line_start(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult {
+    tokenizer.attempt(
+        |t, c| whitespace(t, c, TokenType::Whitespace),
+        |_ok| Box::new(|t, c| at_break_line_begin(t, c, kind)),
+    )(tokenizer, code)
+}
+
+fn at_break_line_begin(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult {
+    match code {
+        // Blank line not allowed.
+        Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => (State::Nok, None),
+        _ => at_break(tokenizer, code, kind),
+    }
+}
+
+/// To do.
+fn title(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult {
+    match code {
+        Code::Char(char) if char == kind_to_marker(&kind) => {
+            tokenizer.exit(TokenType::ChunkString);
+            at_break(tokenizer, code, kind)
+        }
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => {
+            tokenizer.exit(TokenType::ChunkString);
+            at_break(tokenizer, code, kind)
+        }
+        Code::Char('\\') => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(|t, c| escape(t, c, kind))), None)
+        }
+        _ => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(|t, c| title(t, c, kind))), None)
+        }
+    }
+}
+
+/// To do.
+fn escape(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult {
+    match code {
+        Code::Char(char) if char == kind_to_marker(&kind) => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(move |t, c| title(t, c, kind))), None)
+        }
+        Code::Char('\\') => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(move |t, c| title(t, c, kind))), None)
+        }
+        _ => title(tokenizer, code, kind),
+    }
+}