Refactor to remove unneeded tuples in every states

29 files changed, 583 insertions, 781 deletions

diff --git a/src/construct/attention.rs b/src/construct/attention.rs
index 42c0965..b4265f0 100644
--- a/src/construct/attention.rs
+++ b/src/construct/attention.rs
@@ -52,7 +52,7 @@
 //! [html-strong]: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-strong-element
 
 use crate::token::Token;
-use crate::tokenizer::{Code, Event, EventType, Point, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, Event, EventType, Point, State, Tokenizer};
 use crate::unicode::PUNCTUATION;
 use crate::util::edit_map::EditMap;
 
@@ -169,13 +169,13 @@ struct Sequence {
 /// > | **
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('*' | '_') if tokenizer.parse_state.constructs.attention => {
             tokenizer.enter(Token::AttentionSequence);
             inside(tokenizer, code, MarkerKind::from_code(code))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -185,16 +185,16 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | **
 ///     ^^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, marker: MarkerKind) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code, marker: MarkerKind) -> State {
     match code {
         Code::Char(char) if char == marker.as_char() => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| inside(t, c, marker))), 0)
+            State::Fn(Box::new(move |t, c| inside(t, c, marker)))
         }
         _ => {
             tokenizer.exit(Token::AttentionSequence);
             tokenizer.register_resolver("attention".to_string(), Box::new(resolve_attention));
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
     }
 }
@@ -205,7 +205,7 @@ fn resolve_attention(tokenizer: &mut Tokenizer, map: &mut EditMap) -> bool {
     let codes = &tokenizer.parse_state.codes;
     let mut start = 0;
     let mut balance = 0;
-    let mut sequences: Vec<Sequence> = vec![];
+    let mut sequences = vec![];
 
     // Find sequences of sequences and information about them.
     while start < tokenizer.events.len() {
diff --git a/src/construct/autolink.rs b/src/construct/autolink.rs
index e8caf3b..606fc9b 100644
--- a/src/construct/autolink.rs
+++ b/src/construct/autolink.rs
@@ -103,7 +103,7 @@
 
 use crate::constant::{AUTOLINK_DOMAIN_SIZE_MAX, AUTOLINK_SCHEME_SIZE_MAX};
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of an autolink.
 ///
@@ -113,7 +113,7 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 /// > | a<user@example.com>b
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('<') if tokenizer.parse_state.constructs.autolink => {
             tokenizer.enter(Token::Autolink);
@@ -121,9 +121,9 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             tokenizer.consume(code);
             tokenizer.exit(Token::AutolinkMarker);
             tokenizer.enter(Token::AutolinkProtocol);
-            (State::Fn(Box::new(open)), 0)
+            State::Fn(Box::new(open))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -135,14 +135,14 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a<user@example.com>b
 ///       ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(char) if char.is_ascii_alphabetic() => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(scheme_or_email_atext)), 0)
+            State::Fn(Box::new(scheme_or_email_atext))
         }
         Code::Char(char) if is_ascii_atext(char) => email_atext(tokenizer, code),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -154,7 +154,7 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a<user@example.com>b
 ///        ^
 /// ```
-fn scheme_or_email_atext(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn scheme_or_email_atext(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('+' | '-' | '.' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
             scheme_inside_or_email_atext(tokenizer, code, 1)
@@ -171,26 +171,19 @@ fn scheme_or_email_atext(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult
 /// > | a<user@example.com>b
 ///        ^
 /// ```
-fn scheme_inside_or_email_atext(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    size: usize,
-) -> StateFnResult {
+fn scheme_inside_or_email_atext(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     match code {
         Code::Char(':') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(url_inside)), 0)
+            State::Fn(Box::new(url_inside))
         }
         Code::Char('+' | '-' | '.' | '0'..='9' | 'A'..='Z' | 'a'..='z')
             if size < AUTOLINK_SCHEME_SIZE_MAX =>
         {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| {
-                    scheme_inside_or_email_atext(t, c, size + 1)
-                })),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| {
+                scheme_inside_or_email_atext(t, c, size + 1)
+            }))
         }
         _ => email_atext(tokenizer, code),
     }
@@ -202,19 +195,19 @@ fn scheme_inside_or_email_atext(
 /// > | a<https://example.com>b
 ///             ^
 /// ```
-fn url_inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn url_inside(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.exit(Token::AutolinkProtocol);
             end(tokenizer, code)
         }
-        Code::Char(char) if char.is_ascii_control() => (State::Nok, 0),
+        Code::Char(char) if char.is_ascii_control() => State::Nok,
         Code::None | Code::CarriageReturnLineFeed | Code::VirtualSpace | Code::Char(' ') => {
-            (State::Nok, 0)
+            State::Nok
         }
         Code::Char(_) => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(url_inside)), 0)
+            State::Fn(Box::new(url_inside))
         }
     }
 }
@@ -225,17 +218,17 @@ fn url_inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a<user.name@example.com>b
 ///              ^
 /// ```
-fn email_atext(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn email_atext(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('@') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| email_at_sign_or_dot(t, c, 0))), 0)
+            State::Fn(Box::new(|t, c| email_at_sign_or_dot(t, c, 0)))
         }
         Code::Char(char) if is_ascii_atext(char) => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(email_atext)), 0)
+            State::Fn(Box::new(email_atext))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -245,10 +238,10 @@ fn email_atext(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a<user.name@example.com>b
 ///                 ^       ^
 /// ```
-fn email_at_sign_or_dot(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
+fn email_at_sign_or_dot(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     match code {
         Code::Char(char) if char.is_ascii_alphanumeric() => email_value(tokenizer, code, size),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -258,11 +251,11 @@ fn email_at_sign_or_dot(tokenizer: &mut Tokenizer, code: Code, size: usize) -> S
 /// > | a<user.name@example.com>b
 ///                   ^
 /// ```
-fn email_label(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
+fn email_label(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     match code {
         Code::Char('.') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| email_at_sign_or_dot(t, c, 0))), 0)
+            State::Fn(Box::new(|t, c| email_at_sign_or_dot(t, c, 0)))
         }
         Code::Char('>') => {
             let index = tokenizer.events.len();
@@ -284,23 +277,17 @@ fn email_label(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnRes
 /// > | a<user.name@ex-ample.com>b
 ///                    ^
 /// ```
-fn email_value(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
+fn email_value(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     match code {
         Code::Char('-') if size < AUTOLINK_DOMAIN_SIZE_MAX => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| email_value(t, c, size + 1))),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| email_value(t, c, size + 1)))
         }
         Code::Char(char) if char.is_ascii_alphanumeric() && size < AUTOLINK_DOMAIN_SIZE_MAX => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| email_label(t, c, size + 1))),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| email_label(t, c, size + 1)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -312,14 +299,14 @@ fn email_value(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnRes
 /// > | a<user@example.com>b
 ///                       ^
 /// ```
-fn end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn end(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.enter(Token::AutolinkMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::AutolinkMarker);
             tokenizer.exit(Token::Autolink);
-            (State::Ok, 0)
+            State::Ok(0)
         }
         _ => unreachable!("expected `>`"),
     }
diff --git a/src/construct/blank_line.rs b/src/construct/blank_line.rs
index 5b6513d..1121b81 100644
--- a/src/construct/blank_line.rs
+++ b/src/construct/blank_line.rs
@@ -33,7 +33,7 @@
 //! [flow]: crate::content::flow
 
 use crate::construct::partial_space_or_tab::space_or_tab;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of a blank line.
 ///
@@ -45,7 +45,7 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 /// > |
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(space_or_tab(), after)(tokenizer, code)
 }
 
@@ -57,11 +57,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |
 ///     ^
 /// ```
-fn after(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after(_tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/block_quote.rs b/src/construct/block_quote.rs
index d1b4005..da21add 100644
--- a/src/construct/block_quote.rs
+++ b/src/construct/block_quote.rs
@@ -36,7 +36,7 @@
 use crate::constant::TAB_SIZE;
 use crate::construct::partial_space_or_tab::space_or_tab_min_max;
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of block quote.
 ///
@@ -44,7 +44,7 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 /// > | > a
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -53,7 +53,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
     if tokenizer.parse_state.constructs.block_quote {
         tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -63,7 +63,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | > a
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.enter(Token::BlockQuote);
@@ -80,7 +80,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | > b
 ///     ^
 /// ```
-pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -96,16 +96,16 @@ pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | > b
 ///     ^
 /// ```
-fn cont_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn cont_before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.enter(Token::BlockQuotePrefix);
             tokenizer.enter(Token::BlockQuoteMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::BlockQuoteMarker);
-            (State::Fn(Box::new(cont_after)), 0)
+            State::Fn(Box::new(cont_after))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -117,18 +117,18 @@ fn cont_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | >b
 ///      ^
 /// ```
-fn cont_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn cont_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.enter(Token::SpaceOrTab);
             tokenizer.consume(code);
             tokenizer.exit(Token::SpaceOrTab);
             tokenizer.exit(Token::BlockQuotePrefix);
-            (State::Ok, 0)
+            State::Ok(0)
         }
         _ => {
             tokenizer.exit(Token::BlockQuotePrefix);
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
     }
 }
diff --git a/src/construct/character_escape.rs b/src/construct/character_escape.rs
index eb79486..8403765 100644
--- a/src/construct/character_escape.rs
+++ b/src/construct/character_escape.rs
@@ -34,7 +34,7 @@
 //! [hard_break_escape]: crate::construct::hard_break_escape
 
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of a character escape.
 ///
@@ -42,16 +42,16 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 /// > | a\*b
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('\\') if tokenizer.parse_state.constructs.character_escape => {
             tokenizer.enter(Token::CharacterEscape);
             tokenizer.enter(Token::CharacterEscapeMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::CharacterEscapeMarker);
-            (State::Fn(Box::new(inside)), 0)
+            State::Fn(Box::new(inside))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -61,15 +61,15 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a\*b
 ///       ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(char) if char.is_ascii_punctuation() => {
             tokenizer.enter(Token::CharacterEscapeValue);
             tokenizer.consume(code);
             tokenizer.exit(Token::CharacterEscapeValue);
             tokenizer.exit(Token::CharacterEscape);
-            (State::Ok, 0)
+            State::Ok(0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/character_reference.rs b/src/construct/character_reference.rs
index 2d9d524..b2146e7 100644
--- a/src/construct/character_reference.rs
+++ b/src/construct/character_reference.rs
@@ -66,7 +66,7 @@ use crate::constant::{
     CHARACTER_REFERENCE_HEXADECIMAL_SIZE_MAX, CHARACTER_REFERENCE_NAMED_SIZE_MAX,
 };
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Kind of a character reference.
 #[derive(Debug, Clone, PartialEq)]
@@ -136,16 +136,16 @@ struct Info {
 /// > | a&#x9;b
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('&') if tokenizer.parse_state.constructs.character_reference => {
             tokenizer.enter(Token::CharacterReference);
             tokenizer.enter(Token::CharacterReferenceMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::CharacterReferenceMarker);
-            (State::Fn(Box::new(open)), 0)
+            State::Fn(Box::new(open))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -160,7 +160,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a&#x9;b
 ///       ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
     let info = Info {
         buffer: String::new(),
         kind: Kind::Named,
@@ -169,7 +169,7 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         tokenizer.enter(Token::CharacterReferenceMarkerNumeric);
         tokenizer.consume(code);
         tokenizer.exit(Token::CharacterReferenceMarkerNumeric);
-        (State::Fn(Box::new(|t, c| numeric(t, c, info))), 0)
+        State::Fn(Box::new(|t, c| numeric(t, c, info)))
     } else {
         tokenizer.enter(Token::CharacterReferenceValue);
         value(tokenizer, code, info)
@@ -185,14 +185,14 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a&#x9;b
 ///        ^
 /// ```
-fn numeric(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn numeric(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     if let Code::Char('x' | 'X') = code {
         tokenizer.enter(Token::CharacterReferenceMarkerHexadecimal);
         tokenizer.consume(code);
         tokenizer.exit(Token::CharacterReferenceMarkerHexadecimal);
         tokenizer.enter(Token::CharacterReferenceValue);
         info.kind = Kind::Hexadecimal;
-        (State::Fn(Box::new(|t, c| value(t, c, info))), 0)
+        State::Fn(Box::new(|t, c| value(t, c, info)))
     } else {
         tokenizer.enter(Token::CharacterReferenceValue);
         info.kind = Kind::Decimal;
@@ -213,32 +213,32 @@ fn numeric(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResu
 /// > | a&#x9;b
 ///         ^
 /// ```
-fn value(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn value(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char(';') if !info.buffer.is_empty() => {
             let unknown_named = Kind::Named == info.kind
                 && !CHARACTER_REFERENCES.iter().any(|d| d.0 == info.buffer);
 
             if unknown_named {
-                (State::Nok, 0)
+                State::Nok
             } else {
                 tokenizer.exit(Token::CharacterReferenceValue);
                 tokenizer.enter(Token::CharacterReferenceMarkerSemi);
                 tokenizer.consume(code);
                 tokenizer.exit(Token::CharacterReferenceMarkerSemi);
                 tokenizer.exit(Token::CharacterReference);
-                (State::Ok, 0)
+                State::Ok(0)
             }
         }
         Code::Char(char) => {
             if info.buffer.len() < info.kind.max() && info.kind.allowed(char) {
                 info.buffer.push(char);
                 tokenizer.consume(code);
-                (State::Fn(Box::new(|t, c| value(t, c, info))), 0)
+                State::Fn(Box::new(|t, c| value(t, c, info)))
             } else {
-                (State::Nok, 0)
+                State::Nok
             }
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/code_fenced.rs b/src/construct/code_fenced.rs
index 332d93c..3923ba0 100644
--- a/src/construct/code_fenced.rs
+++ b/src/construct/code_fenced.rs
@@ -107,7 +107,7 @@ use crate::construct::{
     partial_space_or_tab::{space_or_tab, space_or_tab_min_max},
 };
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, State, Tokenizer};
 use crate::util::span::from_exit_event;
 
 /// Kind of fences.
@@ -188,7 +188,7 @@ struct Info {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -199,7 +199,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         tokenizer.enter(Token::CodeFencedFence);
         tokenizer.go(space_or_tab_min_max(0, max), before_sequence_open)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -211,7 +211,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> State {
     let tail = tokenizer.events.last();
     let mut prefix = 0;
 
@@ -235,7 +235,7 @@ fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult
                 },
             )
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -247,23 +247,20 @@ fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn sequence_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn sequence_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| {
-                    info.size += 1;
-                    sequence_open(t, c, info)
-                })),
-                0,
-            )
+            State::Fn(Box::new(|t, c| {
+                info.size += 1;
+                sequence_open(t, c, info)
+            }))
         }
         _ if info.size >= CODE_FENCED_SEQUENCE_SIZE_MIN => {
             tokenizer.exit(Token::CodeFencedFenceSequence);
             tokenizer.attempt_opt(space_or_tab(), |t, c| info_before(t, c, info))(tokenizer, code)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -275,7 +272,7 @@ fn sequence_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn info_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn info_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFencedFence);
@@ -299,12 +296,7 @@ fn info_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResu
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn info_inside(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-    mut codes: Vec<Code>,
-) -> StateFnResult {
+fn info_inside(tokenizer: &mut Tokenizer, code: Code, info: Info, mut codes: Vec<Code>) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
@@ -319,14 +311,11 @@ fn info_inside(
             tokenizer.exit(Token::CodeFencedFenceInfo);
             tokenizer.attempt_opt(space_or_tab(), |t, c| meta_before(t, c, info))(tokenizer, code)
         }
-        Code::Char('`') if info.kind == Kind::GraveAccent => (State::Nok, 0),
+        Code::Char('`') if info.kind == Kind::GraveAccent => State::Nok,
         Code::Char(_) => {
             codes.push(code);
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| info_inside(t, c, info, codes))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| info_inside(t, c, info, codes)))
         }
     }
 }
@@ -339,7 +328,7 @@ fn info_inside(
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn meta_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn meta_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFencedFence);
@@ -363,7 +352,7 @@ fn meta_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResu
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn meta(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn meta(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
@@ -373,10 +362,10 @@ fn meta(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
             tokenizer.concrete = true;
             at_break(tokenizer, code, info)
         }
-        Code::Char('`') if info.kind == Kind::GraveAccent => (State::Nok, 0),
+        Code::Char('`') if info.kind == Kind::GraveAccent => State::Nok,
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| meta(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| meta(t, c, info)))
         }
     }
 }
@@ -390,7 +379,7 @@ fn meta(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
 ///                   ^
 ///   | ~~~
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     tokenizer.check(partial_non_lazy_continuation, |ok| {
         if ok {
             Box::new(move |t, c| at_non_lazy_break(t, c, info))
@@ -409,7 +398,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult
 ///                   ^
 ///   | ~~~
 /// ```
-fn at_non_lazy_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn at_non_lazy_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     let clone = info.clone();
 
     tokenizer.attempt(
@@ -432,13 +421,13 @@ fn at_non_lazy_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State
 ///                   ^
 ///   | ~~~
 /// ```
-fn close_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn close_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (State::Fn(Box::new(|t, c| close_start(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| close_start(t, c, info)))
         }
         _ => unreachable!("expected eol"),
     }
@@ -452,7 +441,7 @@ fn close_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResu
 /// > | ~~~
 ///     ^
 /// ```
-fn close_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn close_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -473,13 +462,13 @@ fn close_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResu
 /// > | ~~~
 ///     ^
 /// ```
-fn close_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn close_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.enter(Token::CodeFencedFenceSequence);
             close_sequence(tokenizer, code, info, 0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -491,20 +480,17 @@ fn close_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnRes
 /// > | ~~~
 ///     ^
 /// ```
-fn close_sequence(tokenizer: &mut Tokenizer, code: Code, info: Info, size: usize) -> StateFnResult {
+fn close_sequence(tokenizer: &mut Tokenizer, code: Code, info: Info, size: usize) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| close_sequence(t, c, info, size + 1))),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| close_sequence(t, c, info, size + 1)))
         }
         _ if size >= CODE_FENCED_SEQUENCE_SIZE_MIN && size >= info.size => {
             tokenizer.exit(Token::CodeFencedFenceSequence);
             tokenizer.attempt_opt(space_or_tab(), close_sequence_after)(tokenizer, code)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -516,13 +502,13 @@ fn close_sequence(tokenizer: &mut Tokenizer, code: Code, info: Info, size: usize
 /// > | ~~~
 ///        ^
 /// ```
-fn close_sequence_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn close_sequence_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFencedFence);
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -534,11 +520,11 @@ fn close_sequence_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult
 ///                   ^
 ///   | ~~~
 /// ```
-fn content_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn content_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     tokenizer.enter(Token::LineEnding);
     tokenizer.consume(code);
     tokenizer.exit(Token::LineEnding);
-    (State::Fn(Box::new(|t, c| content_start(t, c, info))), 0)
+    State::Fn(Box::new(|t, c| content_start(t, c, info)))
 }
 /// Before code content, definitely not before a closing fence.
 ///
@@ -548,7 +534,7 @@ fn content_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnR
 ///     ^
 ///   | ~~~
 /// ```
-fn content_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn content_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     tokenizer.go(space_or_tab_min_max(0, info.prefix), |t, c| {
         content_begin(t, c, info)
     })(tokenizer, code)
@@ -562,7 +548,7 @@ fn content_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnRe
 ///     ^
 ///   | ~~~
 /// ```
-fn content_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn content_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_break(tokenizer, code, info)
@@ -582,7 +568,7 @@ fn content_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnRe
 ///     ^^^^^^^^^^^^^^
 ///   | ~~~
 /// ```
-fn content_continue(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn content_continue(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFlowChunk);
@@ -590,7 +576,7 @@ fn content_continue(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateF
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| content_continue(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| content_continue(t, c, info)))
         }
     }
 }
@@ -603,11 +589,11 @@ fn content_continue(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateF
 /// > | ~~~
 ///        ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.exit(Token::CodeFenced);
     // Feel free to interrupt.
     tokenizer.interrupt = false;
     // No longer concrete.
     tokenizer.concrete = false;
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
diff --git a/src/construct/code_indented.rs b/src/construct/code_indented.rs
index 2a8b92f..512a816 100644
--- a/src/construct/code_indented.rs
+++ b/src/construct/code_indented.rs
@@ -48,7 +48,7 @@
 use super::partial_space_or_tab::{space_or_tab, space_or_tab_min_max};
 use crate::constant::TAB_SIZE;
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of code (indented).
 ///
@@ -60,10 +60,10 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 /// > |     aaa
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     // Do not interrupt paragraphs.
     if tokenizer.interrupt || !tokenizer.parse_state.constructs.code_indented {
-        (State::Nok, 0)
+        State::Nok
     } else {
         tokenizer.enter(Token::CodeIndented);
         tokenizer.go(space_or_tab_min_max(TAB_SIZE, TAB_SIZE), at_break)(tokenizer, code)
@@ -76,7 +76,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |     aaa
 ///         ^  ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None => after(tokenizer, code),
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => tokenizer
@@ -96,7 +96,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |     aaa
 ///         ^^^^
 /// ```
-fn content(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn content(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFlowChunk);
@@ -104,7 +104,7 @@ fn content(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(content)), 0)
+            State::Fn(Box::new(content))
         }
     }
 }
@@ -115,11 +115,11 @@ fn content(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |     aaa
 ///            ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.exit(Token::CodeIndented);
     // Feel free to interrupt.
     tokenizer.interrupt = false;
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
 
 /// Right at a line ending, trying to parse another indent.
@@ -129,16 +129,16 @@ fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///            ^
 ///   |     bbb
 /// ```
-fn further_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn further_start(tokenizer: &mut Tokenizer, code: Code) -> State {
     if tokenizer.lazy {
-        (State::Nok, 0)
+        State::Nok
     } else {
         match code {
             Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
                 tokenizer.enter(Token::LineEnding);
                 tokenizer.consume(code);
                 tokenizer.exit(Token::LineEnding);
-                (State::Fn(Box::new(further_start)), 0)
+                State::Fn(Box::new(further_start))
             }
             _ => tokenizer.attempt(space_or_tab_min_max(TAB_SIZE, TAB_SIZE), |ok| {
                 Box::new(if ok { further_end } else { further_begin })
@@ -154,8 +154,8 @@ fn further_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |     bbb
 ///         ^
 /// ```
-fn further_end(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+fn further_end(_tokenizer: &mut Tokenizer, code: Code) -> State {
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
 
 /// At the beginning of a line that is not indented enough.
@@ -165,7 +165,7 @@ fn further_end(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |   bbb
 ///     ^
 /// ```
-fn further_begin(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn further_begin(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(space_or_tab(), further_after)(tokenizer, code)
 }
 
@@ -176,9 +176,9 @@ fn further_begin(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |   bbb
 ///       ^
 /// ```
-fn further_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn further_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => further_start(tokenizer, code),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/code_text.rs b/src/construct/code_text.rs
index 03ff881..e68d489 100644
--- a/src/construct/code_text.rs
+++ b/src/construct/code_text.rs
@@ -84,7 +84,7 @@
 //! [html-code]: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-code-element
 
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of code (text).
 ///
@@ -94,7 +94,7 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 /// > | \`a`
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let len = tokenizer.events.len();
 
     match code {
@@ -108,7 +108,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             tokenizer.enter(Token::CodeTextSequence);
             sequence_open(tokenizer, code, 0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -118,13 +118,10 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | `a`
 ///     ^
 /// ```
-fn sequence_open(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
+fn sequence_open(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     if let Code::Char('`') = code {
         tokenizer.consume(code);
-        (
-            State::Fn(Box::new(move |t, c| sequence_open(t, c, size + 1))),
-            0,
-        )
+        State::Fn(Box::new(move |t, c| sequence_open(t, c, size + 1)))
     } else {
         tokenizer.exit(Token::CodeTextSequence);
         between(tokenizer, code, size)
@@ -137,14 +134,14 @@ fn sequence_open(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnR
 /// > | `a`
 ///      ^^
 /// ```
-fn between(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> StateFnResult {
+fn between(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> State {
     match code {
-        Code::None => (State::Nok, 0),
+        Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (State::Fn(Box::new(move |t, c| between(t, c, size_open))), 0)
+            State::Fn(Box::new(move |t, c| between(t, c, size_open)))
         }
         Code::Char('`') => {
             tokenizer.enter(Token::CodeTextSequence);
@@ -163,7 +160,7 @@ fn between(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> StateFnRe
 /// > | `a`
 ///      ^
 /// ```
-fn data(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> StateFnResult {
+fn data(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r' | '`') => {
             tokenizer.exit(Token::CodeTextData);
@@ -171,7 +168,7 @@ fn data(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> StateFnResul
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| data(t, c, size_open))), 0)
+            State::Fn(Box::new(move |t, c| data(t, c, size_open)))
         }
     }
 }
@@ -182,26 +179,18 @@ fn data(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> StateFnResul
 /// > | `a`
 ///       ^
 /// ```
-fn sequence_close(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    size_open: usize,
-    size: usize,
-) -> StateFnResult {
+fn sequence_close(tokenizer: &mut Tokenizer, code: Code, size_open: usize, size: usize) -> State {
     match code {
         Code::Char('`') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| {
-                    sequence_close(t, c, size_open, size + 1)
-                })),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| {
+                sequence_close(t, c, size_open, size + 1)
+            }))
         }
         _ if size_open == size => {
             tokenizer.exit(Token::CodeTextSequence);
             tokenizer.exit(Token::CodeText);
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
         _ => {
             let index = tokenizer.events.len();
diff --git a/src/construct/definition.rs b/src/construct/definition.rs
index 2016cc4..9e43d18 100644
--- a/src/construct/definition.rs
+++ b/src/construct/definition.rs
@@ -100,7 +100,7 @@ use crate::construct::{
     partial_title::{start as title, Options as TitleOptions},
 };
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 use crate::util::skip::opt_back as skip_opt_back;
 
 /// At the start of a definition.
@@ -109,7 +109,7 @@ use crate::util::skip::opt_back as skip_opt_back;
 /// > | [a]: b "c"
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let definition_before = !tokenizer.events.is_empty()
         && tokenizer.events[skip_opt_back(
             &tokenizer.events,
@@ -125,7 +125,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         // Note: arbitrary whitespace allowed even if code (indented) is on.
         tokenizer.attempt_opt(space_or_tab(), before)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -135,7 +135,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('[') => tokenizer.go(
             |t, c| {
@@ -151,7 +151,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             },
             label_after,
         )(tokenizer, code),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -161,20 +161,17 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///        ^
 /// ```
-fn label_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn label_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(':') => {
             tokenizer.enter(Token::DefinitionMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::DefinitionMarker);
-            (
-                State::Fn(Box::new(
-                    tokenizer.attempt_opt(space_or_tab_eol(), destination_before),
-                )),
-                0,
-            )
+            State::Fn(Box::new(
+                tokenizer.attempt_opt(space_or_tab_eol(), destination_before),
+            ))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -184,7 +181,7 @@ fn label_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///          ^
 /// ```
-fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.go(
         |t, c| {
             destination(
@@ -210,7 +207,7 @@ fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///           ^
 /// ```
-fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(title_before, after)(tokenizer, code)
 }
 
@@ -222,7 +219,7 @@ fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(space_or_tab(), after_whitespace)(tokenizer, code)
 }
 
@@ -234,15 +231,15 @@ fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Definition);
             // You’d be interrupting.
             tokenizer.interrupt = true;
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -254,7 +251,7 @@ fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///           ^
 /// ```
-fn title_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn title_before(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.go(space_or_tab_eol(), title_before_marker)(tokenizer, code)
 }
 
@@ -265,7 +262,7 @@ fn title_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | "c"
 ///     ^
 /// ```
-fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.go(
         |t, c| {
             title(
@@ -288,7 +285,7 @@ fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn title_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn title_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(space_or_tab(), title_after_after_optional_whitespace)(tokenizer, code)
 }
 
@@ -298,11 +295,11 @@ fn title_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn title_after_after_optional_whitespace(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn title_after_after_optional_whitespace(_tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/hard_break_escape.rs b/src/construct/hard_break_escape.rs
index 19d430d..617b0ce 100644
--- a/src/construct/hard_break_escape.rs
+++ b/src/construct/hard_break_escape.rs
@@ -41,7 +41,7 @@
 //! [html]: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-br-element
 
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of a hard break (escape).
 ///
@@ -50,16 +50,16 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 ///      ^
 ///   | b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('\\') if tokenizer.parse_state.constructs.hard_break_escape => {
             tokenizer.enter(Token::HardBreakEscape);
             tokenizer.enter(Token::HardBreakEscapeMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::HardBreakEscapeMarker);
-            (State::Fn(Box::new(inside)), 0)
+            State::Fn(Box::new(inside))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -70,12 +70,12 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///       ^
 ///   | b
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HardBreakEscape);
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/hard_break_trailing.rs b/src/construct/hard_break_trailing.rs
index c5861f7..8ce4201 100644
--- a/src/construct/hard_break_trailing.rs
+++ b/src/construct/hard_break_trailing.rs
@@ -42,7 +42,7 @@
 
 use crate::constant::HARD_BREAK_PREFIX_SIZE_MIN;
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of a hard break (trailing).
 ///
@@ -51,15 +51,15 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 ///      ^
 ///   | b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(' ') if tokenizer.parse_state.constructs.hard_break_trailing => {
             tokenizer.enter(Token::HardBreakTrailing);
             tokenizer.enter(Token::HardBreakTrailingSpace);
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| inside(t, c, 1))), 0)
+            State::Fn(Box::new(|t, c| inside(t, c, 1)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -70,19 +70,19 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///      ^
 ///   | b
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     match code {
         Code::Char(' ') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| inside(t, c, size + 1))), 0)
+            State::Fn(Box::new(move |t, c| inside(t, c, size + 1)))
         }
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
             if size >= HARD_BREAK_PREFIX_SIZE_MIN =>
         {
             tokenizer.exit(Token::HardBreakTrailingSpace);
             tokenizer.exit(Token::HardBreakTrailing);
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/heading_atx.rs b/src/construct/heading_atx.rs
index ac36e29..52eca54 100644
--- a/src/construct/heading_atx.rs
+++ b/src/construct/heading_atx.rs
@@ -57,7 +57,7 @@
 use super::partial_space_or_tab::{space_or_tab, space_or_tab_min_max};
 use crate::constant::{HEADING_ATX_OPENING_FENCE_SIZE_MAX, TAB_SIZE};
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, Event, EventType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, Event, EventType, State, Tokenizer};
 use crate::util::edit_map::EditMap;
 
 /// Start of a heading (atx).
@@ -66,7 +66,7 @@ use crate::util::edit_map::EditMap;
 /// > | ## aa
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -77,7 +77,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         tokenizer.enter(Token::HeadingAtx);
         tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -87,12 +87,12 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ## aa
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     if Code::Char('#') == code {
         tokenizer.enter(Token::HeadingAtxSequence);
         sequence_open(tokenizer, code, 0)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -102,7 +102,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ## aa
 ///     ^
 /// ```
-fn sequence_open(tokenizer: &mut Tokenizer, code: Code, rank: usize) -> StateFnResult {
+fn sequence_open(tokenizer: &mut Tokenizer, code: Code, rank: usize) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') if rank > 0 => {
             tokenizer.exit(Token::HeadingAtxSequence);
@@ -110,18 +110,15 @@ fn sequence_open(tokenizer: &mut Tokenizer, code: Code, rank: usize) -> StateFnR
         }
         Code::Char('#') if rank < HEADING_ATX_OPENING_FENCE_SIZE_MAX => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |tokenizer, code| {
-                    sequence_open(tokenizer, code, rank + 1)
-                })),
-                0,
-            )
+            State::Fn(Box::new(move |tokenizer, code| {
+                sequence_open(tokenizer, code, rank + 1)
+            }))
         }
         _ if rank > 0 => {
             tokenizer.exit(Token::HeadingAtxSequence);
             tokenizer.go(space_or_tab(), at_break)(tokenizer, code)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -131,14 +128,14 @@ fn sequence_open(tokenizer: &mut Tokenizer, code: Code, rank: usize) -> StateFnR
 /// > | ## aa
 ///       ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HeadingAtx);
             tokenizer.register_resolver("heading_atx".to_string(), Box::new(resolve));
             // Feel free to interrupt.
             tokenizer.interrupt = false;
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.go(space_or_tab(), at_break)(tokenizer, code)
@@ -162,10 +159,10 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ## aa ##
 ///           ^
 /// ```
-fn further_sequence(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn further_sequence(tokenizer: &mut Tokenizer, code: Code) -> State {
     if let Code::Char('#') = code {
         tokenizer.consume(code);
-        (State::Fn(Box::new(further_sequence)), 0)
+        State::Fn(Box::new(further_sequence))
     } else {
         tokenizer.exit(Token::HeadingAtxSequence);
         at_break(tokenizer, code)
@@ -178,7 +175,7 @@ fn further_sequence(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ## aa
 ///        ^
 /// ```
-fn data(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn data(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         // Note: `#` for closing sequence must be preceded by whitespace, otherwise it’s just text.
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\t' | '\n' | '\r' | ' ') => {
@@ -187,7 +184,7 @@ fn data(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(data)), 0)
+            State::Fn(Box::new(data))
         }
     }
 }
diff --git a/src/construct/heading_setext.rs b/src/construct/heading_setext.rs
index 49d9cd2..828b7f4 100644
--- a/src/construct/heading_setext.rs
+++ b/src/construct/heading_setext.rs
@@ -60,7 +60,7 @@
 use crate::constant::TAB_SIZE;
 use crate::construct::partial_space_or_tab::{space_or_tab, space_or_tab_min_max};
 use crate::token::Token;
-use crate::tokenizer::{Code, EventType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, EventType, State, Tokenizer};
 use crate::util::{edit_map::EditMap, skip::opt_back as skip_opt_back};
 
 /// Kind of underline.
@@ -116,7 +116,7 @@ impl Kind {
 /// > | ==
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -135,7 +135,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
     if paragraph_before && !tokenizer.lazy && tokenizer.parse_state.constructs.heading_setext {
         tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -146,13 +146,13 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ==
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(char) if char == '-' || char == '=' => {
             tokenizer.enter(Token::HeadingSetextUnderline);
             inside(tokenizer, code, Kind::from_char(char))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -163,11 +163,11 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ==
 ///     ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, kind: Kind) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code, kind: Kind) -> State {
     match code {
         Code::Char(char) if char == kind.as_char() => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| inside(t, c, kind))), 0)
+            State::Fn(Box::new(move |t, c| inside(t, c, kind)))
         }
         _ => {
             tokenizer.exit(Token::HeadingSetextUnderline);
@@ -183,23 +183,23 @@ fn inside(tokenizer: &mut Tokenizer, code: Code, kind: Kind) -> StateFnResult {
 /// > | ==
 ///       ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             // Feel free to interrupt.
             tokenizer.interrupt = false;
             tokenizer.register_resolver("heading_setext".to_string(), Box::new(resolve));
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
 /// Resolve heading (setext).
 pub fn resolve(tokenizer: &mut Tokenizer, map: &mut EditMap) -> bool {
     let mut index = 0;
-    let mut paragraph_enter: Option<usize> = None;
-    let mut paragraph_exit: Option<usize> = None;
+    let mut paragraph_enter = None;
+    let mut paragraph_exit = None;
 
     while index < tokenizer.events.len() {
         let event = &tokenizer.events[index];
diff --git a/src/construct/html_flow.rs b/src/construct/html_flow.rs
index c77a626..7a7c25f 100644
--- a/src/construct/html_flow.rs
+++ b/src/construct/html_flow.rs
@@ -105,7 +105,7 @@ use crate::construct::{
     partial_space_or_tab::{space_or_tab_with_options, Options as SpaceOrTabOptions},
 };
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 use crate::util::codes::{parse, serialize};
 
 /// Kind of HTML (flow).
@@ -203,7 +203,7 @@ struct Info {
 /// > | <x />
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -223,7 +223,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             before,
         )(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -233,13 +233,13 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | <x />
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     if Code::Char('<') == code {
         tokenizer.enter(Token::HtmlFlowData);
         tokenizer.consume(code);
-        (State::Fn(Box::new(open)), 0)
+        State::Fn(Box::new(open))
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -253,7 +253,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | <!--xxx-->
 ///      ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
     let mut info = Info {
         // Assume basic.
         kind: Kind::Basic,
@@ -267,11 +267,11 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
     match code {
         Code::Char('!') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| declaration_open(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| declaration_open(t, c, info)))
         }
         Code::Char('/') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| tag_close_start(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| tag_close_start(t, c, info)))
         }
         Code::Char('?') => {
             info.kind = Kind::Instruction;
@@ -280,16 +280,13 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             tokenizer.concrete = true;
             // While we’re in an instruction instead of a declaration, we’re on a `?`
             // right now, so we do need to search for `>`, similar to declarations.
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
             info.start_tag = true;
             tag_name(tokenizer, code, info)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -303,34 +300,28 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | <![CDATA[>&<]]>
 ///       ^
 /// ```
-fn declaration_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn declaration_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char('-') => {
             tokenizer.consume(code);
             info.kind = Kind::Comment;
-            (
-                State::Fn(Box::new(|t, c| comment_open_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| comment_open_inside(t, c, info)))
         }
         Code::Char('[') => {
             tokenizer.consume(code);
             info.kind = Kind::Cdata;
             info.buffer = parse("CDATA[");
             info.index = 0;
-            (State::Fn(Box::new(|t, c| cdata_open_inside(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| cdata_open_inside(t, c, info)))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
             info.kind = Kind::Declaration;
             // Do not form containers.
             tokenizer.concrete = true;
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -340,18 +331,15 @@ fn declaration_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> St
 /// > | <!--xxx-->
 ///        ^
 /// ```
-fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('-') => {
             tokenizer.consume(code);
             // Do not form containers.
             tokenizer.concrete = true;
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -361,7 +349,7 @@ fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Sta
 /// > | <![CDATA[>&<]]>
 ///        ^^^^^^
 /// ```
-fn cdata_open_inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn cdata_open_inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     if code == info.buffer[info.index] {
         info.index += 1;
         tokenizer.consume(code);
@@ -370,12 +358,12 @@ fn cdata_open_inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> S
             info.buffer.clear();
             // Do not form containers.
             tokenizer.concrete = true;
-            (State::Fn(Box::new(|t, c| continuation(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| continuation(t, c, info)))
         } else {
-            (State::Fn(Box::new(|t, c| cdata_open_inside(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| cdata_open_inside(t, c, info)))
         }
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -385,14 +373,14 @@ fn cdata_open_inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> S
 /// > | </x>
 ///       ^
 /// ```
-fn tag_close_start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn tag_close_start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char('A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
             info.buffer.push(code);
-            (State::Fn(Box::new(|t, c| tag_name(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| tag_name(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -404,7 +392,7 @@ fn tag_close_start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> Sta
 /// > | </ab>
 ///       ^^
 /// ```
-fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::None
         | Code::CarriageReturnLineFeed
@@ -425,10 +413,7 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnRes
                 // Basic is assumed, no need to set `kind`.
                 if slash {
                     tokenizer.consume(code);
-                    (
-                        State::Fn(Box::new(|t, c| basic_self_closing(t, c, info))),
-                        0,
-                    )
+                    State::Fn(Box::new(|t, c| basic_self_closing(t, c, info)))
                 } else {
                     // Do not form containers.
                     tokenizer.concrete = true;
@@ -439,7 +424,7 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnRes
 
                 // Do not support complete HTML when interrupting.
                 if tokenizer.interrupt && !tokenizer.lazy {
-                    (State::Nok, 0)
+                    State::Nok
                 } else if info.start_tag {
                     complete_attribute_name_before(tokenizer, code, info)
                 } else {
@@ -450,9 +435,9 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnRes
         Code::Char('-' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
             info.buffer.push(code);
-            (State::Fn(Box::new(|t, c| tag_name(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| tag_name(t, c, info)))
         }
-        Code::Char(_) => (State::Nok, 0),
+        Code::Char(_) => State::Nok,
     }
 }
 
@@ -462,15 +447,15 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnRes
 /// > | <div/>
 ///          ^
 /// ```
-fn basic_self_closing(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn basic_self_closing(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.consume(code);
             // Do not form containers.
             tokenizer.concrete = true;
-            (State::Fn(Box::new(|t, c| continuation(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| continuation(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -480,14 +465,11 @@ fn basic_self_closing(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Stat
 /// > | <x/>
 ///        ^
 /// ```
-fn complete_closing_tag_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn complete_closing_tag_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_closing_tag_after(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_closing_tag_after(t, c, info)))
         }
         _ => complete_end(tokenizer, code, info),
     }
@@ -512,29 +494,19 @@ fn complete_closing_tag_after(tokenizer: &mut Tokenizer, code: Code, info: Info)
 /// > | <a >
 ///        ^
 /// ```
-fn complete_attribute_name_before(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> StateFnResult {
+fn complete_attribute_name_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('/') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| complete_end(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| complete_end(t, c, info)))
         }
         Code::Char('0'..='9' | ':' | 'A'..='Z' | '_' | 'a'..='z') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_name(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_name(t, c, info)))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_name_before(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_name_before(t, c, info)))
         }
         _ => complete_end(tokenizer, code, info),
     }
@@ -550,14 +522,11 @@ fn complete_attribute_name_before(
 /// > | <a b>
 ///         ^
 /// ```
-fn complete_attribute_name(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn complete_attribute_name(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('-' | '.' | '0'..='9' | ':' | 'A'..='Z' | '_' | 'a'..='z') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_name(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_name(t, c, info)))
         }
         _ => complete_attribute_name_after(tokenizer, code, info),
     }
@@ -572,25 +541,15 @@ fn complete_attribute_name(tokenizer: &mut Tokenizer, code: Code, info: Info) ->
 /// > | <a b=c>
 ///         ^
 /// ```
-fn complete_attribute_name_after(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> StateFnResult {
+fn complete_attribute_name_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('=') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_value_before(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_value_before(t, c, info)))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_name_after(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_name_after(t, c, info)))
         }
         _ => complete_attribute_name_before(tokenizer, code, info),
     }
@@ -605,27 +564,17 @@ fn complete_attribute_name_after(
 /// > | <a b="c">
 ///          ^
 /// ```
-fn complete_attribute_value_before(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    mut info: Info,
-) -> StateFnResult {
+fn complete_attribute_value_before(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
-        Code::None | Code::Char('<' | '=' | '>' | '`') => (State::Nok, 0),
+        Code::None | Code::Char('<' | '=' | '>' | '`') => State::Nok,
         Code::Char('"' | '\'') => {
             tokenizer.consume(code);
             info.quote = Some(QuoteKind::from_code(code));
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_value_quoted(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_value_quoted(t, c, info)))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_value_before(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_value_before(t, c, info)))
         }
         _ => complete_attribute_value_unquoted(tokenizer, code, info),
     }
@@ -639,28 +588,18 @@ fn complete_attribute_value_before(
 /// > | <a b='c'>
 ///           ^
 /// ```
-fn complete_attribute_value_quoted(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> StateFnResult {
+fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
-        Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => (State::Nok, 0),
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => State::Nok,
         Code::Char(char) if char == info.quote.as_ref().unwrap().as_char() => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| {
-                    complete_attribute_value_quoted_after(t, c, info)
-                })),
-                0,
-            )
+            State::Fn(Box::new(|t, c| {
+                complete_attribute_value_quoted_after(t, c, info)
+            }))
         }
         _ => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| complete_attribute_value_quoted(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| complete_attribute_value_quoted(t, c, info)))
         }
     }
 }
@@ -671,11 +610,7 @@ fn complete_attribute_value_quoted(
 /// > | <a b=c>
 ///          ^
 /// ```
-fn complete_attribute_value_unquoted(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> StateFnResult {
+fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None
         | Code::CarriageReturnLineFeed
@@ -685,12 +620,9 @@ fn complete_attribute_value_unquoted(
         }
         Code::Char(_) => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| {
-                    complete_attribute_value_unquoted(t, c, info)
-                })),
-                0,
-            )
+            State::Fn(Box::new(|t, c| {
+                complete_attribute_value_unquoted(t, c, info)
+            }))
         }
     }
 }
@@ -706,12 +638,12 @@ fn complete_attribute_value_quoted_after(
     tokenizer: &mut Tokenizer,
     code: Code,
     info: Info,
-) -> StateFnResult {
+) -> State {
     match code {
         Code::VirtualSpace | Code::Char('\t' | ' ' | '/' | '>') => {
             complete_attribute_name_before(tokenizer, code, info)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -721,13 +653,13 @@ fn complete_attribute_value_quoted_after(
 /// > | <a b="c">
 ///             ^
 /// ```
-fn complete_end(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn complete_end(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| complete_after(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| complete_after(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -737,7 +669,7 @@ fn complete_end(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnRes
 /// > | <x>
 ///        ^
 /// ```
-fn complete_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn complete_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             // Do not form containers.
@@ -746,9 +678,9 @@ fn complete_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnR
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| complete_after(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| complete_after(t, c, info)))
         }
-        Code::Char(_) => (State::Nok, 0),
+        Code::Char(_) => State::Nok,
     }
 }
 
@@ -758,44 +690,29 @@ fn complete_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnR
 /// > | <!--xxx-->
 ///          ^
 /// ```
-fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('-') if info.kind == Kind::Comment => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_comment_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_comment_inside(t, c, info)))
         }
         Code::Char('<') if info.kind == Kind::Raw => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_raw_tag_open(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_raw_tag_open(t, c, info)))
         }
         Code::Char('>') if info.kind == Kind::Declaration => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_close(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
         }
         Code::Char('?') if info.kind == Kind::Instruction => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
         Code::Char(']') if info.kind == Kind::Cdata => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| {
-                    continuation_character_data_inside(t, c, info)
-                })),
-                0,
-            )
+            State::Fn(Box::new(|t, c| {
+                continuation_character_data_inside(t, c, info)
+            }))
         }
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
             if info.kind == Kind::Basic || info.kind == Kind::Complete =>
@@ -815,7 +732,7 @@ fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnRes
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| continuation(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| continuation(t, c, info)))
         }
     }
 }
@@ -827,7 +744,7 @@ fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnRes
 ///        ^
 ///   | asd
 /// ```
-fn continuation_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     tokenizer.check(partial_non_lazy_continuation, |ok| {
         if ok {
             Box::new(move |t, c| continuation_start_non_lazy(t, c, info))
@@ -844,16 +761,13 @@ fn continuation_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Stat
 ///        ^
 ///   | asd
 /// ```
-fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (
-                State::Fn(Box::new(|t, c| continuation_before(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_before(t, c, info)))
         }
         _ => unreachable!("expected eol"),
     }
@@ -866,7 +780,7 @@ fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, code: Code, info: Info
 /// > | asd
 ///     ^
 /// ```
-fn continuation_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             continuation_start(tokenizer, code, info)
@@ -884,14 +798,11 @@ fn continuation_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Sta
 /// > | <!--xxx-->
 ///             ^
 /// ```
-fn continuation_comment_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation_comment_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('-') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
         _ => continuation(tokenizer, code, info),
     }
@@ -903,14 +814,11 @@ fn continuation_comment_inside(tokenizer: &mut Tokenizer, code: Code, info: Info
 /// > | <script>console.log(1)</script>
 ///                            ^
 /// ```
-fn continuation_raw_tag_open(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation_raw_tag_open(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('/') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_raw_end_tag(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_raw_end_tag(t, c, info)))
         }
         _ => continuation(tokenizer, code, info),
     }
@@ -922,11 +830,7 @@ fn continuation_raw_tag_open(tokenizer: &mut Tokenizer, code: Code, info: Info)
 /// > | <script>console.log(1)</script>
 ///                             ^^^^^^
 /// ```
-fn continuation_raw_end_tag(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    mut info: Info,
-) -> StateFnResult {
+fn continuation_raw_end_tag(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char('>') => {
             let tag_name_buffer = serialize(&info.buffer, false).to_lowercase();
@@ -934,10 +838,7 @@ fn continuation_raw_end_tag(
 
             if HTML_RAW_NAMES.contains(&tag_name_buffer.as_str()) {
                 tokenizer.consume(code);
-                (
-                    State::Fn(Box::new(|t, c| continuation_close(t, c, info))),
-                    0,
-                )
+                State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
             } else {
                 continuation(tokenizer, code, info)
             }
@@ -945,10 +846,7 @@ fn continuation_raw_end_tag(
         Code::Char('A'..='Z' | 'a'..='z') if info.buffer.len() < HTML_RAW_SIZE_MAX => {
             tokenizer.consume(code);
             info.buffer.push(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_raw_end_tag(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_raw_end_tag(t, c, info)))
         }
         _ => {
             info.buffer.clear();
@@ -963,18 +861,11 @@ fn continuation_raw_end_tag(
 /// > | <![CDATA[>&<]]>
 ///                  ^
 /// ```
-fn continuation_character_data_inside(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> StateFnResult {
+fn continuation_character_data_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char(']') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
         _ => continuation(tokenizer, code, info),
     }
@@ -994,25 +885,15 @@ fn continuation_character_data_inside(
 /// > | <![CDATA[>&<]]>
 ///                   ^
 /// ```
-fn continuation_declaration_inside(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> StateFnResult {
+fn continuation_declaration_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_close(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
         }
         Code::Char('-') if info.kind == Kind::Comment => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
         }
         _ => continuation(tokenizer, code, info),
     }
@@ -1024,7 +905,7 @@ fn continuation_declaration_inside(
 /// > | <!doctype>
 ///               ^
 /// ```
-fn continuation_close(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn continuation_close(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HtmlFlowData);
@@ -1032,10 +913,7 @@ fn continuation_close(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Stat
         }
         _ => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(|t, c| continuation_close(t, c, info))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
         }
     }
 }
@@ -1046,13 +924,13 @@ fn continuation_close(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Stat
 /// > | <!doctype>
 ///               ^
 /// ```
-fn continuation_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn continuation_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.exit(Token::HtmlFlow);
     // Feel free to interrupt.
     tokenizer.interrupt = false;
     // No longer concrete.
     tokenizer.concrete = false;
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
 
 /// Before a line ending, expecting a blank line.
@@ -1062,9 +940,9 @@ fn continuation_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///          ^
 ///   |
 /// ```
-fn blank_line_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn blank_line_before(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.enter(Token::LineEnding);
     tokenizer.consume(code);
     tokenizer.exit(Token::LineEnding);
-    (State::Fn(Box::new(blank_line)), 0)
+    State::Fn(Box::new(blank_line))
 }
diff --git a/src/construct/html_text.rs b/src/construct/html_text.rs
index 1696f68..f1ed5c7 100644
--- a/src/construct/html_text.rs
+++ b/src/construct/html_text.rs
@@ -56,7 +56,7 @@
 
 use crate::construct::partial_space_or_tab::space_or_tab;
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFn, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, StateFn, Tokenizer};
 use crate::util::codes::parse;
 
 /// Start of HTML (text)
@@ -65,14 +65,14 @@ use crate::util::codes::parse;
 /// > | a <b> c
 ///       ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     if Code::Char('<') == code && tokenizer.parse_state.constructs.html_text {
         tokenizer.enter(Token::HtmlText);
         tokenizer.enter(Token::HtmlTextData);
         tokenizer.consume(code);
-        (State::Fn(Box::new(open)), 0)
+        State::Fn(Box::new(open))
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -86,25 +86,25 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <!--b--> c
 ///        ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('!') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(declaration_open)), 0)
+            State::Fn(Box::new(declaration_open))
         }
         Code::Char('/') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_close_start)), 0)
+            State::Fn(Box::new(tag_close_start))
         }
         Code::Char('?') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(instruction)), 0)
+            State::Fn(Box::new(instruction))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open)), 0)
+            State::Fn(Box::new(tag_open))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -118,25 +118,22 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <![CDATA[>&<]]> c
 ///         ^
 /// ```
-fn declaration_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn declaration_open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('-') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(comment_open_inside)), 0)
+            State::Fn(Box::new(comment_open_inside))
         }
         Code::Char('[') => {
             tokenizer.consume(code);
             let buffer = parse("CDATA[");
-            (
-                State::Fn(Box::new(|t, c| cdata_open_inside(t, c, buffer, 0))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| cdata_open_inside(t, c, buffer, 0)))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(declaration)), 0)
+            State::Fn(Box::new(declaration))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -146,13 +143,13 @@ fn declaration_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <!--b--> c
 ///          ^
 /// ```
-fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('-') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(comment_start)), 0)
+            State::Fn(Box::new(comment_start))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -169,12 +166,12 @@ fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// ```
 ///
 /// [html_flow]: crate::construct::html_flow
-fn comment_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn comment_start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None | Code::Char('>') => (State::Nok, 0),
+        Code::None | Code::Char('>') => State::Nok,
         Code::Char('-') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(comment_start_dash)), 0)
+            State::Fn(Box::new(comment_start_dash))
         }
         _ => comment(tokenizer, code),
     }
@@ -193,9 +190,9 @@ fn comment_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// ```
 ///
 /// [html_flow]: crate::construct::html_flow
-fn comment_start_dash(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn comment_start_dash(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None | Code::Char('>') => (State::Nok, 0),
+        Code::None | Code::Char('>') => State::Nok,
         _ => comment(tokenizer, code),
     }
 }
@@ -206,19 +203,19 @@ fn comment_start_dash(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <!--b--> c
 ///           ^
 /// ```
-fn comment(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn comment(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None => (State::Nok, 0),
+        Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(comment))
         }
         Code::Char('-') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(comment_close)), 0)
+            State::Fn(Box::new(comment_close))
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(comment)), 0)
+            State::Fn(Box::new(comment))
         }
     }
 }
@@ -229,11 +226,11 @@ fn comment(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <!--b--> c
 ///             ^
 /// ```
-fn comment_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn comment_close(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('-') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(end)), 0)
+            State::Fn(Box::new(end))
         }
         _ => comment(tokenizer, code),
     }
@@ -250,22 +247,19 @@ fn cdata_open_inside(
     code: Code,
     buffer: Vec<Code>,
     index: usize,
-) -> StateFnResult {
+) -> State {
     if code == buffer[index] {
         tokenizer.consume(code);
 
         if index + 1 == buffer.len() {
-            (State::Fn(Box::new(cdata)), 0)
+            State::Fn(Box::new(cdata))
         } else {
-            (
-                State::Fn(Box::new(move |t, c| {
-                    cdata_open_inside(t, c, buffer, index + 1)
-                })),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| {
+                cdata_open_inside(t, c, buffer, index + 1)
+            }))
         }
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -275,19 +269,19 @@ fn cdata_open_inside(
 /// > | a <![CDATA[>&<]]> b
 ///                ^^^
 /// ```
-fn cdata(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn cdata(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None => (State::Nok, 0),
+        Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(cdata))
         }
         Code::Char(']') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(cdata_close)), 0)
+            State::Fn(Box::new(cdata_close))
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(cdata)), 0)
+            State::Fn(Box::new(cdata))
         }
     }
 }
@@ -298,11 +292,11 @@ fn cdata(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <![CDATA[>&<]]> b
 ///                    ^
 /// ```
-fn cdata_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn cdata_close(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(']') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(cdata_end)), 0)
+            State::Fn(Box::new(cdata_end))
         }
         _ => cdata(tokenizer, code),
     }
@@ -314,7 +308,7 @@ fn cdata_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <![CDATA[>&<]]> b
 ///                     ^
 /// ```
-fn cdata_end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn cdata_end(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => end(tokenizer, code),
         Code::Char(']') => cdata_close(tokenizer, code),
@@ -328,7 +322,7 @@ fn cdata_end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <!b> c
 ///          ^
 /// ```
-fn declaration(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn declaration(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::Char('>') => end(tokenizer, code),
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
@@ -336,7 +330,7 @@ fn declaration(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(declaration)), 0)
+            State::Fn(Box::new(declaration))
         }
     }
 }
@@ -347,19 +341,19 @@ fn declaration(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <?b?> c
 ///         ^
 /// ```
-fn instruction(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn instruction(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None => (State::Nok, 0),
+        Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(instruction))
         }
         Code::Char('?') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(instruction_close)), 0)
+            State::Fn(Box::new(instruction_close))
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(instruction)), 0)
+            State::Fn(Box::new(instruction))
         }
     }
 }
@@ -370,7 +364,7 @@ fn instruction(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <?b?> c
 ///           ^
 /// ```
-fn instruction_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn instruction_close(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => end(tokenizer, code),
         _ => instruction(tokenizer, code),
@@ -383,13 +377,13 @@ fn instruction_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a </b> c
 ///         ^
 /// ```
-fn tag_close_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_close_start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_close)), 0)
+            State::Fn(Box::new(tag_close))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -399,11 +393,11 @@ fn tag_close_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a </b> c
 ///          ^
 /// ```
-fn tag_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_close(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('-' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_close)), 0)
+            State::Fn(Box::new(tag_close))
         }
         _ => tag_close_between(tokenizer, code),
     }
@@ -415,14 +409,14 @@ fn tag_close(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a </b> c
 ///          ^
 /// ```
-fn tag_close_between(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_close_between(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(tag_close_between))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_close_between)), 0)
+            State::Fn(Box::new(tag_close_between))
         }
         _ => end(tokenizer, code),
     }
@@ -434,16 +428,16 @@ fn tag_close_between(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <b> c
 ///         ^
 /// ```
-fn tag_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('-' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open)), 0)
+            State::Fn(Box::new(tag_open))
         }
         Code::CarriageReturnLineFeed
         | Code::VirtualSpace
         | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => tag_open_between(tokenizer, code),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -453,22 +447,22 @@ fn tag_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <b> c
 ///         ^
 /// ```
-fn tag_open_between(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open_between(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(tag_open_between))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_between)), 0)
+            State::Fn(Box::new(tag_open_between))
         }
         Code::Char('/') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(end)), 0)
+            State::Fn(Box::new(end))
         }
         Code::Char(':' | 'A'..='Z' | '_' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_name)), 0)
+            State::Fn(Box::new(tag_open_attribute_name))
         }
         _ => end(tokenizer, code),
     }
@@ -480,11 +474,11 @@ fn tag_open_between(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a <b c> d
 ///          ^
 /// ```
-fn tag_open_attribute_name(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open_attribute_name(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('-' | '.' | '0'..='9' | ':' | 'A'..='Z' | '_' | 'a'..='z') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_name)), 0)
+            State::Fn(Box::new(tag_open_attribute_name))
         }
         _ => tag_open_attribute_name_after(tokenizer, code),
     }
@@ -497,18 +491,18 @@ fn tag_open_attribute_name(tokenizer: &mut Tokenizer, code: Code) -> StateFnResu
 /// > | a <b c> d
 ///           ^
 /// ```
-fn tag_open_attribute_name_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open_attribute_name_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(tag_open_attribute_name_after))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_name_after)), 0)
+            State::Fn(Box::new(tag_open_attribute_name_after))
         }
         Code::Char('=') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_value_before)), 0)
+            State::Fn(Box::new(tag_open_attribute_value_before))
         }
         _ => tag_open_between(tokenizer, code),
     }
@@ -521,28 +515,25 @@ fn tag_open_attribute_name_after(tokenizer: &mut Tokenizer, code: Code) -> State
 /// > | a <b c=d> e
 ///            ^
 /// ```
-fn tag_open_attribute_value_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open_attribute_value_before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None | Code::Char('<' | '=' | '>' | '`') => (State::Nok, 0),
+        Code::None | Code::Char('<' | '=' | '>' | '`') => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             at_line_ending(tokenizer, code, Box::new(tag_open_attribute_value_before))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_value_before)), 0)
+            State::Fn(Box::new(tag_open_attribute_value_before))
         }
         Code::Char(char) if char == '"' || char == '\'' => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| {
-                    tag_open_attribute_value_quoted(t, c, char)
-                })),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| {
+                tag_open_attribute_value_quoted(t, c, char)
+            }))
         }
         Code::Char(_) => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_value_unquoted)), 0)
+            State::Fn(Box::new(tag_open_attribute_value_unquoted))
         }
     }
 }
@@ -553,13 +544,9 @@ fn tag_open_attribute_value_before(tokenizer: &mut Tokenizer, code: Code) -> Sta
 /// > | a <b c="d"> e
 ///             ^
 /// ```
-fn tag_open_attribute_value_quoted(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    marker: char,
-) -> StateFnResult {
+fn tag_open_attribute_value_quoted(tokenizer: &mut Tokenizer, code: Code, marker: char) -> State {
     match code {
-        Code::None => (State::Nok, 0),
+        Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => at_line_ending(
             tokenizer,
             code,
@@ -567,19 +554,13 @@ fn tag_open_attribute_value_quoted(
         ),
         Code::Char(char) if char == marker => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(tag_open_attribute_value_quoted_after)),
-                0,
-            )
+            State::Fn(Box::new(tag_open_attribute_value_quoted_after))
         }
         _ => {
             tokenizer.consume(code);
-            (
-                State::Fn(Box::new(move |t, c| {
-                    tag_open_attribute_value_quoted(t, c, marker)
-                })),
-                0,
-            )
+            State::Fn(Box::new(move |t, c| {
+                tag_open_attribute_value_quoted(t, c, marker)
+            }))
         }
     }
 }
@@ -590,15 +571,15 @@ fn tag_open_attribute_value_quoted(
 /// > | a <b c=d> e
 ///            ^
 /// ```
-fn tag_open_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
-        Code::None | Code::Char('"' | '\'' | '<' | '=' | '`') => (State::Nok, 0),
+        Code::None | Code::Char('"' | '\'' | '<' | '=' | '`') => State::Nok,
         Code::CarriageReturnLineFeed
         | Code::VirtualSpace
         | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => tag_open_between(tokenizer, code),
         Code::Char(_) => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(tag_open_attribute_value_unquoted)), 0)
+            State::Fn(Box::new(tag_open_attribute_value_unquoted))
         }
     }
 }
@@ -610,12 +591,12 @@ fn tag_open_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code) -> S
 /// > | a <b c="d"> e
 ///               ^
 /// ```
-fn tag_open_attribute_value_quoted_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn tag_open_attribute_value_quoted_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed
         | Code::VirtualSpace
         | Code::Char('\t' | '\n' | '\r' | ' ' | '>' | '/') => tag_open_between(tokenizer, code),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -625,15 +606,15 @@ fn tag_open_attribute_value_quoted_after(tokenizer: &mut Tokenizer, code: Code)
 /// > | a <b c="d"> e
 ///               ^
 /// ```
-fn end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn end(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.consume(code);
             tokenizer.exit(Token::HtmlTextData);
             tokenizer.exit(Token::HtmlText);
-            (State::Ok, 0)
+            State::Ok(0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -647,21 +628,14 @@ fn end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///            ^
 ///   | b-->
 /// ```
-fn at_line_ending(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    return_state: Box<StateFn>,
-) -> StateFnResult {
+fn at_line_ending(tokenizer: &mut Tokenizer, code: Code, return_state: Box<StateFn>) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HtmlTextData);
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (
-                State::Fn(Box::new(|t, c| after_line_ending(t, c, return_state))),
-                0,
-            )
+            State::Fn(Box::new(|t, c| after_line_ending(t, c, return_state)))
         }
         _ => unreachable!("expected eol"),
     }
@@ -677,11 +651,7 @@ fn at_line_ending(
 /// > | b-->
 ///     ^
 /// ```
-fn after_line_ending(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    return_state: Box<StateFn>,
-) -> StateFnResult {
+fn after_line_ending(tokenizer: &mut Tokenizer, code: Code, return_state: Box<StateFn>) -> State {
     tokenizer.attempt_opt(space_or_tab(), |t, c| {
         after_line_ending_prefix(t, c, return_state)
     })(tokenizer, code)
@@ -701,7 +671,7 @@ fn after_line_ending_prefix(
     tokenizer: &mut Tokenizer,
     code: Code,
     return_state: Box<StateFn>,
-) -> StateFnResult {
+) -> State {
     tokenizer.enter(Token::HtmlTextData);
     return_state(tokenizer, code)
 }
diff --git a/src/construct/label_end.rs b/src/construct/label_end.rs
index 504571d..0b9654d 100644
--- a/src/construct/label_end.rs
+++ b/src/construct/label_end.rs
@@ -154,7 +154,7 @@ use crate::construct::{
     partial_title::{start as title, Options as TitleOptions},
 };
 use crate::token::Token;
-use crate::tokenizer::{Code, Event, EventType, Media, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, Event, EventType, Media, State, Tokenizer};
 use crate::util::{
     edit_map::EditMap,
     normalize_identifier::normalize_identifier,
@@ -181,9 +181,9 @@ struct Info {
 ///       ^
 /// > | [a] b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     if Code::Char(']') == code && tokenizer.parse_state.constructs.label_end {
-        let mut label_start_index: Option<usize> = None;
+        let mut label_start_index = None;
         let mut index = tokenizer.label_start_stack.len();
 
         while index > 0 {
@@ -230,11 +230,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             tokenizer.exit(Token::LabelMarker);
             tokenizer.exit(Token::LabelEnd);
 
-            return (State::Fn(Box::new(move |t, c| after(t, c, info))), 0);
+            return State::Fn(Box::new(move |t, c| after(t, c, info)));
         }
     }
 
-    (State::Nok, 0)
+    State::Nok
 }
 
 /// After `]`.
@@ -249,7 +249,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a] b
 ///       ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     let defined = tokenizer.parse_state.definitions.contains(&info.media.id);
 
     match code {
@@ -297,7 +297,7 @@ fn after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
 /// > | [a] b
 ///        ^
 /// ```
-fn reference_not_full(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn reference_not_full(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     tokenizer.attempt(collapsed_reference, move |is_ok| {
         Box::new(move |t, c| {
             if is_ok {
@@ -321,7 +321,7 @@ fn reference_not_full(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Stat
 /// > | [a] b
 ///        ^
 /// ```
-fn ok(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn ok(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     // Remove this one and everything after it.
     let mut left = tokenizer
         .label_start_stack
@@ -346,7 +346,7 @@ fn ok(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
     info.media.end.1 = tokenizer.events.len() - 1;
     tokenizer.media_list.push(info.media);
     tokenizer.register_resolver_before("media".to_string(), Box::new(resolve_media));
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
 
 /// Done, it’s nothing.
@@ -361,13 +361,13 @@ fn ok(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
 /// > | [a] b
 ///        ^
 /// ```
-fn nok(tokenizer: &mut Tokenizer, _code: Code, label_start_index: usize) -> StateFnResult {
+fn nok(tokenizer: &mut Tokenizer, _code: Code, label_start_index: usize) -> State {
     let label_start = tokenizer
         .label_start_stack
         .get_mut(label_start_index)
         .unwrap();
     label_start.balanced = true;
-    (State::Nok, 0)
+    State::Nok
 }
 
 /// Before a resource, at `(`.
@@ -376,14 +376,14 @@ fn nok(tokenizer: &mut Tokenizer, _code: Code, label_start_index: usize) -> Stat
 /// > | [a](b) c
 ///        ^
 /// ```
-fn resource(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn resource(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('(') => {
             tokenizer.enter(Token::Resource);
             tokenizer.enter(Token::ResourceMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::ResourceMarker);
-            (State::Fn(Box::new(resource_start)), 0)
+            State::Fn(Box::new(resource_start))
         }
         _ => unreachable!("expected `(`"),
     }
@@ -395,7 +395,7 @@ fn resource(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a](b) c
 ///         ^
 /// ```
-fn resource_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn resource_start(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(space_or_tab_eol(), resource_open)(tokenizer, code)
 }
 
@@ -405,7 +405,7 @@ fn resource_start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a](b) c
 ///         ^
 /// ```
-fn resource_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn resource_open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(')') => resource_end(tokenizer, code),
         _ => tokenizer.go(
@@ -434,7 +434,7 @@ fn resource_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a](b) c
 ///          ^
 /// ```
-fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt(space_or_tab_eol(), |ok| {
         Box::new(if ok { resource_between } else { resource_end })
     })(tokenizer, code)
@@ -446,7 +446,7 @@ fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a](b ) c
 ///           ^
 /// ```
-fn resource_between(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn resource_between(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('"' | '\'' | '(') => tokenizer.go(
             |t, c| {
@@ -472,7 +472,7 @@ fn resource_between(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a](b "c") d
 ///              ^
 /// ```
-fn title_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn title_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.attempt_opt(space_or_tab_eol(), resource_end)(tokenizer, code)
 }
 
@@ -482,16 +482,16 @@ fn title_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a](b) d
 ///          ^
 /// ```
-fn resource_end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn resource_end(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(')') => {
             tokenizer.enter(Token::ResourceMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::ResourceMarker);
             tokenizer.exit(Token::Resource);
-            (State::Ok, 0)
+            State::Ok(0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -501,7 +501,7 @@ fn resource_end(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a][b] d
 ///        ^
 /// ```
-fn full_reference(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn full_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('[') => tokenizer.go(
             |t, c| {
@@ -527,7 +527,7 @@ fn full_reference(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a][b] d
 ///          ^
 /// ```
-fn full_reference_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn full_reference_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     let events = &tokenizer.events;
     let mut index = events.len() - 1;
     let mut start: Option<usize> = None;
@@ -559,9 +559,9 @@ fn full_reference_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult
             false,
         )))
     {
-        (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+        State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -573,16 +573,16 @@ fn full_reference_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult
 /// > | [a][] d
 ///        ^
 /// ```
-fn collapsed_reference(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn collapsed_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('[') => {
             tokenizer.enter(Token::Reference);
             tokenizer.enter(Token::ReferenceMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::ReferenceMarker);
-            (State::Fn(Box::new(collapsed_reference_open)), 0)
+            State::Fn(Box::new(collapsed_reference_open))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -594,16 +594,16 @@ fn collapsed_reference(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | [a][] d
 ///         ^
 /// ```
-fn collapsed_reference_open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn collapsed_reference_open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char(']') => {
             tokenizer.enter(Token::ReferenceMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::ReferenceMarker);
             tokenizer.exit(Token::Reference);
-            (State::Ok, 0)
+            State::Ok(0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
diff --git a/src/construct/label_start_image.rs b/src/construct/label_start_image.rs
index 3764f20..6738ebe 100644
--- a/src/construct/label_start_image.rs
+++ b/src/construct/label_start_image.rs
@@ -30,7 +30,7 @@
 
 use super::label_end::resolve_media;
 use crate::token::Token;
-use crate::tokenizer::{Code, LabelStart, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, LabelStart, State, Tokenizer};
 
 /// Start of label (image) start.
 ///
@@ -38,16 +38,16 @@ use crate::tokenizer::{Code, LabelStart, State, StateFnResult, Tokenizer};
 /// > | a ![b] c
 ///       ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('!') if tokenizer.parse_state.constructs.label_start_image => {
             tokenizer.enter(Token::LabelImage);
             tokenizer.enter(Token::LabelImageMarker);
             tokenizer.consume(code);
             tokenizer.exit(Token::LabelImageMarker);
-            (State::Fn(Box::new(open)), 0)
+            State::Fn(Box::new(open))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -57,7 +57,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | a ![b] c
 ///        ^
 /// ```
-pub fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('[') => {
             tokenizer.enter(Token::LabelMarker);
@@ -71,8 +71,8 @@ pub fn open(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
                 inactive: false,
             });
             tokenizer.register_resolver_before("media".to_string(), Box::new(resolve_media));
-            (State::Ok, 0)
+            State::Ok(0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/label_start_link.rs b/src/construct/label_start_link.rs
index 404b91a..9462ba7 100644
--- a/src/construct/label_start_link.rs
+++ b/src/construct/label_start_link.rs
@@ -29,7 +29,7 @@
 
 use super::label_end::resolve_media;
 use crate::token::Token;
-use crate::tokenizer::{Code, LabelStart, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, LabelStart, State, Tokenizer};
 
 /// Start of label (link) start.
 ///
@@ -37,7 +37,7 @@ use crate::tokenizer::{Code, LabelStart, State, StateFnResult, Tokenizer};
 /// > | a [b] c
 ///       ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('[') if tokenizer.parse_state.constructs.label_start_link => {
             let start = tokenizer.events.len();
@@ -52,8 +52,8 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
                 inactive: false,
             });
             tokenizer.register_resolver_before("media".to_string(), Box::new(resolve_media));
-            (State::Ok, 0)
+            State::Ok(0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
diff --git a/src/construct/list.rs b/src/construct/list.rs
index 289398a..96113e6 100644
--- a/src/construct/list.rs
+++ b/src/construct/list.rs
@@ -50,7 +50,7 @@ use crate::construct::{
     thematic_break::start as thematic_break,
 };
 use crate::token::Token;
-use crate::tokenizer::{Code, EventType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, EventType, State, Tokenizer};
 use crate::util::{
     edit_map::EditMap,
     skip,
@@ -137,7 +137,7 @@ impl Kind {
 /// > | * a
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -148,7 +148,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         tokenizer.enter(Token::ListItem);
         tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -158,7 +158,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | * a
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         // Unordered.
         Code::Char('*' | '+' | '-') => tokenizer.check(thematic_break, |ok| {
@@ -170,7 +170,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             tokenizer.enter(Token::ListItemValue);
             inside(tokenizer, code, 0)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -182,7 +182,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | * a
 ///     ^
 /// ```
-fn before_unordered(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before_unordered(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.enter(Token::ListItemPrefix);
     marker(tokenizer, code)
 }
@@ -193,17 +193,17 @@ fn before_unordered(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | 1. a
 ///     ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
     match code {
         Code::Char(char) if char.is_ascii_digit() && size + 1 < LIST_ITEM_VALUE_SIZE_MAX => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| inside(t, c, size + 1))), 0)
+            State::Fn(Box::new(move |t, c| inside(t, c, size + 1)))
         }
         Code::Char('.' | ')') if !tokenizer.interrupt || size < 2 => {
             tokenizer.exit(Token::ListItemValue);
             marker(tokenizer, code)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -215,11 +215,11 @@ fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> StateFnResult {
 /// > | 1. b
 ///      ^
 /// ```
-fn marker(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn marker(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.enter(Token::ListItemMarker);
     tokenizer.consume(code);
     tokenizer.exit(Token::ListItemMarker);
-    (State::Fn(Box::new(marker_after)), 0)
+    State::Fn(Box::new(marker_after))
 }
 
 /// After a list item marker.
@@ -230,7 +230,7 @@ fn marker(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | 1. b
 ///       ^
 /// ```
-fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.check(blank_line, move |ok| {
         if ok {
             Box::new(|t, c| after(t, c, true))
@@ -246,7 +246,7 @@ fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | * a
 ///      ^
 /// ```
-fn marker_after_not_blank(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn marker_after_not_blank(tokenizer: &mut Tokenizer, code: Code) -> State {
     // Attempt to parse up to the largest allowed indent, `nok` if there is more whitespace.
     tokenizer.attempt(whitespace, move |ok| {
         if ok {
@@ -263,7 +263,7 @@ fn marker_after_not_blank(tokenizer: &mut Tokenizer, code: Code) -> StateFnResul
 /// > | * a
 ///      ^
 /// ```
-fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.go(space_or_tab_min_max(1, TAB_SIZE), whitespace_after)(tokenizer, code)
 }
 
@@ -273,11 +273,11 @@ fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | * a
 ///      ^
 /// ```
-fn whitespace_after(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn whitespace_after(_tokenizer: &mut Tokenizer, code: Code) -> State {
     if matches!(code, Code::VirtualSpace | Code::Char('\t' | ' ')) {
-        (State::Nok, 0)
+        State::Nok
     } else {
-        (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+        State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
     }
 }
 
@@ -287,15 +287,15 @@ fn whitespace_after(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | * a
 ///      ^
 /// ```
-fn prefix_other(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn prefix_other(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.enter(Token::SpaceOrTab);
             tokenizer.consume(code);
             tokenizer.exit(Token::SpaceOrTab);
-            (State::Fn(Box::new(|t, c| after(t, c, false))), 0)
+            State::Fn(Box::new(|t, c| after(t, c, false)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -305,9 +305,9 @@ fn prefix_other(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | * a
 ///       ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code, blank: bool) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code, blank: bool) -> State {
     if blank && tokenizer.interrupt {
-        (State::Nok, 0)
+        State::Nok
     } else {
         let start = skip::to_back(
             &tokenizer.events,
@@ -323,7 +323,7 @@ fn after(tokenizer: &mut Tokenizer, code: Code, blank: bool) -> StateFnResult {
 
         tokenizer.exit(Token::ListItemPrefix);
         tokenizer.register_resolver_before("list_item".to_string(), Box::new(resolve_list_item));
-        (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+        State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
     }
 }
 
@@ -334,7 +334,7 @@ fn after(tokenizer: &mut Tokenizer, code: Code, blank: bool) -> StateFnResult {
 /// > |   b
 ///     ^
 /// ```
-pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.check(blank_line, |ok| {
         Box::new(if ok { blank_cont } else { not_blank_cont })
     })(tokenizer, code)
@@ -348,12 +348,12 @@ pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 ///     ^
 ///   |   b
 /// ```
-pub fn blank_cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn blank_cont(tokenizer: &mut Tokenizer, code: Code) -> State {
     let container = tokenizer.container.as_ref().unwrap();
     let size = container.size;
 
     if container.blank_initial {
-        (State::Nok, 0)
+        State::Nok
     } else {
         // Consume, optionally, at most `size`.
         tokenizer.go(space_or_tab_min_max(0, size), ok)(tokenizer, code)
@@ -367,7 +367,7 @@ pub fn blank_cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > |   b
 ///     ^
 /// ```
-pub fn not_blank_cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn not_blank_cont(tokenizer: &mut Tokenizer, code: Code) -> State {
     let container = tokenizer.container.as_mut().unwrap();
     let size = container.size;
 
@@ -378,13 +378,13 @@ pub fn not_blank_cont(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 }
 
 /// A state fn to yield [`State::Ok`].
-pub fn ok(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+pub fn ok(_tokenizer: &mut Tokenizer, code: Code) -> State {
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
 
 /// A state fn to yield [`State::Nok`].
-fn nok(_tokenizer: &mut Tokenizer, _code: Code) -> StateFnResult {
-    (State::Nok, 0)
+fn nok(_tokenizer: &mut Tokenizer, _code: Code) -> State {
+    State::Nok
 }
 
 /// Find adjacent list items with the same marker.
@@ -437,7 +437,7 @@ pub fn resolve_list_item(tokenizer: &mut Tokenizer, map: &mut EditMap) -> bool {
 
                 if !matched {
                     let mut index = lists_wip.len();
-                    let mut exit: Option<usize> = None;
+                    let mut exit = None;
 
                     while index > 0 {
                         index -= 1;
diff --git a/src/construct/paragraph.rs b/src/construct/paragraph.rs
index e43ee43..811bc75 100644
--- a/src/construct/paragraph.rs
+++ b/src/construct/paragraph.rs
@@ -33,7 +33,7 @@
 //! [html]: https://html.spec.whatwg.org/multipage/grouping-content.html#the-p-element
 
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, EventType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, EventType, State, Tokenizer};
 use crate::util::{edit_map::EditMap, skip::opt as skip_opt};
 
 /// Before a paragraph.
@@ -42,7 +42,7 @@ use crate::util::{edit_map::EditMap, skip::opt as skip_opt};
 /// > | abc
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             unreachable!("unexpected eol/eof")
@@ -61,7 +61,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | abc
 ///     ^^^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
@@ -69,11 +69,11 @@ fn inside(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
             tokenizer.register_resolver_before("paragraph".to_string(), Box::new(resolve));
             // You’d be interrupting.
             tokenizer.interrupt = true;
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(inside)), 0)
+            State::Fn(Box::new(inside))
         }
     }
 }
diff --git a/src/construct/partial_data.rs b/src/construct/partial_data.rs
index 3701e40..11064e6 100644
--- a/src/construct/partial_data.rs
+++ b/src/construct/partial_data.rs
@@ -7,7 +7,7 @@
 //! [text]: crate::content::text
 
 use crate::token::Token;
-use crate::tokenizer::{Code, EventType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, EventType, State, Tokenizer};
 use crate::util::edit_map::EditMap;
 
 /// At the beginning of data.
@@ -16,11 +16,11 @@ use crate::util::edit_map::EditMap;
 /// > | abc
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> State {
     if stop.contains(&code) {
         tokenizer.enter(Token::Data);
         tokenizer.consume(code);
-        (State::Fn(Box::new(move |t, c| data(t, c, stop))), 0)
+        State::Fn(Box::new(move |t, c| data(t, c, stop)))
     } else {
         at_break(tokenizer, code, stop)
     }
@@ -32,18 +32,18 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> St
 /// > | abc
 ///     ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> State {
     match code {
-        Code::None => (State::Ok, 0),
+        Code::None => State::Ok(0),
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (State::Fn(Box::new(move |t, c| at_break(t, c, stop))), 0)
+            State::Fn(Box::new(move |t, c| at_break(t, c, stop)))
         }
         _ if stop.contains(&code) => {
             tokenizer.register_resolver("data".to_string(), Box::new(resolve_data));
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
         _ => {
             tokenizer.enter(Token::Data);
@@ -58,7 +58,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> Sta
 /// > | abc
 ///     ^^^
 /// ```
-fn data(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> StateFnResult {
+fn data(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> State {
     let done = match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => true,
         _ if stop.contains(&code) => true,
@@ -70,7 +70,7 @@ fn data(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> StateFn
         at_break(tokenizer, code, stop)
     } else {
         tokenizer.consume(code);
-        (State::Fn(Box::new(move |t, c| data(t, c, stop))), 0)
+        State::Fn(Box::new(move |t, c| data(t, c, stop)))
     }
 }
 
diff --git a/src/construct/partial_destination.rs b/src/construct/partial_destination.rs
index de2952c..f898eb5 100644
--- a/src/construct/partial_destination.rs
+++ b/src/construct/partial_destination.rs
@@ -72,7 +72,7 @@
 //! [sanitize_uri]: crate::util::sanitize_uri
 
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, State, Tokenizer};
 
 /// Configuration.
 ///
@@ -110,7 +110,7 @@ struct Info {
 /// > | aa
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
     let info = Info {
         balance: 0,
         options,
@@ -123,12 +123,12 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFn
             tokenizer.enter(info.options.marker.clone());
             tokenizer.consume(code);
             tokenizer.exit(info.options.marker.clone());
-            (State::Fn(Box::new(|t, c| enclosed_before(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| enclosed_before(t, c, info)))
         }
         Code::None | Code::CarriageReturnLineFeed | Code::VirtualSpace | Code::Char(' ' | ')') => {
-            (State::Nok, 0)
+            State::Nok
         }
-        Code::Char(char) if char.is_ascii_control() => (State::Nok, 0),
+        Code::Char(char) if char.is_ascii_control() => State::Nok,
         Code::Char(_) => {
             tokenizer.enter(info.options.destination.clone());
             tokenizer.enter(info.options.raw.clone());
@@ -145,14 +145,14 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFn
 /// > | <aa>
 ///      ^
 /// ```
-fn enclosed_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn enclosed_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     if let Code::Char('>') = code {
         tokenizer.enter(info.options.marker.clone());
         tokenizer.consume(code);
         tokenizer.exit(info.options.marker.clone());
         tokenizer.exit(info.options.literal.clone());
         tokenizer.exit(info.options.destination);
-        (State::Ok, 0)
+        State::Ok(0)
     } else {
         tokenizer.enter(info.options.string.clone());
         tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
@@ -166,23 +166,21 @@ fn enclosed_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFn
 /// > | <aa>
 ///      ^
 /// ```
-fn enclosed(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn enclosed(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('>') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(info.options.string.clone());
             enclosed_before(tokenizer, code, info)
         }
-        Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r' | '<') => {
-            (State::Nok, 0)
-        }
+        Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r' | '<') => State::Nok,
         Code::Char('\\') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| enclosed_escape(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| enclosed_escape(t, c, info)))
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| enclosed(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| enclosed(t, c, info)))
         }
     }
 }
@@ -193,11 +191,11 @@ fn enclosed(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult
 /// > | <a\*a>
 ///        ^
 /// ```
-fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('<' | '>' | '\\') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| enclosed(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| enclosed(t, c, info)))
         }
         _ => enclosed(tokenizer, code, info),
     }
@@ -209,15 +207,15 @@ fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFn
 /// > | aa
 ///     ^
 /// ```
-fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char('(') => {
             if info.balance >= info.options.limit {
-                (State::Nok, 0)
+                State::Nok
             } else {
                 tokenizer.consume(code);
                 info.balance += 1;
-                (State::Fn(Box::new(move |t, c| raw(t, c, info))), 0)
+                State::Fn(Box::new(move |t, c| raw(t, c, info)))
             }
         }
         Code::Char(')') => {
@@ -226,11 +224,11 @@ fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
                 tokenizer.exit(info.options.string.clone());
                 tokenizer.exit(info.options.raw.clone());
                 tokenizer.exit(info.options.destination);
-                (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+                State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
             } else {
                 tokenizer.consume(code);
                 info.balance -= 1;
-                (State::Fn(Box::new(move |t, c| raw(t, c, info))), 0)
+                State::Fn(Box::new(move |t, c| raw(t, c, info)))
             }
         }
         Code::None
@@ -238,23 +236,23 @@ fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
         | Code::VirtualSpace
         | Code::Char('\t' | '\n' | '\r' | ' ') => {
             if info.balance > 0 {
-                (State::Nok, 0)
+                State::Nok
             } else {
                 tokenizer.exit(Token::Data);
                 tokenizer.exit(info.options.string.clone());
                 tokenizer.exit(info.options.raw.clone());
                 tokenizer.exit(info.options.destination);
-                (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+                State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
             }
         }
-        Code::Char(char) if char.is_ascii_control() => (State::Nok, 0),
+        Code::Char(char) if char.is_ascii_control() => State::Nok,
         Code::Char('\\') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| raw_escape(t, c, info))), 0)
+            State::Fn(Box::new(move |t, c| raw_escape(t, c, info)))
         }
         Code::Char(_) => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| raw(t, c, info))), 0)
+            State::Fn(Box::new(move |t, c| raw(t, c, info)))
         }
     }
 }
@@ -265,11 +263,11 @@ fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
 /// > | a\*a
 ///       ^
 /// ```
-fn raw_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn raw_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char('(' | ')' | '\\') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(move |t, c| raw(t, c, info))), 0)
+            State::Fn(Box::new(move |t, c| raw(t, c, info)))
         }
         _ => raw(tokenizer, code, info),
     }
diff --git a/src/construct/partial_label.rs b/src/construct/partial_label.rs
index 0892dbd..d2219cd 100644
--- a/src/construct/partial_label.rs
+++ b/src/construct/partial_label.rs
@@ -62,7 +62,7 @@ use super::partial_space_or_tab::{space_or_tab_eol_with_options, EolOptions};
 use crate::constant::LINK_REFERENCE_SIZE_MAX;
 use crate::subtokenize::link;
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, State, Tokenizer};
 
 /// Configuration.
 ///
@@ -96,7 +96,7 @@ struct Info {
 /// > | [a]
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
     match code {
         Code::Char('[') => {
             let info = Info {
@@ -110,9 +110,9 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFn
             tokenizer.consume(code);
             tokenizer.exit(info.options.marker.clone());
             tokenizer.enter(info.options.string.clone());
-            (State::Fn(Box::new(|t, c| at_break(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| at_break(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -122,18 +122,18 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFn
 /// > | [a]
 ///      ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
-        Code::None | Code::Char('[') => (State::Nok, 0),
-        Code::Char(']') if !info.data => (State::Nok, 0),
-        _ if info.size > LINK_REFERENCE_SIZE_MAX => (State::Nok, 0),
+        Code::None | Code::Char('[') => State::Nok,
+        Code::Char(']') if !info.data => State::Nok,
+        _ if info.size > LINK_REFERENCE_SIZE_MAX => State::Nok,
         Code::Char(']') => {
             tokenizer.exit(info.options.string.clone());
             tokenizer.enter(info.options.marker.clone());
             tokenizer.consume(code);
             tokenizer.exit(info.options.marker.clone());
             tokenizer.exit(info.options.label);
-            (State::Ok, 0)
+            State::Ok(0)
         }
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => tokenizer.go(
             space_or_tab_eol_with_options(EolOptions {
@@ -166,7 +166,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnRes
 /// > | [a]
 ///      ^
 /// ```
-fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r' | '[' | ']') => {
             tokenizer.exit(Token::Data);
@@ -179,7 +179,7 @@ fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.consume(code);
             info.size += 1;
-            (State::Fn(Box::new(|t, c| label(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| label(t, c, info)))
         }
         Code::Char('\\') => {
             tokenizer.consume(code);
@@ -187,7 +187,7 @@ fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult
             if !info.data {
                 info.data = true;
             }
-            (State::Fn(Box::new(|t, c| escape(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| escape(t, c, info)))
         }
         Code::Char(_) => {
             tokenizer.consume(code);
@@ -195,7 +195,7 @@ fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult
             if !info.data {
                 info.data = true;
             }
-            (State::Fn(Box::new(|t, c| label(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| label(t, c, info)))
         }
     }
 }
@@ -206,12 +206,12 @@ fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult
 /// > | [a\*a]
 ///        ^
 /// ```
-fn escape(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn escape(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char('[' | '\\' | ']') => {
             tokenizer.consume(code);
             info.size += 1;
-            (State::Fn(Box::new(|t, c| label(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| label(t, c, info)))
         }
         _ => label(tokenizer, code, info),
     }
diff --git a/src/construct/partial_non_lazy_continuation.rs b/src/construct/partial_non_lazy_continuation.rs
index c3b82c7..c6ac493 100644
--- a/src/construct/partial_non_lazy_continuation.rs
+++ b/src/construct/partial_non_lazy_continuation.rs
@@ -11,7 +11,7 @@
 //! [html_flow]: crate::construct::html_flow
 
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Start of continuation.
 ///
@@ -20,15 +20,15 @@ use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 ///            ^
 ///   | b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (State::Fn(Box::new(after)), 0)
+            State::Fn(Box::new(after))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -39,10 +39,10 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | b
 ///     ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
     if tokenizer.lazy {
-        (State::Nok, 0)
+        State::Nok
     } else {
-        (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+        State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
     }
 }
diff --git a/src/construct/partial_space_or_tab.rs b/src/construct/partial_space_or_tab.rs
index aacf28c..6eb3f1d 100644
--- a/src/construct/partial_space_or_tab.rs
+++ b/src/construct/partial_space_or_tab.rs
@@ -6,7 +6,7 @@
 
 use crate::subtokenize::link;
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, State, StateFn, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, State, StateFn, Tokenizer};
 
 /// Options to parse `space_or_tab`.
 #[derive(Debug)]
@@ -132,7 +132,7 @@ pub fn space_or_tab_eol_with_options(options: EolOptions) -> Box<StateFn> {
 /// > | a␠␠b
 ///      ^
 /// ```
-fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::VirtualSpace | Code::Char('\t' | ' ') if info.options.max > 0 => {
             tokenizer
@@ -145,13 +145,13 @@ fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult
 
             tokenizer.consume(code);
             info.size += 1;
-            (State::Fn(Box::new(|t, c| inside(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| inside(t, c, info)))
         }
         _ => {
             if info.options.min == 0 {
-                (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+                State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
             } else {
-                (State::Nok, 0)
+                State::Nok
             }
         }
     }
@@ -163,19 +163,19 @@ fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult
 /// > | a␠␠b
 ///       ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::VirtualSpace | Code::Char('\t' | ' ') if info.size < info.options.max => {
             tokenizer.consume(code);
             info.size += 1;
-            (State::Fn(Box::new(|t, c| inside(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| inside(t, c, info)))
         }
         _ => {
             tokenizer.exit(info.options.kind.clone());
             if info.size >= info.options.min {
-                (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+                State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
             } else {
-                (State::Nok, 0)
+                State::Nok
             }
         }
     }
@@ -188,7 +188,7 @@ fn inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResul
 ///      ^
 ///   | b
 /// ```
-fn after_space_or_tab(tokenizer: &mut Tokenizer, code: Code, mut info: EolInfo) -> StateFnResult {
+fn after_space_or_tab(tokenizer: &mut Tokenizer, code: Code, mut info: EolInfo) -> State {
     match code {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter_with_content(Token::LineEnding, info.options.content_type.clone());
@@ -202,10 +202,10 @@ fn after_space_or_tab(tokenizer: &mut Tokenizer, code: Code, mut info: EolInfo)
 
             tokenizer.consume(code);
             tokenizer.exit(Token::LineEnding);
-            (State::Fn(Box::new(|t, c| after_eol(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| after_eol(t, c, info)))
         }
-        _ if info.ok => (State::Ok, if matches!(code, Code::None) { 0 } else { 1 }),
-        _ => (State::Nok, 0),
+        _ if info.ok => State::Ok(if matches!(code, Code::None) { 0 } else { 1 }),
+        _ => State::Nok,
     }
 }
 
@@ -217,7 +217,7 @@ fn after_space_or_tab(tokenizer: &mut Tokenizer, code: Code, mut info: EolInfo)
 ///     ^
 /// ```
 #[allow(clippy::needless_pass_by_value)]
-fn after_eol(tokenizer: &mut Tokenizer, code: Code, info: EolInfo) -> StateFnResult {
+fn after_eol(tokenizer: &mut Tokenizer, code: Code, info: EolInfo) -> State {
     tokenizer.attempt_opt(
         space_or_tab_with_options(Options {
             kind: Token::SpaceOrTab,
@@ -237,14 +237,14 @@ fn after_eol(tokenizer: &mut Tokenizer, code: Code, info: EolInfo) -> StateFnRes
 /// > | b
 ///     ^
 /// ```
-fn after_more_space_or_tab(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn after_more_space_or_tab(_tokenizer: &mut Tokenizer, code: Code) -> State {
     // Blank line not allowed.
     if matches!(
         code,
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
     ) {
-        (State::Nok, 0)
+        State::Nok
     } else {
-        (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+        State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
     }
 }
diff --git a/src/construct/partial_title.rs b/src/construct/partial_title.rs
index f69d609..8510391 100644
--- a/src/construct/partial_title.rs
+++ b/src/construct/partial_title.rs
@@ -33,7 +33,7 @@
 use super::partial_space_or_tab::{space_or_tab_eol_with_options, EolOptions};
 use crate::subtokenize::link;
 use crate::token::Token;
-use crate::tokenizer::{Code, ContentType, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, ContentType, State, Tokenizer};
 
 /// Configuration.
 ///
@@ -135,7 +135,7 @@ struct Info {
 /// > | "a"
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
     match code {
         Code::Char('"' | '\'' | '(') => {
             let info = Info {
@@ -147,9 +147,9 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFn
             tokenizer.enter(info.options.marker.clone());
             tokenizer.consume(code);
             tokenizer.exit(info.options.marker.clone());
-            (State::Fn(Box::new(|t, c| begin(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| begin(t, c, info)))
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -161,14 +161,14 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> StateFn
 /// > | "a"
 ///      ^
 /// ```
-fn begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.enter(info.options.marker.clone());
             tokenizer.consume(code);
             tokenizer.exit(info.options.marker.clone());
             tokenizer.exit(info.options.title);
-            (State::Ok, 0)
+            State::Ok(0)
         }
         _ => {
             tokenizer.enter(info.options.string.clone());
@@ -183,13 +183,13 @@ fn begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
 /// > | "a"
 ///      ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.exit(info.options.string.clone());
             begin(tokenizer, code, info)
         }
-        Code::None => (State::Nok, 0),
+        Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => tokenizer.go(
             space_or_tab_eol_with_options(EolOptions {
                 content_type: Some(ContentType::String),
@@ -221,7 +221,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnRes
 /// > | "a"
 ///      ^
 /// ```
-fn title(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn title(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.exit(Token::Data);
@@ -233,11 +233,11 @@ fn title(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
         }
         Code::Char('\\') => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| escape(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| escape(t, c, info)))
         }
         _ => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| title(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| title(t, c, info)))
         }
     }
 }
@@ -248,11 +248,11 @@ fn title(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
 /// > | "a\*b"
 ///      ^
 /// ```
-fn escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.consume(code);
-            (State::Fn(Box::new(|t, c| title(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| title(t, c, info)))
         }
         _ => title(tokenizer, code, info),
     }
diff --git a/src/construct/partial_whitespace.rs b/src/construct/partial_whitespace.rs
index 7624ec0..4fc013e 100644
--- a/src/construct/partial_whitespace.rs
+++ b/src/construct/partial_whitespace.rs
@@ -24,10 +24,10 @@
 //! [space_or_tab_eol]: crate::construct::partial_space_or_tab::space_or_tab_eol
 
 use super::partial_space_or_tab::space_or_tab;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Parse initial or final whitespace.
-pub fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
     tokenizer.go(
         // Nothing if there’s no whitespace.
         space_or_tab(),
@@ -45,18 +45,18 @@ pub fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 }
 
 /// After whitespace, at an eol/eof.
-fn at_eol(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn at_eol(tokenizer: &mut Tokenizer, code: Code) -> State {
     if matches!(
         code,
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
     ) {
         ok(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
 /// Fine.
-fn ok(_tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
-    (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+fn ok(_tokenizer: &mut Tokenizer, code: Code) -> State {
+    State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
 }
diff --git a/src/construct/thematic_break.rs b/src/construct/thematic_break.rs
index d87778f..4159146 100644
--- a/src/construct/thematic_break.rs
+++ b/src/construct/thematic_break.rs
@@ -51,7 +51,7 @@
 use super::partial_space_or_tab::{space_or_tab, space_or_tab_min_max};
 use crate::constant::{TAB_SIZE, THEMATIC_BREAK_MARKER_COUNT_MIN};
 use crate::token::Token;
-use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
+use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Type of thematic break.
 #[derive(Debug, PartialEq)]
@@ -134,7 +134,7 @@ struct Info {
 /// > | ***
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -145,7 +145,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         tokenizer.enter(Token::ThematicBreak);
         tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
     } else {
-        (State::Nok, 0)
+        State::Nok
     }
 }
 
@@ -155,7 +155,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ***
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
     match code {
         Code::Char('*' | '-' | '_') => at_break(
             tokenizer,
@@ -165,7 +165,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
                 size: 0,
             },
         ),
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -175,7 +175,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
 /// > | ***
 ///     ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult {
+fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     match code {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
             if info.size >= THEMATIC_BREAK_MARKER_COUNT_MIN =>
@@ -183,13 +183,13 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult
             tokenizer.exit(Token::ThematicBreak);
             // Feel free to interrupt.
             tokenizer.interrupt = false;
-            (State::Ok, if matches!(code, Code::None) { 0 } else { 1 })
+            State::Ok(if matches!(code, Code::None) { 0 } else { 1 })
         }
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.enter(Token::ThematicBreakSequence);
             sequence(tokenizer, code, info)
         }
-        _ => (State::Nok, 0),
+        _ => State::Nok,
     }
 }
 
@@ -199,12 +199,12 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> StateFnResult
 /// > | ***
 ///     ^
 /// ```
-fn sequence(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> StateFnResult {
+fn sequence(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
     match code {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.consume(code);
             info.size += 1;
-            (State::Fn(Box::new(|t, c| sequence(t, c, info))), 0)
+            State::Fn(Box::new(|t, c| sequence(t, c, info)))
         }
         _ => {
             tokenizer.exit(Token::ThematicBreakSequence);