Refactor to not pass codes around

34 files changed, 938 insertions, 993 deletions

diff --git a/src/construct/attention.rs b/src/construct/attention.rs
index a53a328..27d7544 100644
--- a/src/construct/attention.rs
+++ b/src/construct/attention.rs
@@ -168,11 +168,11 @@ struct Sequence {
 /// > | **
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('*' | '_') if tokenizer.parse_state.constructs.attention => {
             tokenizer.enter(Token::AttentionSequence);
-            inside(tokenizer, code, MarkerKind::from_code(code))
+            inside(tokenizer, MarkerKind::from_code(tokenizer.current))
         }
         _ => State::Nok,
     }
@@ -184,11 +184,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | **
 ///     ^^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, marker: MarkerKind) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer, marker: MarkerKind) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == marker.as_char() => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| inside(t, c, marker)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| inside(t, marker)))
         }
         _ => {
             tokenizer.exit(Token::AttentionSequence);
diff --git a/src/construct/autolink.rs b/src/construct/autolink.rs
index 0c5a328..3933596 100644
--- a/src/construct/autolink.rs
+++ b/src/construct/autolink.rs
@@ -113,12 +113,12 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// > | a<user@example.com>b
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('<') if tokenizer.parse_state.constructs.autolink => {
             tokenizer.enter(Token::Autolink);
             tokenizer.enter(Token::AutolinkMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::AutolinkMarker);
             tokenizer.enter(Token::AutolinkProtocol);
             State::Fn(Box::new(open))
@@ -135,13 +135,13 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a<user@example.com>b
 ///       ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(char) if char.is_ascii_alphabetic() => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(scheme_or_email_atext))
         }
-        Code::Char(char) if is_ascii_atext(char) => email_atext(tokenizer, code),
+        Code::Char(char) if is_ascii_atext(char) => email_atext(tokenizer),
         _ => State::Nok,
     }
 }
@@ -154,12 +154,12 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a<user@example.com>b
 ///        ^
 /// ```
-fn scheme_or_email_atext(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn scheme_or_email_atext(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('+' | '-' | '.' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
-            scheme_inside_or_email_atext(tokenizer, code, 1)
+            scheme_inside_or_email_atext(tokenizer, 1)
         }
-        _ => email_atext(tokenizer, code),
+        _ => email_atext(tokenizer),
     }
 }
 
@@ -171,21 +171,19 @@ fn scheme_or_email_atext(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a<user@example.com>b
 ///        ^
 /// ```
-fn scheme_inside_or_email_atext(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
-    match code {
+fn scheme_inside_or_email_atext(tokenizer: &mut Tokenizer, size: usize) -> State {
+    match tokenizer.current {
         Code::Char(':') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             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)
-            }))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| scheme_inside_or_email_atext(t, size + 1)))
         }
-        _ => email_atext(tokenizer, code),
+        _ => email_atext(tokenizer),
     }
 }
 
@@ -195,18 +193,18 @@ fn scheme_inside_or_email_atext(tokenizer: &mut Tokenizer, code: Code, size: usi
 /// > | a<https://example.com>b
 ///             ^
 /// ```
-fn url_inside(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn url_inside(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
             tokenizer.exit(Token::AutolinkProtocol);
-            end(tokenizer, code)
+            end(tokenizer)
         }
         Code::Char(char) if char.is_ascii_control() => State::Nok,
         Code::None | Code::CarriageReturnLineFeed | Code::VirtualSpace | Code::Char(' ') => {
             State::Nok
         }
         Code::Char(_) => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(url_inside))
         }
     }
@@ -218,14 +216,14 @@ fn url_inside(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a<user.name@example.com>b
 ///              ^
 /// ```
-fn email_atext(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn email_atext(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('@') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| email_at_sign_or_dot(t, c, 0)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| email_at_sign_or_dot(t, 0)))
         }
         Code::Char(char) if is_ascii_atext(char) => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(email_atext))
         }
         _ => State::Nok,
@@ -238,9 +236,9 @@ fn email_atext(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a<user.name@example.com>b
 ///                 ^       ^
 /// ```
-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),
+fn email_at_sign_or_dot(tokenizer: &mut Tokenizer, size: usize) -> State {
+    match tokenizer.current {
+        Code::Char(char) if char.is_ascii_alphanumeric() => email_value(tokenizer, size),
         _ => State::Nok,
     }
 }
@@ -251,11 +249,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) -> State {
-    match code {
+fn email_label(tokenizer: &mut Tokenizer, size: usize) -> State {
+    match tokenizer.current {
         Code::Char('.') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| email_at_sign_or_dot(t, c, 0)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| email_at_sign_or_dot(t, 0)))
         }
         Code::Char('>') => {
             let index = tokenizer.events.len();
@@ -263,9 +261,9 @@ fn email_label(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
             // Change the token type.
             tokenizer.events[index - 1].token_type = Token::AutolinkEmail;
             tokenizer.events[index].token_type = Token::AutolinkEmail;
-            end(tokenizer, code)
+            end(tokenizer)
         }
-        _ => email_value(tokenizer, code, size),
+        _ => email_value(tokenizer, size),
     }
 }
 
@@ -277,15 +275,15 @@ fn email_label(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
 /// > | a<user.name@ex-ample.com>b
 ///                    ^
 /// ```
-fn email_value(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
-    match code {
+fn email_value(tokenizer: &mut Tokenizer, size: usize) -> State {
+    match tokenizer.current {
         Code::Char('-') if size < AUTOLINK_DOMAIN_SIZE_MAX => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| email_value(t, c, size + 1)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| email_value(t, 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)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| email_label(t, size + 1)))
         }
         _ => State::Nok,
     }
@@ -299,11 +297,11 @@ fn email_value(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
 /// > | a<user@example.com>b
 ///                       ^
 /// ```
-fn end(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn end(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
             tokenizer.enter(Token::AutolinkMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::AutolinkMarker);
             tokenizer.exit(Token::Autolink);
             State::Ok
diff --git a/src/construct/blank_line.rs b/src/construct/blank_line.rs
index 48cf2e6..537ffc1 100644
--- a/src/construct/blank_line.rs
+++ b/src/construct/blank_line.rs
@@ -45,8 +45,8 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// > |
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(space_or_tab(), after)(tokenizer, code)
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(space_or_tab(), after)(tokenizer)
 }
 
 /// After zero or more spaces or tabs, before a line ending or EOF.
@@ -57,8 +57,8 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |
 ///     ^
 /// ```
-fn after(_tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => State::Ok,
         _ => State::Nok,
     }
diff --git a/src/construct/block_quote.rs b/src/construct/block_quote.rs
index b99665f..3bb4b8b 100644
--- a/src/construct/block_quote.rs
+++ b/src/construct/block_quote.rs
@@ -44,14 +44,14 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// > | > a
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
         usize::MAX
     };
     if tokenizer.parse_state.constructs.block_quote {
-        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer)
     } else {
         State::Nok
     }
@@ -63,13 +63,13 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | > a
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
             tokenizer.enter(Token::BlockQuote);
-            cont_before(tokenizer, code)
+            cont_before(tokenizer)
         }
-        _ => cont_before(tokenizer, code),
+        _ => cont_before(tokenizer),
     }
 }
 
@@ -80,13 +80,13 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | > b
 ///     ^
 /// ```
-pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn cont(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
         usize::MAX
     };
-    tokenizer.go(space_or_tab_min_max(0, max), cont_before)(tokenizer, code)
+    tokenizer.go(space_or_tab_min_max(0, max), cont_before)(tokenizer)
 }
 
 /// After whitespace, before `>`.
@@ -96,12 +96,12 @@ pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | > b
 ///     ^
 /// ```
-fn cont_before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn cont_before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
             tokenizer.enter(Token::BlockQuotePrefix);
             tokenizer.enter(Token::BlockQuoteMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::BlockQuoteMarker);
             State::Fn(Box::new(cont_after))
         }
@@ -117,11 +117,11 @@ fn cont_before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | >b
 ///      ^
 /// ```
-fn cont_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn cont_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.enter(Token::SpaceOrTab);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::SpaceOrTab);
             tokenizer.exit(Token::BlockQuotePrefix);
             State::Ok
diff --git a/src/construct/character_escape.rs b/src/construct/character_escape.rs
index f317854..9e9b713 100644
--- a/src/construct/character_escape.rs
+++ b/src/construct/character_escape.rs
@@ -42,12 +42,12 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// > | a\*b
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('\\') if tokenizer.parse_state.constructs.character_escape => {
             tokenizer.enter(Token::CharacterEscape);
             tokenizer.enter(Token::CharacterEscapeMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::CharacterEscapeMarker);
             State::Fn(Box::new(inside))
         }
@@ -61,11 +61,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a\*b
 ///       ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(char) if char.is_ascii_punctuation() => {
             tokenizer.enter(Token::CharacterEscapeValue);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::CharacterEscapeValue);
             tokenizer.exit(Token::CharacterEscape);
             State::Ok
diff --git a/src/construct/character_reference.rs b/src/construct/character_reference.rs
index 6e44502..8521f15 100644
--- a/src/construct/character_reference.rs
+++ b/src/construct/character_reference.rs
@@ -136,12 +136,12 @@ struct Info {
 /// > | a&#x9;b
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('&') if tokenizer.parse_state.constructs.character_reference => {
             tokenizer.enter(Token::CharacterReference);
             tokenizer.enter(Token::CharacterReferenceMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::CharacterReferenceMarker);
             State::Fn(Box::new(open))
         }
@@ -160,19 +160,19 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a&#x9;b
 ///       ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn open(tokenizer: &mut Tokenizer) -> State {
     let info = Info {
         buffer: String::new(),
         kind: Kind::Named,
     };
-    if let Code::Char('#') = code {
+    if let Code::Char('#') = tokenizer.current {
         tokenizer.enter(Token::CharacterReferenceMarkerNumeric);
-        tokenizer.consume(code);
+        tokenizer.consume();
         tokenizer.exit(Token::CharacterReferenceMarkerNumeric);
-        State::Fn(Box::new(|t, c| numeric(t, c, info)))
+        State::Fn(Box::new(|t| numeric(t, info)))
     } else {
         tokenizer.enter(Token::CharacterReferenceValue);
-        value(tokenizer, code, info)
+        value(tokenizer, info)
     }
 }
 
@@ -185,18 +185,18 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a&#x9;b
 ///        ^
 /// ```
-fn numeric(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    if let Code::Char('x' | 'X') = code {
+fn numeric(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    if let Code::Char('x' | 'X') = tokenizer.current {
         tokenizer.enter(Token::CharacterReferenceMarkerHexadecimal);
-        tokenizer.consume(code);
+        tokenizer.consume();
         tokenizer.exit(Token::CharacterReferenceMarkerHexadecimal);
         tokenizer.enter(Token::CharacterReferenceValue);
         info.kind = Kind::Hexadecimal;
-        State::Fn(Box::new(|t, c| value(t, c, info)))
+        State::Fn(Box::new(|t| value(t, info)))
     } else {
         tokenizer.enter(Token::CharacterReferenceValue);
         info.kind = Kind::Decimal;
-        value(tokenizer, code, info)
+        value(tokenizer, info)
     }
 }
 
@@ -213,8 +213,8 @@ fn numeric(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | a&#x9;b
 ///         ^
 /// ```
-fn value(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn value(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char(';') if !info.buffer.is_empty() => {
             let unknown_named = Kind::Named == info.kind
                 && !CHARACTER_REFERENCES.iter().any(|d| d.0 == info.buffer);
@@ -224,7 +224,7 @@ fn value(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
             } else {
                 tokenizer.exit(Token::CharacterReferenceValue);
                 tokenizer.enter(Token::CharacterReferenceMarkerSemi);
-                tokenizer.consume(code);
+                tokenizer.consume();
                 tokenizer.exit(Token::CharacterReferenceMarkerSemi);
                 tokenizer.exit(Token::CharacterReference);
                 State::Ok
@@ -233,8 +233,8 @@ fn value(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
         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)))
+                tokenizer.consume();
+                State::Fn(Box::new(|t| value(t, info)))
             } else {
                 State::Nok
             }
diff --git a/src/construct/code_fenced.rs b/src/construct/code_fenced.rs
index 10968c2..2fea95e 100644
--- a/src/construct/code_fenced.rs
+++ b/src/construct/code_fenced.rs
@@ -188,7 +188,7 @@ struct Info {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -197,7 +197,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     if tokenizer.parse_state.constructs.code_fenced {
         tokenizer.enter(Token::CodeFenced);
         tokenizer.enter(Token::CodeFencedFence);
-        tokenizer.go(space_or_tab_min_max(0, max), before_sequence_open)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, max), before_sequence_open)(tokenizer)
     } else {
         State::Nok
     }
@@ -211,7 +211,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn before_sequence_open(tokenizer: &mut Tokenizer) -> State {
     let tail = tokenizer.events.last();
     let mut prefix = 0;
 
@@ -222,16 +222,15 @@ fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> State {
         }
     }
 
-    match code {
+    match tokenizer.current {
         Code::Char('`' | '~') => {
             tokenizer.enter(Token::CodeFencedFenceSequence);
             sequence_open(
                 tokenizer,
-                code,
                 Info {
                     prefix,
                     size: 0,
-                    kind: Kind::from_code(code),
+                    kind: Kind::from_code(tokenizer.current),
                 },
             )
         }
@@ -247,18 +246,18 @@ fn before_sequence_open(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn sequence_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn sequence_open(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| {
+            tokenizer.consume();
+            State::Fn(Box::new(|t| {
                 info.size += 1;
-                sequence_open(t, c, info)
+                sequence_open(t, 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)
+            tokenizer.attempt_opt(space_or_tab(), |t| info_before(t, info))(tokenizer)
         }
         _ => State::Nok,
     }
@@ -272,18 +271,18 @@ 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) -> State {
-    match code {
+fn info_before(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFencedFence);
             // Do not form containers.
             tokenizer.concrete = true;
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         _ => {
             tokenizer.enter(Token::CodeFencedFenceInfo);
             tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
-            info_inside(tokenizer, code, info, vec![])
+            info_inside(tokenizer, info, vec![])
         }
     }
 }
@@ -296,26 +295,26 @@ fn info_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn info_inside(tokenizer: &mut Tokenizer, code: Code, info: Info, mut codes: Vec<Code>) -> State {
-    match code {
+fn info_inside(tokenizer: &mut Tokenizer, info: Info, mut codes: Vec<Code>) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(Token::CodeFencedFenceInfo);
             tokenizer.exit(Token::CodeFencedFence);
             // Do not form containers.
             tokenizer.concrete = true;
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(Token::CodeFencedFenceInfo);
-            tokenizer.attempt_opt(space_or_tab(), |t, c| meta_before(t, c, info))(tokenizer, code)
+            tokenizer.attempt_opt(space_or_tab(), |t| meta_before(t, info))(tokenizer)
         }
         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)))
+            codes.push(tokenizer.current);
+            tokenizer.consume();
+            State::Fn(Box::new(|t| info_inside(t, info, codes)))
         }
     }
 }
@@ -328,18 +327,18 @@ fn info_inside(tokenizer: &mut Tokenizer, code: Code, info: Info, mut codes: Vec
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn meta_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn meta_before(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFencedFence);
             // Do not form containers.
             tokenizer.concrete = true;
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         _ => {
             tokenizer.enter(Token::CodeFencedFenceMeta);
             tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
-            meta(tokenizer, code, info)
+            meta(tokenizer, info)
         }
     }
 }
@@ -352,20 +351,20 @@ fn meta_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///   | console.log(1)
 ///   | ~~~
 /// ```
-fn meta(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn meta(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(Token::CodeFencedFenceMeta);
             tokenizer.exit(Token::CodeFencedFence);
             // Do not form containers.
             tokenizer.concrete = true;
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         Code::Char('`') if info.kind == Kind::GraveAccent => State::Nok,
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| meta(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| meta(t, info)))
         }
     }
 }
@@ -379,14 +378,14 @@ fn meta(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///                   ^
 ///   | ~~~
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn at_break(tokenizer: &mut Tokenizer, info: Info) -> State {
     tokenizer.check(partial_non_lazy_continuation, |ok| {
         if ok {
-            Box::new(move |t, c| at_non_lazy_break(t, c, info))
+            Box::new(move |t| at_non_lazy_break(t, info))
         } else {
             Box::new(after)
         }
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// At an eol/eof in code, before a non-lazy closing fence or content.
@@ -398,19 +397,19 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///                   ^
 ///   | ~~~
 /// ```
-fn at_non_lazy_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn at_non_lazy_break(tokenizer: &mut Tokenizer, info: Info) -> State {
     let clone = info.clone();
 
     tokenizer.attempt(
-        |t, c| close_begin(t, c, info),
+        |t| close_begin(t, info),
         |ok| {
             if ok {
                 Box::new(after)
             } else {
-                Box::new(|t, c| content_before(t, c, clone))
+                Box::new(|t| content_before(t, clone))
             }
         },
-    )(tokenizer, code)
+    )(tokenizer)
 }
 
 /// Before a closing fence, at the line ending.
@@ -421,13 +420,13 @@ fn at_non_lazy_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State
 ///                   ^
 ///   | ~~~
 /// ```
-fn close_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn close_begin(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(Box::new(|t, c| close_start(t, c, info)))
+            State::Fn(Box::new(|t| close_start(t, info)))
         }
         _ => unreachable!("expected eol"),
     }
@@ -441,7 +440,7 @@ fn close_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | ~~~
 ///     ^
 /// ```
-fn close_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn close_start(tokenizer: &mut Tokenizer, info: Info) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -449,9 +448,7 @@ fn close_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     };
 
     tokenizer.enter(Token::CodeFencedFence);
-    tokenizer.go(space_or_tab_min_max(0, max), |t, c| {
-        close_before(t, c, info)
-    })(tokenizer, code)
+    tokenizer.go(space_or_tab_min_max(0, max), |t| close_before(t, info))(tokenizer)
 }
 
 /// In a closing fence, after optional whitespace, before sequence.
@@ -462,11 +459,11 @@ fn close_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | ~~~
 ///     ^
 /// ```
-fn close_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn close_before(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.enter(Token::CodeFencedFenceSequence);
-            close_sequence(tokenizer, code, info, 0)
+            close_sequence(tokenizer, info, 0)
         }
         _ => State::Nok,
     }
@@ -480,15 +477,15 @@ fn close_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | ~~~
 ///     ^
 /// ```
-fn close_sequence(tokenizer: &mut Tokenizer, code: Code, info: Info, size: usize) -> State {
-    match code {
+fn close_sequence(tokenizer: &mut Tokenizer, info: Info, size: usize) -> State {
+    match tokenizer.current {
         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)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| close_sequence(t, 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)
+            tokenizer.attempt_opt(space_or_tab(), close_sequence_after)(tokenizer)
         }
         _ => State::Nok,
     }
@@ -502,8 +499,8 @@ fn close_sequence(tokenizer: &mut Tokenizer, code: Code, info: Info, size: usize
 /// > | ~~~
 ///        ^
 /// ```
-fn close_sequence_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn close_sequence_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFencedFence);
             State::Ok
@@ -520,11 +517,11 @@ fn close_sequence_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///                   ^
 ///   | ~~~
 /// ```
-fn content_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn content_before(tokenizer: &mut Tokenizer, info: Info) -> State {
     tokenizer.enter(Token::LineEnding);
-    tokenizer.consume(code);
+    tokenizer.consume();
     tokenizer.exit(Token::LineEnding);
-    State::Fn(Box::new(|t, c| content_start(t, c, info)))
+    State::Fn(Box::new(|t| content_start(t, info)))
 }
 /// Before code content, definitely not before a closing fence.
 ///
@@ -534,10 +531,10 @@ fn content_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///     ^
 ///   | ~~~
 /// ```
-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)
+fn content_start(tokenizer: &mut Tokenizer, info: Info) -> State {
+    tokenizer.go(space_or_tab_min_max(0, info.prefix), |t| {
+        content_begin(t, info)
+    })(tokenizer)
 }
 
 /// Before code content, after a prefix.
@@ -548,14 +545,14 @@ fn content_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///     ^
 ///   | ~~~
 /// ```
-fn content_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn content_begin(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         _ => {
             tokenizer.enter(Token::CodeFlowChunk);
-            content_continue(tokenizer, code, info)
+            content_continue(tokenizer, info)
         }
     }
 }
@@ -568,15 +565,15 @@ fn content_begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///     ^^^^^^^^^^^^^^
 ///   | ~~~
 /// ```
-fn content_continue(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn content_continue(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFlowChunk);
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| content_continue(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| content_continue(t, info)))
         }
     }
 }
@@ -589,7 +586,7 @@ fn content_continue(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State
 /// > | ~~~
 ///        ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.exit(Token::CodeFenced);
     // Feel free to interrupt.
     tokenizer.interrupt = false;
diff --git a/src/construct/code_indented.rs b/src/construct/code_indented.rs
index f223633..015c4a0 100644
--- a/src/construct/code_indented.rs
+++ b/src/construct/code_indented.rs
@@ -60,13 +60,13 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// > |     aaa
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     // Do not interrupt paragraphs.
     if tokenizer.interrupt || !tokenizer.parse_state.constructs.code_indented {
         State::Nok
     } else {
         tokenizer.enter(Token::CodeIndented);
-        tokenizer.go(space_or_tab_min_max(TAB_SIZE, TAB_SIZE), at_break)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(TAB_SIZE, TAB_SIZE), at_break)(tokenizer)
     }
 }
 
@@ -76,16 +76,16 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |     aaa
 ///         ^  ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
-        Code::None => after(tokenizer, code),
+fn at_break(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
+        Code::None => after(tokenizer),
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => tokenizer
             .attempt(further_start, |ok| {
                 Box::new(if ok { at_break } else { after })
-            })(tokenizer, code),
+            })(tokenizer),
         _ => {
             tokenizer.enter(Token::CodeFlowChunk);
-            content(tokenizer, code)
+            content(tokenizer)
         }
     }
 }
@@ -96,14 +96,14 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |     aaa
 ///         ^^^^
 /// ```
-fn content(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn content(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::CodeFlowChunk);
-            at_break(tokenizer, code)
+            at_break(tokenizer)
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(content))
         }
     }
@@ -115,7 +115,7 @@ fn content(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |     aaa
 ///            ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.exit(Token::CodeIndented);
     // Feel free to interrupt.
     tokenizer.interrupt = false;
@@ -129,20 +129,20 @@ fn after(tokenizer: &mut Tokenizer, _code: Code) -> State {
 ///            ^
 ///   |     bbb
 /// ```
-fn further_start(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn further_start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.lazy {
         State::Nok
     } else {
-        match code {
+        match tokenizer.current {
             Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
                 tokenizer.enter(Token::LineEnding);
-                tokenizer.consume(code);
+                tokenizer.consume();
                 tokenizer.exit(Token::LineEnding);
                 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 })
-            })(tokenizer, code),
+            })(tokenizer),
         }
     }
 }
@@ -154,7 +154,7 @@ fn further_start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |     bbb
 ///         ^
 /// ```
-fn further_end(_tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn further_end(_tokenizer: &mut Tokenizer) -> State {
     State::Ok
 }
 
@@ -165,8 +165,8 @@ fn further_end(_tokenizer: &mut Tokenizer, _code: Code) -> State {
 /// > |   bbb
 ///     ^
 /// ```
-fn further_begin(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(space_or_tab(), further_after)(tokenizer, code)
+fn further_begin(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(space_or_tab(), further_after)(tokenizer)
 }
 
 /// After whitespace, not indented enough.
@@ -176,9 +176,9 @@ fn further_begin(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |   bbb
 ///       ^
 /// ```
-fn further_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
-        Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => further_start(tokenizer, code),
+fn further_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
+        Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => further_start(tokenizer),
         _ => State::Nok,
     }
 }
diff --git a/src/construct/code_text.rs b/src/construct/code_text.rs
index 978ad01..f5f92fc 100644
--- a/src/construct/code_text.rs
+++ b/src/construct/code_text.rs
@@ -94,10 +94,10 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// > | \`a`
 ///      ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let len = tokenizer.events.len();
 
-    match code {
+    match tokenizer.current {
         Code::Char('`')
             if tokenizer.parse_state.constructs.code_text
                 && (tokenizer.previous != Code::Char('`')
@@ -106,7 +106,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
         {
             tokenizer.enter(Token::CodeText);
             tokenizer.enter(Token::CodeTextSequence);
-            sequence_open(tokenizer, code, 0)
+            sequence_open(tokenizer, 0)
         }
         _ => State::Nok,
     }
@@ -118,13 +118,13 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | `a`
 ///     ^
 /// ```
-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)))
+fn sequence_open(tokenizer: &mut Tokenizer, size: usize) -> State {
+    if let Code::Char('`') = tokenizer.current {
+        tokenizer.consume();
+        State::Fn(Box::new(move |t| sequence_open(t, size + 1)))
     } else {
         tokenizer.exit(Token::CodeTextSequence);
-        between(tokenizer, code, size)
+        between(tokenizer, size)
     }
 }
 
@@ -134,22 +134,22 @@ fn sequence_open(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
 /// > | `a`
 ///      ^^
 /// ```
-fn between(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> State {
-    match code {
+fn between(tokenizer: &mut Tokenizer, size_open: usize) -> State {
+    match tokenizer.current {
         Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(Box::new(move |t, c| between(t, c, size_open)))
+            State::Fn(Box::new(move |t| between(t, size_open)))
         }
         Code::Char('`') => {
             tokenizer.enter(Token::CodeTextSequence);
-            sequence_close(tokenizer, code, size_open, 0)
+            sequence_close(tokenizer, size_open, 0)
         }
         _ => {
             tokenizer.enter(Token::CodeTextData);
-            data(tokenizer, code, size_open)
+            data(tokenizer, size_open)
         }
     }
 }
@@ -160,15 +160,15 @@ fn between(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> State {
 /// > | `a`
 ///      ^
 /// ```
-fn data(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> State {
-    match code {
+fn data(tokenizer: &mut Tokenizer, size_open: usize) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r' | '`') => {
             tokenizer.exit(Token::CodeTextData);
-            between(tokenizer, code, size_open)
+            between(tokenizer, size_open)
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| data(t, c, size_open)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| data(t, size_open)))
         }
     }
 }
@@ -179,13 +179,11 @@ fn data(tokenizer: &mut Tokenizer, code: Code, size_open: usize) -> State {
 /// > | `a`
 ///       ^
 /// ```
-fn sequence_close(tokenizer: &mut Tokenizer, code: Code, size_open: usize, size: usize) -> State {
-    match code {
+fn sequence_close(tokenizer: &mut Tokenizer, size_open: usize, size: usize) -> State {
+    match tokenizer.current {
         Code::Char('`') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| {
-                sequence_close(t, c, size_open, size + 1)
-            }))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| sequence_close(t, size_open, size + 1)))
         }
         _ if size_open == size => {
             tokenizer.exit(Token::CodeTextSequence);
@@ -198,7 +196,7 @@ fn sequence_close(tokenizer: &mut Tokenizer, code: Code, size_open: usize, size:
             // Change the token type.
             tokenizer.events[index - 1].token_type = Token::CodeTextData;
             tokenizer.events[index].token_type = Token::CodeTextData;
-            between(tokenizer, code, size_open)
+            between(tokenizer, size_open)
         }
     }
 }
diff --git a/src/construct/definition.rs b/src/construct/definition.rs
index 093b9e5..ffaaa98 100644
--- a/src/construct/definition.rs
+++ b/src/construct/definition.rs
@@ -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) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let definition_before = !tokenizer.events.is_empty()
         && tokenizer.events[skip_opt_back(
             &tokenizer.events,
@@ -123,7 +123,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
     if (!tokenizer.interrupt || definition_before) && tokenizer.parse_state.constructs.definition {
         tokenizer.enter(Token::Definition);
         // Note: arbitrary whitespace allowed even if code (indented) is on.
-        tokenizer.attempt_opt(space_or_tab(), before)(tokenizer, code)
+        tokenizer.attempt_opt(space_or_tab(), before)(tokenizer)
     } else {
         State::Nok
     }
@@ -135,13 +135,12 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('[') => tokenizer.go(
-            |t, c| {
+            |t| {
                 label(
                     t,
-                    c,
                     LabelOptions {
                         label: Token::DefinitionLabel,
                         marker: Token::DefinitionLabelMarker,
@@ -150,7 +149,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
                 )
             },
             label_after,
-        )(tokenizer, code),
+        )(tokenizer),
         _ => State::Nok,
     }
 }
@@ -161,11 +160,11 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///        ^
 /// ```
-fn label_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn label_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(':') => {
             tokenizer.enter(Token::DefinitionMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::DefinitionMarker);
             State::Fn(Box::new(
                 tokenizer.attempt_opt(space_or_tab_eol(), destination_before),
@@ -181,12 +180,11 @@ fn label_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///          ^
 /// ```
-fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn destination_before(tokenizer: &mut Tokenizer) -> State {
     tokenizer.go(
-        |t, c| {
+        |t| {
             destination(
                 t,
-                c,
                 DestinationOptions {
                     limit: usize::MAX,
                     destination: Token::DefinitionDestination,
@@ -198,7 +196,7 @@ fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> State {
             )
         },
         destination_after,
-    )(tokenizer, code)
+    )(tokenizer)
 }
 
 /// After a destination.
@@ -207,8 +205,8 @@ fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///           ^
 /// ```
-fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(title_before, after)(tokenizer, code)
+fn destination_after(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(title_before, after)(tokenizer)
 }
 
 /// After a definition.
@@ -219,8 +217,8 @@ fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(space_or_tab(), after_whitespace)(tokenizer, code)
+fn after(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(space_or_tab(), after_whitespace)(tokenizer)
 }
 
 /// After a definition, after optional whitespace.
@@ -231,8 +229,8 @@ fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn after_whitespace(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Definition);
             // You’d be interrupting.
@@ -251,8 +249,8 @@ fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///           ^
 /// ```
-fn title_before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.go(space_or_tab_eol(), title_before_marker)(tokenizer, code)
+fn title_before(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.go(space_or_tab_eol(), title_before_marker)(tokenizer)
 }
 
 /// Before a title, after a line ending.
@@ -262,12 +260,11 @@ fn title_before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | "c"
 ///     ^
 /// ```
-fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn title_before_marker(tokenizer: &mut Tokenizer) -> State {
     tokenizer.go(
-        |t, c| {
+        |t| {
             title(
                 t,
-                c,
                 TitleOptions {
                     title: Token::DefinitionTitle,
                     marker: Token::DefinitionTitleMarker,
@@ -276,7 +273,7 @@ fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> State {
             )
         },
         title_after,
-    )(tokenizer, code)
+    )(tokenizer)
 }
 
 /// After a title.
@@ -285,8 +282,8 @@ fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn title_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(space_or_tab(), title_after_after_optional_whitespace)(tokenizer, code)
+fn title_after(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(space_or_tab(), title_after_after_optional_whitespace)(tokenizer)
 }
 
 /// After a title, after optional whitespace.
@@ -295,8 +292,8 @@ fn title_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a]: b "c"
 ///               ^
 /// ```
-fn title_after_after_optional_whitespace(_tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn title_after_after_optional_whitespace(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => State::Ok,
         _ => State::Nok,
     }
diff --git a/src/construct/hard_break_escape.rs b/src/construct/hard_break_escape.rs
index 85a64f7..d45d685 100644
--- a/src/construct/hard_break_escape.rs
+++ b/src/construct/hard_break_escape.rs
@@ -50,12 +50,12 @@ use crate::tokenizer::{Code, State, Tokenizer};
 ///      ^
 ///   | b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('\\') if tokenizer.parse_state.constructs.hard_break_escape => {
             tokenizer.enter(Token::HardBreakEscape);
             tokenizer.enter(Token::HardBreakEscapeMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::HardBreakEscapeMarker);
             State::Fn(Box::new(inside))
         }
@@ -70,8 +70,8 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///       ^
 ///   | b
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HardBreakEscape);
             State::Ok
diff --git a/src/construct/hard_break_trailing.rs b/src/construct/hard_break_trailing.rs
index 1d1f10f..f0ef83b 100644
--- a/src/construct/hard_break_trailing.rs
+++ b/src/construct/hard_break_trailing.rs
@@ -51,13 +51,13 @@ use crate::tokenizer::{Code, State, Tokenizer};
 ///      ^
 ///   | b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         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)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| inside(t, 1)))
         }
         _ => State::Nok,
     }
@@ -70,11 +70,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///      ^
 ///   | b
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer, size: usize) -> State {
+    match tokenizer.current {
         Code::Char(' ') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| inside(t, c, size + 1)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| inside(t, size + 1)))
         }
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
             if size >= HARD_BREAK_PREFIX_SIZE_MIN =>
diff --git a/src/construct/heading_atx.rs b/src/construct/heading_atx.rs
index 65022d5..5de9a80 100644
--- a/src/construct/heading_atx.rs
+++ b/src/construct/heading_atx.rs
@@ -65,7 +65,7 @@ use crate::tokenizer::{Code, ContentType, Event, EventType, State, Tokenizer};
 /// > | ## aa
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -74,7 +74,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 
     if tokenizer.parse_state.constructs.heading_atx {
         tokenizer.enter(Token::HeadingAtx);
-        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer)
     } else {
         State::Nok
     }
@@ -86,10 +86,10 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ## aa
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    if Code::Char('#') == code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    if Code::Char('#') == tokenizer.current {
         tokenizer.enter(Token::HeadingAtxSequence);
-        sequence_open(tokenizer, code, 0)
+        sequence_open(tokenizer, 0)
     } else {
         State::Nok
     }
@@ -101,21 +101,21 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ## aa
 ///     ^
 /// ```
-fn sequence_open(tokenizer: &mut Tokenizer, code: Code, rank: usize) -> State {
-    match code {
+fn sequence_open(tokenizer: &mut Tokenizer, rank: usize) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') if rank > 0 => {
             tokenizer.exit(Token::HeadingAtxSequence);
-            at_break(tokenizer, code)
+            at_break(tokenizer)
         }
         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)
+            tokenizer.consume();
+            State::Fn(Box::new(move |tokenizer| {
+                sequence_open(tokenizer, rank + 1)
             }))
         }
         _ if rank > 0 => {
             tokenizer.exit(Token::HeadingAtxSequence);
-            tokenizer.go(space_or_tab(), at_break)(tokenizer, code)
+            tokenizer.go(space_or_tab(), at_break)(tokenizer)
         }
         _ => State::Nok,
     }
@@ -127,8 +127,8 @@ fn sequence_open(tokenizer: &mut Tokenizer, code: Code, rank: usize) -> State {
 /// > | ## aa
 ///       ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn at_break(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HeadingAtx);
             tokenizer.register_resolver("heading_atx".to_string(), Box::new(resolve));
@@ -137,15 +137,15 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
             State::Ok
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.go(space_or_tab(), at_break)(tokenizer, code)
+            tokenizer.go(space_or_tab(), at_break)(tokenizer)
         }
         Code::Char('#') => {
             tokenizer.enter(Token::HeadingAtxSequence);
-            further_sequence(tokenizer, code)
+            further_sequence(tokenizer)
         }
         Code::Char(_) => {
             tokenizer.enter_with_content(Token::Data, Some(ContentType::Text));
-            data(tokenizer, code)
+            data(tokenizer)
         }
     }
 }
@@ -158,13 +158,13 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ## aa ##
 ///           ^
 /// ```
-fn further_sequence(tokenizer: &mut Tokenizer, code: Code) -> State {
-    if let Code::Char('#') = code {
-        tokenizer.consume(code);
+fn further_sequence(tokenizer: &mut Tokenizer) -> State {
+    if let Code::Char('#') = tokenizer.current {
+        tokenizer.consume();
         State::Fn(Box::new(further_sequence))
     } else {
         tokenizer.exit(Token::HeadingAtxSequence);
-        at_break(tokenizer, code)
+        at_break(tokenizer)
     }
 }
 
@@ -174,15 +174,15 @@ fn further_sequence(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ## aa
 ///        ^
 /// ```
-fn data(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn data(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         // Note: `#` for closing sequence must be preceded by whitespace, otherwise it’s just text.
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\t' | '\n' | '\r' | ' ') => {
             tokenizer.exit(Token::Data);
-            at_break(tokenizer, code)
+            at_break(tokenizer)
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(data))
         }
     }
diff --git a/src/construct/heading_setext.rs b/src/construct/heading_setext.rs
index 7ac2eb6..a0f7545 100644
--- a/src/construct/heading_setext.rs
+++ b/src/construct/heading_setext.rs
@@ -116,7 +116,7 @@ impl Kind {
 /// > | ==
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -133,7 +133,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 
     // Require a paragraph before and do not allow on a lazy line.
     if paragraph_before && !tokenizer.lazy && tokenizer.parse_state.constructs.heading_setext {
-        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer)
     } else {
         State::Nok
     }
@@ -146,11 +146,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ==
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == '-' || char == '=' => {
             tokenizer.enter(Token::HeadingSetextUnderline);
-            inside(tokenizer, code, Kind::from_char(char))
+            inside(tokenizer, Kind::from_char(char))
         }
         _ => State::Nok,
     }
@@ -163,15 +163,15 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ==
 ///     ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, kind: Kind) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer, kind: Kind) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == kind.as_char() => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| inside(t, c, kind)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| inside(t, kind)))
         }
         _ => {
             tokenizer.exit(Token::HeadingSetextUnderline);
-            tokenizer.attempt_opt(space_or_tab(), after)(tokenizer, code)
+            tokenizer.attempt_opt(space_or_tab(), after)(tokenizer)
         }
     }
 }
@@ -183,8 +183,8 @@ fn inside(tokenizer: &mut Tokenizer, code: Code, kind: Kind) -> State {
 /// > | ==
 ///       ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             // Feel free to interrupt.
             tokenizer.interrupt = false;
diff --git a/src/construct/html_flow.rs b/src/construct/html_flow.rs
index 30c14a1..24d6f98 100644
--- a/src/construct/html_flow.rs
+++ b/src/construct/html_flow.rs
@@ -203,7 +203,7 @@ struct Info {
 /// > | <x />
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -221,7 +221,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
                 content_type: None,
             }),
             before,
-        )(tokenizer, code)
+        )(tokenizer)
     } else {
         State::Nok
     }
@@ -233,10 +233,10 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | <x />
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    if Code::Char('<') == code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    if Code::Char('<') == tokenizer.current {
         tokenizer.enter(Token::HtmlFlowData);
-        tokenizer.consume(code);
+        tokenizer.consume();
         State::Fn(Box::new(open))
     } else {
         State::Nok
@@ -253,7 +253,7 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | <!--xxx-->
 ///      ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn open(tokenizer: &mut Tokenizer) -> State {
     let mut info = Info {
         // Assume basic.
         kind: Kind::Basic,
@@ -264,27 +264,27 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
         quote: None,
     };
 
-    match code {
+    match tokenizer.current {
         Code::Char('!') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| declaration_open(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| declaration_open(t, info)))
         }
         Code::Char('/') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| tag_close_start(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| tag_close_start(t, info)))
         }
         Code::Char('?') => {
             info.kind = Kind::Instruction;
-            tokenizer.consume(code);
+            tokenizer.consume();
             // Do not form containers.
             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)))
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
             info.start_tag = true;
-            tag_name(tokenizer, code, info)
+            tag_name(tokenizer, info)
         }
         _ => State::Nok,
     }
@@ -300,26 +300,26 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | <![CDATA[>&<]]>
 ///       ^
 /// ```
-fn declaration_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn declaration_open(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.kind = Kind::Comment;
-            State::Fn(Box::new(|t, c| comment_open_inside(t, c, info)))
+            State::Fn(Box::new(|t| comment_open_inside(t, info)))
         }
         Code::Char('[') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.kind = Kind::Cdata;
             info.buffer = parse("CDATA[");
             info.index = 0;
-            State::Fn(Box::new(|t, c| cdata_open_inside(t, c, info)))
+            State::Fn(Box::new(|t| cdata_open_inside(t, info)))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.kind = Kind::Declaration;
             // Do not form containers.
             tokenizer.concrete = true;
-            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
         _ => State::Nok,
     }
@@ -331,13 +331,13 @@ fn declaration_open(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> St
 /// > | <!--xxx-->
 ///        ^
 /// ```
-fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn comment_open_inside(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             // Do not form containers.
             tokenizer.concrete = true;
-            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
         _ => State::Nok,
     }
@@ -349,18 +349,18 @@ 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) -> State {
-    if code == info.buffer[info.index] {
+fn cdata_open_inside(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    if tokenizer.current == info.buffer[info.index] {
         info.index += 1;
-        tokenizer.consume(code);
+        tokenizer.consume();
 
         if info.index == info.buffer.len() {
             info.buffer.clear();
             // Do not form containers.
             tokenizer.concrete = true;
-            State::Fn(Box::new(|t, c| continuation(t, c, info)))
+            State::Fn(Box::new(|t| continuation(t, info)))
         } else {
-            State::Fn(Box::new(|t, c| cdata_open_inside(t, c, info)))
+            State::Fn(Box::new(|t| cdata_open_inside(t, info)))
         }
     } else {
         State::Nok
@@ -373,12 +373,12 @@ 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) -> State {
-    match code {
+fn tag_close_start(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char('A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
-            info.buffer.push(code);
-            State::Fn(Box::new(|t, c| tag_name(t, c, info)))
+            tokenizer.consume();
+            info.buffer.push(tokenizer.current);
+            State::Fn(Box::new(|t| tag_name(t, info)))
         }
         _ => State::Nok,
     }
@@ -392,15 +392,15 @@ 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) -> State {
-    match code {
+fn tag_name(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::None
         | Code::CarriageReturnLineFeed
         | Code::VirtualSpace
         | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => {
             let tag_name_buffer = serialize(&info.buffer, false).to_lowercase();
             let name = tag_name_buffer.as_str();
-            let slash = matches!(code, Code::Char('/'));
+            let slash = matches!(tokenizer.current, Code::Char('/'));
 
             info.buffer.clear();
 
@@ -408,16 +408,16 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 info.kind = Kind::Raw;
                 // Do not form containers.
                 tokenizer.concrete = true;
-                continuation(tokenizer, code, info)
+                continuation(tokenizer, info)
             } else if HTML_BLOCK_NAMES.contains(&name) {
                 // 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)))
+                    tokenizer.consume();
+                    State::Fn(Box::new(|t| basic_self_closing(t, info)))
                 } else {
                     // Do not form containers.
                     tokenizer.concrete = true;
-                    continuation(tokenizer, code, info)
+                    continuation(tokenizer, info)
                 }
             } else {
                 info.kind = Kind::Complete;
@@ -426,16 +426,16 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 if tokenizer.interrupt && !tokenizer.lazy {
                     State::Nok
                 } else if info.start_tag {
-                    complete_attribute_name_before(tokenizer, code, info)
+                    complete_attribute_name_before(tokenizer, info)
                 } else {
-                    complete_closing_tag_after(tokenizer, code, info)
+                    complete_closing_tag_after(tokenizer, info)
                 }
             }
         }
         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)))
+            tokenizer.consume();
+            info.buffer.push(tokenizer.current);
+            State::Fn(Box::new(|t| tag_name(t, info)))
         }
         Code::Char(_) => State::Nok,
     }
@@ -447,13 +447,13 @@ fn tag_name(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | <div/>
 ///          ^
 /// ```
-fn basic_self_closing(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn basic_self_closing(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             // Do not form containers.
             tokenizer.concrete = true;
-            State::Fn(Box::new(|t, c| continuation(t, c, info)))
+            State::Fn(Box::new(|t| continuation(t, info)))
         }
         _ => State::Nok,
     }
@@ -465,13 +465,13 @@ 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) -> State {
-    match code {
+fn complete_closing_tag_after(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_closing_tag_after(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_closing_tag_after(t, info)))
         }
-        _ => complete_end(tokenizer, code, info),
+        _ => complete_end(tokenizer, info),
     }
 }
 
@@ -494,21 +494,21 @@ 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) -> State {
-    match code {
+fn complete_attribute_name_before(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('/') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_end(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_end(t, info)))
         }
         Code::Char('0'..='9' | ':' | 'A'..='Z' | '_' | 'a'..='z') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_name(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_name(t, info)))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_name_before(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_name_before(t, info)))
         }
-        _ => complete_end(tokenizer, code, info),
+        _ => complete_end(tokenizer, info),
     }
 }
 
@@ -522,13 +522,13 @@ fn complete_attribute_name_before(tokenizer: &mut Tokenizer, code: Code, info: I
 /// > | <a b>
 ///         ^
 /// ```
-fn complete_attribute_name(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn complete_attribute_name(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('-' | '.' | '0'..='9' | ':' | 'A'..='Z' | '_' | 'a'..='z') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_name(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_name(t, info)))
         }
-        _ => complete_attribute_name_after(tokenizer, code, info),
+        _ => complete_attribute_name_after(tokenizer, info),
     }
 }
 
@@ -541,17 +541,17 @@ 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) -> State {
-    match code {
+fn complete_attribute_name_after(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('=') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_value_before(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_value_before(t, info)))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_name_after(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_name_after(t, info)))
         }
-        _ => complete_attribute_name_before(tokenizer, code, info),
+        _ => complete_attribute_name_before(tokenizer, info),
     }
 }
 
@@ -564,19 +564,19 @@ fn complete_attribute_name_after(tokenizer: &mut Tokenizer, code: Code, info: In
 /// > | <a b="c">
 ///          ^
 /// ```
-fn complete_attribute_value_before(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn complete_attribute_value_before(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         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)))
+            tokenizer.consume();
+            info.quote = Some(QuoteKind::from_code(tokenizer.current));
+            State::Fn(Box::new(|t| complete_attribute_value_quoted(t, info)))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_value_before(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_value_before(t, info)))
         }
-        _ => complete_attribute_value_unquoted(tokenizer, code, info),
+        _ => complete_attribute_value_unquoted(tokenizer, info),
     }
 }
 
@@ -588,18 +588,16 @@ fn complete_attribute_value_before(tokenizer: &mut Tokenizer, code: Code, mut in
 /// > | <a b='c'>
 ///           ^
 /// ```
-fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         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)
-            }))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_value_quoted_after(t, info)))
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_attribute_value_quoted(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_value_quoted(t, info)))
         }
     }
 }
@@ -610,19 +608,17 @@ fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer, code: Code, info:
 /// > | <a b=c>
 ///          ^
 /// ```
-fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None
         | Code::CarriageReturnLineFeed
         | Code::VirtualSpace
         | Code::Char('\t' | '\n' | '\r' | ' ' | '"' | '\'' | '/' | '<' | '=' | '>' | '`') => {
-            complete_attribute_name_after(tokenizer, code, info)
+            complete_attribute_name_after(tokenizer, info)
         }
         Code::Char(_) => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| {
-                complete_attribute_value_unquoted(t, c, info)
-            }))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_attribute_value_unquoted(t, info)))
         }
     }
 }
@@ -634,14 +630,10 @@ fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code, info
 /// > | <a b="c">
 ///            ^
 /// ```
-fn complete_attribute_value_quoted_after(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    info: Info,
-) -> State {
-    match code {
+fn complete_attribute_value_quoted_after(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::VirtualSpace | Code::Char('\t' | ' ' | '/' | '>') => {
-            complete_attribute_name_before(tokenizer, code, info)
+            complete_attribute_name_before(tokenizer, info)
         }
         _ => State::Nok,
     }
@@ -653,11 +645,11 @@ fn complete_attribute_value_quoted_after(
 /// > | <a b="c">
 ///             ^
 /// ```
-fn complete_end(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn complete_end(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_after(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_after(t, info)))
         }
         _ => State::Nok,
     }
@@ -669,16 +661,16 @@ fn complete_end(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | <x>
 ///        ^
 /// ```
-fn complete_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn complete_after(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             // Do not form containers.
             tokenizer.concrete = true;
-            continuation(tokenizer, code, info)
+            continuation(tokenizer, info)
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| complete_after(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| complete_after(t, info)))
         }
         Code::Char(_) => State::Nok,
     }
@@ -690,29 +682,27 @@ fn complete_after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | <!--xxx-->
 ///          ^
 /// ```
-fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn continuation(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('-') if info.kind == Kind::Comment => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_comment_inside(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_comment_inside(t, info)))
         }
         Code::Char('<') if info.kind == Kind::Raw => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_raw_tag_open(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_raw_tag_open(t, info)))
         }
         Code::Char('>') if info.kind == Kind::Declaration => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_close(t, info)))
         }
         Code::Char('?') if info.kind == Kind::Instruction => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
         Code::Char(']') if info.kind == Kind::Cdata => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| {
-                continuation_character_data_inside(t, c, info)
-            }))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_character_data_inside(t, info)))
         }
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
             if info.kind == Kind::Basic || info.kind == Kind::Complete =>
@@ -722,17 +712,17 @@ fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
                 if ok {
                     Box::new(continuation_after)
                 } else {
-                    Box::new(move |t, c| continuation_start(t, c, info))
+                    Box::new(move |t| continuation_start(t, info))
                 }
-            })(tokenizer, code)
+            })(tokenizer)
         }
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HtmlFlowData);
-            continuation_start(tokenizer, code, info)
+            continuation_start(tokenizer, info)
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation(t, info)))
         }
     }
 }
@@ -744,14 +734,14 @@ fn continuation(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 ///        ^
 ///   | asd
 /// ```
-fn continuation_start(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn continuation_start(tokenizer: &mut Tokenizer, info: Info) -> State {
     tokenizer.check(partial_non_lazy_continuation, |ok| {
         if ok {
-            Box::new(move |t, c| continuation_start_non_lazy(t, c, info))
+            Box::new(move |t| continuation_start_non_lazy(t, info))
         } else {
             Box::new(continuation_after)
         }
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// In continuation, at an eol, before non-lazy content.
@@ -761,13 +751,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) -> State {
-    match code {
+fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(Box::new(|t, c| continuation_before(t, c, info)))
+            State::Fn(Box::new(|t| continuation_before(t, info)))
         }
         _ => unreachable!("expected eol"),
     }
@@ -780,14 +770,14 @@ fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, code: Code, info: Info
 /// > | asd
 ///     ^
 /// ```
-fn continuation_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn continuation_before(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            continuation_start(tokenizer, code, info)
+            continuation_start(tokenizer, info)
         }
         _ => {
             tokenizer.enter(Token::HtmlFlowData);
-            continuation(tokenizer, code, info)
+            continuation(tokenizer, info)
         }
     }
 }
@@ -798,13 +788,13 @@ fn continuation_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Sta
 /// > | <!--xxx-->
 ///             ^
 /// ```
-fn continuation_comment_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn continuation_comment_inside(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('-') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
-        _ => continuation(tokenizer, code, info),
+        _ => continuation(tokenizer, info),
     }
 }
 
@@ -814,13 +804,13 @@ 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) -> State {
-    match code {
+fn continuation_raw_tag_open(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('/') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_raw_end_tag(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_raw_end_tag(t, info)))
         }
-        _ => continuation(tokenizer, code, info),
+        _ => continuation(tokenizer, info),
     }
 }
 
@@ -830,27 +820,27 @@ 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) -> State {
-    match code {
+fn continuation_raw_end_tag(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
             let tag_name_buffer = serialize(&info.buffer, false).to_lowercase();
             info.buffer.clear();
 
             if HTML_RAW_NAMES.contains(&tag_name_buffer.as_str()) {
-                tokenizer.consume(code);
-                State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
+                tokenizer.consume();
+                State::Fn(Box::new(|t| continuation_close(t, info)))
             } else {
-                continuation(tokenizer, code, info)
+                continuation(tokenizer, info)
             }
         }
         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)))
+            tokenizer.consume();
+            info.buffer.push(tokenizer.current);
+            State::Fn(Box::new(|t| continuation_raw_end_tag(t, info)))
         }
         _ => {
             info.buffer.clear();
-            continuation(tokenizer, code, info)
+            continuation(tokenizer, info)
         }
     }
 }
@@ -861,13 +851,13 @@ fn continuation_raw_end_tag(tokenizer: &mut Tokenizer, code: Code, mut info: Inf
 /// > | <![CDATA[>&<]]>
 ///                  ^
 /// ```
-fn continuation_character_data_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn continuation_character_data_inside(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char(']') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
-        _ => continuation(tokenizer, code, info),
+        _ => continuation(tokenizer, info),
     }
 }
 
@@ -885,17 +875,17 @@ fn continuation_character_data_inside(tokenizer: &mut Tokenizer, code: Code, inf
 /// > | <![CDATA[>&<]]>
 ///                   ^
 /// ```
-fn continuation_declaration_inside(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn continuation_declaration_inside(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_close(t, info)))
         }
         Code::Char('-') if info.kind == Kind::Comment => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_declaration_inside(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_declaration_inside(t, info)))
         }
-        _ => continuation(tokenizer, code, info),
+        _ => continuation(tokenizer, info),
     }
 }
 
@@ -905,15 +895,15 @@ fn continuation_declaration_inside(tokenizer: &mut Tokenizer, code: Code, info:
 /// > | <!doctype>
 ///               ^
 /// ```
-fn continuation_close(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn continuation_close(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HtmlFlowData);
-            continuation_after(tokenizer, code)
+            continuation_after(tokenizer)
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| continuation_close(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| continuation_close(t, info)))
         }
     }
 }
@@ -924,7 +914,7 @@ fn continuation_close(tokenizer: &mut Tokenizer, code: Code, info: Info) -> Stat
 /// > | <!doctype>
 ///               ^
 /// ```
-fn continuation_after(tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn continuation_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.exit(Token::HtmlFlow);
     // Feel free to interrupt.
     tokenizer.interrupt = false;
@@ -940,9 +930,9 @@ fn continuation_after(tokenizer: &mut Tokenizer, _code: Code) -> State {
 ///          ^
 ///   |
 /// ```
-fn blank_line_before(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn blank_line_before(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::LineEnding);
-    tokenizer.consume(code);
+    tokenizer.consume();
     tokenizer.exit(Token::LineEnding);
     State::Fn(Box::new(blank_line))
 }
diff --git a/src/construct/html_text.rs b/src/construct/html_text.rs
index 8fbe862..3ac8d71 100644
--- a/src/construct/html_text.rs
+++ b/src/construct/html_text.rs
@@ -65,11 +65,11 @@ use crate::util::codes::parse;
 /// > | a <b> c
 ///       ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    if Code::Char('<') == code && tokenizer.parse_state.constructs.html_text {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    if Code::Char('<') == tokenizer.current && tokenizer.parse_state.constructs.html_text {
         tokenizer.enter(Token::HtmlText);
         tokenizer.enter(Token::HtmlTextData);
-        tokenizer.consume(code);
+        tokenizer.consume();
         State::Fn(Box::new(open))
     } else {
         State::Nok
@@ -86,22 +86,22 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <!--b--> c
 ///        ^
 /// ```
-fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('!') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(declaration_open))
         }
         Code::Char('/') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_close_start))
         }
         Code::Char('?') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(instruction))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open))
         }
         _ => State::Nok,
@@ -118,19 +118,19 @@ fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <![CDATA[>&<]]> c
 ///         ^
 /// ```
-fn declaration_open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn declaration_open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(comment_open_inside))
         }
         Code::Char('[') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             let buffer = parse("CDATA[");
-            State::Fn(Box::new(|t, c| cdata_open_inside(t, c, buffer, 0)))
+            State::Fn(Box::new(|t| cdata_open_inside(t, buffer, 0)))
         }
         Code::Char('A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(declaration))
         }
         _ => State::Nok,
@@ -143,10 +143,10 @@ fn declaration_open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <!--b--> c
 ///          ^
 /// ```
-fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn comment_open_inside(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(comment_start))
         }
         _ => State::Nok,
@@ -166,14 +166,14 @@ fn comment_open_inside(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// ```
 ///
 /// [html_flow]: crate::construct::html_flow
-fn comment_start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn comment_start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::Char('>') => State::Nok,
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(comment_start_dash))
         }
-        _ => comment(tokenizer, code),
+        _ => comment(tokenizer),
     }
 }
 
@@ -190,10 +190,10 @@ fn comment_start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// ```
 ///
 /// [html_flow]: crate::construct::html_flow
-fn comment_start_dash(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn comment_start_dash(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::Char('>') => State::Nok,
-        _ => comment(tokenizer, code),
+        _ => comment(tokenizer),
     }
 }
 
@@ -203,18 +203,18 @@ fn comment_start_dash(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <!--b--> c
 ///           ^
 /// ```
-fn comment(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn comment(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(comment))
+            at_line_ending(tokenizer, Box::new(comment))
         }
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(comment_close))
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(comment))
         }
     }
@@ -226,13 +226,13 @@ fn comment(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <!--b--> c
 ///             ^
 /// ```
-fn comment_close(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn comment_close(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('-') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(end))
         }
-        _ => comment(tokenizer, code),
+        _ => comment(tokenizer),
     }
 }
 
@@ -242,21 +242,14 @@ fn comment_close(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <![CDATA[>&<]]> b
 ///          ^^^^^^
 /// ```
-fn cdata_open_inside(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    buffer: Vec<Code>,
-    index: usize,
-) -> State {
-    if code == buffer[index] {
-        tokenizer.consume(code);
+fn cdata_open_inside(tokenizer: &mut Tokenizer, buffer: Vec<Code>, index: usize) -> State {
+    if tokenizer.current == buffer[index] {
+        tokenizer.consume();
 
         if index + 1 == buffer.len() {
             State::Fn(Box::new(cdata))
         } else {
-            State::Fn(Box::new(move |t, c| {
-                cdata_open_inside(t, c, buffer, index + 1)
-            }))
+            State::Fn(Box::new(move |t| cdata_open_inside(t, buffer, index + 1)))
         }
     } else {
         State::Nok
@@ -269,18 +262,18 @@ fn cdata_open_inside(
 /// > | a <![CDATA[>&<]]> b
 ///                ^^^
 /// ```
-fn cdata(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn cdata(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(cdata))
+            at_line_ending(tokenizer, Box::new(cdata))
         }
         Code::Char(']') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(cdata_close))
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(cdata))
         }
     }
@@ -292,13 +285,13 @@ fn cdata(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <![CDATA[>&<]]> b
 ///                    ^
 /// ```
-fn cdata_close(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn cdata_close(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(']') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(cdata_end))
         }
-        _ => cdata(tokenizer, code),
+        _ => cdata(tokenizer),
     }
 }
 
@@ -308,11 +301,11 @@ fn cdata_close(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <![CDATA[>&<]]> b
 ///                     ^
 /// ```
-fn cdata_end(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
-        Code::Char('>') => end(tokenizer, code),
-        Code::Char(']') => cdata_close(tokenizer, code),
-        _ => cdata(tokenizer, code),
+fn cdata_end(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
+        Code::Char('>') => end(tokenizer),
+        Code::Char(']') => cdata_close(tokenizer),
+        _ => cdata(tokenizer),
     }
 }
 
@@ -322,14 +315,14 @@ fn cdata_end(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <!b> c
 ///          ^
 /// ```
-fn declaration(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
-        Code::None | Code::Char('>') => end(tokenizer, code),
+fn declaration(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
+        Code::None | Code::Char('>') => end(tokenizer),
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(declaration))
+            at_line_ending(tokenizer, Box::new(declaration))
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(declaration))
         }
     }
@@ -341,18 +334,18 @@ fn declaration(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <?b?> c
 ///         ^
 /// ```
-fn instruction(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn instruction(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(instruction))
+            at_line_ending(tokenizer, Box::new(instruction))
         }
         Code::Char('?') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(instruction_close))
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(instruction))
         }
     }
@@ -364,10 +357,10 @@ fn instruction(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <?b?> c
 ///           ^
 /// ```
-fn instruction_close(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
-        Code::Char('>') => end(tokenizer, code),
-        _ => instruction(tokenizer, code),
+fn instruction_close(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
+        Code::Char('>') => end(tokenizer),
+        _ => instruction(tokenizer),
     }
 }
 
@@ -377,10 +370,10 @@ fn instruction_close(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a </b> c
 ///         ^
 /// ```
-fn tag_close_start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_close_start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_close))
         }
         _ => State::Nok,
@@ -393,13 +386,13 @@ fn tag_close_start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a </b> c
 ///          ^
 /// ```
-fn tag_close(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_close(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('-' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_close))
         }
-        _ => tag_close_between(tokenizer, code),
+        _ => tag_close_between(tokenizer),
     }
 }
 
@@ -409,16 +402,16 @@ fn tag_close(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a </b> c
 ///          ^
 /// ```
-fn tag_close_between(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_close_between(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(tag_close_between))
+            at_line_ending(tokenizer, Box::new(tag_close_between))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_close_between))
         }
-        _ => end(tokenizer, code),
+        _ => end(tokenizer),
     }
 }
 
@@ -428,15 +421,15 @@ fn tag_close_between(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <b> c
 ///         ^
 /// ```
-fn tag_open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('-' | '0'..='9' | 'A'..='Z' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open))
         }
         Code::CarriageReturnLineFeed
         | Code::VirtualSpace
-        | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => tag_open_between(tokenizer, code),
+        | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => tag_open_between(tokenizer),
         _ => State::Nok,
     }
 }
@@ -447,24 +440,24 @@ fn tag_open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <b> c
 ///         ^
 /// ```
-fn tag_open_between(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_open_between(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(tag_open_between))
+            at_line_ending(tokenizer, Box::new(tag_open_between))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_between))
         }
         Code::Char('/') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(end))
         }
         Code::Char(':' | 'A'..='Z' | '_' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_attribute_name))
         }
-        _ => end(tokenizer, code),
+        _ => end(tokenizer),
     }
 }
 
@@ -474,13 +467,13 @@ fn tag_open_between(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <b c> d
 ///          ^
 /// ```
-fn tag_open_attribute_name(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_open_attribute_name(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('-' | '.' | '0'..='9' | ':' | 'A'..='Z' | '_' | 'a'..='z') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_attribute_name))
         }
-        _ => tag_open_attribute_name_after(tokenizer, code),
+        _ => tag_open_attribute_name_after(tokenizer),
     }
 }
 
@@ -491,20 +484,20 @@ fn tag_open_attribute_name(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a <b c> d
 ///           ^
 /// ```
-fn tag_open_attribute_name_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_open_attribute_name_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(tag_open_attribute_name_after))
+            at_line_ending(tokenizer, Box::new(tag_open_attribute_name_after))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_attribute_name_after))
         }
         Code::Char('=') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_attribute_value_before))
         }
-        _ => tag_open_between(tokenizer, code),
+        _ => tag_open_between(tokenizer),
     }
 }
 
@@ -515,24 +508,22 @@ 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) -> State {
-    match code {
+fn tag_open_attribute_value_before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::Char('<' | '=' | '>' | '`') => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
-            at_line_ending(tokenizer, code, Box::new(tag_open_attribute_value_before))
+            at_line_ending(tokenizer, Box::new(tag_open_attribute_value_before))
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             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)
-            }))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| tag_open_attribute_value_quoted(t, char)))
         }
         Code::Char(_) => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_attribute_value_unquoted))
         }
     }
@@ -544,22 +535,21 @@ 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) -> State {
-    match code {
+fn tag_open_attribute_value_quoted(tokenizer: &mut Tokenizer, marker: char) -> State {
+    match tokenizer.current {
         Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => at_line_ending(
             tokenizer,
-            code,
-            Box::new(move |t, c| tag_open_attribute_value_quoted(t, c, marker)),
+            Box::new(move |t| tag_open_attribute_value_quoted(t, marker)),
         ),
         Code::Char(char) if char == marker => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             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)
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| {
+                tag_open_attribute_value_quoted(t, marker)
             }))
         }
     }
@@ -571,14 +561,14 @@ fn tag_open_attribute_value_quoted(tokenizer: &mut Tokenizer, code: Code, marker
 /// > | a <b c=d> e
 ///            ^
 /// ```
-fn tag_open_attribute_value_unquoted(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn tag_open_attribute_value_unquoted(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::Char('"' | '\'' | '<' | '=' | '`') => State::Nok,
         Code::CarriageReturnLineFeed
         | Code::VirtualSpace
-        | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => tag_open_between(tokenizer, code),
+        | Code::Char('\t' | '\n' | '\r' | ' ' | '/' | '>') => tag_open_between(tokenizer),
         Code::Char(_) => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(tag_open_attribute_value_unquoted))
         }
     }
@@ -591,11 +581,11 @@ 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) -> State {
-    match code {
+fn tag_open_attribute_value_quoted_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed
         | Code::VirtualSpace
-        | Code::Char('\t' | '\n' | '\r' | ' ' | '>' | '/') => tag_open_between(tokenizer, code),
+        | Code::Char('\t' | '\n' | '\r' | ' ' | '>' | '/') => tag_open_between(tokenizer),
         _ => State::Nok,
     }
 }
@@ -606,10 +596,10 @@ fn tag_open_attribute_value_quoted_after(tokenizer: &mut Tokenizer, code: Code)
 /// > | a <b c="d"> e
 ///               ^
 /// ```
-fn end(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn end(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::HtmlTextData);
             tokenizer.exit(Token::HtmlText);
             State::Ok
@@ -628,14 +618,14 @@ fn end(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///            ^
 ///   | b-->
 /// ```
-fn at_line_ending(tokenizer: &mut Tokenizer, code: Code, return_state: Box<StateFn>) -> State {
-    match code {
+fn at_line_ending(tokenizer: &mut Tokenizer, return_state: Box<StateFn>) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::HtmlTextData);
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(Box::new(|t, c| after_line_ending(t, c, return_state)))
+            State::Fn(Box::new(|t| after_line_ending(t, return_state)))
         }
         _ => unreachable!("expected eol"),
     }
@@ -651,10 +641,10 @@ fn at_line_ending(tokenizer: &mut Tokenizer, code: Code, return_state: Box<State
 /// > | b-->
 ///     ^
 /// ```
-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)
+fn after_line_ending(tokenizer: &mut Tokenizer, return_state: Box<StateFn>) -> State {
+    tokenizer.attempt_opt(space_or_tab(), |t| {
+        after_line_ending_prefix(t, return_state)
+    })(tokenizer)
 }
 
 /// After a line ending, after indent.
@@ -667,11 +657,7 @@ fn after_line_ending(tokenizer: &mut Tokenizer, code: Code, return_state: Box<St
 /// > | b-->
 ///     ^
 /// ```
-fn after_line_ending_prefix(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    return_state: Box<StateFn>,
-) -> State {
+fn after_line_ending_prefix(tokenizer: &mut Tokenizer, return_state: Box<StateFn>) -> State {
     tokenizer.enter(Token::HtmlTextData);
-    return_state(tokenizer, code)
+    return_state(tokenizer)
 }
diff --git a/src/construct/label_end.rs b/src/construct/label_end.rs
index 960e95e..6f0a707 100644
--- a/src/construct/label_end.rs
+++ b/src/construct/label_end.rs
@@ -180,8 +180,8 @@ struct Info {
 ///       ^
 /// > | [a] b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    if Code::Char(']') == code && tokenizer.parse_state.constructs.label_end {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    if Code::Char(']') == tokenizer.current && tokenizer.parse_state.constructs.label_end {
         let mut label_start_index = None;
         let mut index = tokenizer.label_start_stack.len();
 
@@ -203,7 +203,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 
             // Mark as balanced if the info is inactive.
             if label_start.inactive {
-                return nok(tokenizer, code, label_start_index);
+                return nok(tokenizer, label_start_index);
             }
 
             let label_end_start = tokenizer.events.len();
@@ -225,11 +225,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 
             tokenizer.enter(Token::LabelEnd);
             tokenizer.enter(Token::LabelMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LabelMarker);
             tokenizer.exit(Token::LabelEnd);
 
-            return State::Fn(Box::new(move |t, c| after(t, c, info)));
+            return State::Fn(Box::new(move |t| after(t, info)));
         }
     }
 
@@ -248,39 +248,39 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a] b
 ///       ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn after(tokenizer: &mut Tokenizer, info: Info) -> State {
     let defined = tokenizer.parse_state.definitions.contains(&info.media.id);
 
-    match code {
+    match tokenizer.current {
         // Resource (`[asd](fgh)`)?
         Code::Char('(') => tokenizer.attempt(resource, move |is_ok| {
-            Box::new(move |t, c| {
+            Box::new(move |t| {
                 // Also fine if `defined`, as then it’s a valid shortcut.
                 if is_ok || defined {
-                    ok(t, c, info)
+                    ok(t, info)
                 } else {
-                    nok(t, c, info.label_start_index)
+                    nok(t, info.label_start_index)
                 }
             })
-        })(tokenizer, code),
+        })(tokenizer),
         // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?
         Code::Char('[') => tokenizer.attempt(full_reference, move |is_ok| {
-            Box::new(move |t, c| {
+            Box::new(move |t| {
                 if is_ok {
-                    ok(t, c, info)
+                    ok(t, info)
                 } else if defined {
-                    reference_not_full(t, c, info)
+                    reference_not_full(t, info)
                 } else {
-                    nok(t, c, info.label_start_index)
+                    nok(t, info.label_start_index)
                 }
             })
-        })(tokenizer, code),
+        })(tokenizer),
         // Shortcut reference: `[asd]`?
         _ => {
             if defined {
-                ok(tokenizer, code, info)
+                ok(tokenizer, info)
             } else {
-                nok(tokenizer, code, info.label_start_index)
+                nok(tokenizer, info.label_start_index)
             }
         }
     }
@@ -296,16 +296,16 @@ fn after(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | [a] b
 ///        ^
 /// ```
-fn reference_not_full(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
+fn reference_not_full(tokenizer: &mut Tokenizer, info: Info) -> State {
     tokenizer.attempt(collapsed_reference, move |is_ok| {
-        Box::new(move |t, c| {
+        Box::new(move |t| {
             if is_ok {
-                ok(t, c, info)
+                ok(t, info)
             } else {
-                nok(t, c, info.label_start_index)
+                nok(t, info.label_start_index)
             }
         })
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// Done, we found something.
@@ -320,7 +320,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) -> State {
+fn ok(tokenizer: &mut Tokenizer, mut info: Info) -> State {
     // Remove this one and everything after it.
     let mut left = tokenizer
         .label_start_stack
@@ -360,7 +360,7 @@ fn ok(tokenizer: &mut Tokenizer, _code: Code, mut info: Info) -> State {
 /// > | [a] b
 ///        ^
 /// ```
-fn nok(tokenizer: &mut Tokenizer, _code: Code, label_start_index: usize) -> State {
+fn nok(tokenizer: &mut Tokenizer, label_start_index: usize) -> State {
     let label_start = tokenizer
         .label_start_stack
         .get_mut(label_start_index)
@@ -375,12 +375,12 @@ fn nok(tokenizer: &mut Tokenizer, _code: Code, label_start_index: usize) -> Stat
 /// > | [a](b) c
 ///        ^
 /// ```
-fn resource(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn resource(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('(') => {
             tokenizer.enter(Token::Resource);
             tokenizer.enter(Token::ResourceMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::ResourceMarker);
             State::Fn(Box::new(resource_start))
         }
@@ -394,8 +394,8 @@ fn resource(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a](b) c
 ///         ^
 /// ```
-fn resource_start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(space_or_tab_eol(), resource_open)(tokenizer, code)
+fn resource_start(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(space_or_tab_eol(), resource_open)(tokenizer)
 }
 
 /// At the start of a resource, after optional whitespace.
@@ -404,14 +404,13 @@ fn resource_start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a](b) c
 ///         ^
 /// ```
-fn resource_open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
-        Code::Char(')') => resource_end(tokenizer, code),
+fn resource_open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
+        Code::Char(')') => resource_end(tokenizer),
         _ => tokenizer.go(
-            |t, c| {
+            |t| {
                 destination(
                     t,
-                    c,
                     DestinationOptions {
                         limit: RESOURCE_DESTINATION_BALANCE_MAX,
                         destination: Token::ResourceDestination,
@@ -423,7 +422,7 @@ fn resource_open(tokenizer: &mut Tokenizer, code: Code) -> State {
                 )
             },
             destination_after,
-        )(tokenizer, code),
+        )(tokenizer),
     }
 }
 
@@ -433,10 +432,10 @@ fn resource_open(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a](b) c
 ///          ^
 /// ```
-fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn destination_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(space_or_tab_eol(), |ok| {
         Box::new(if ok { resource_between } else { resource_end })
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// In a resource, after a destination, after whitespace.
@@ -445,13 +444,12 @@ fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a](b ) c
 ///           ^
 /// ```
-fn resource_between(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn resource_between(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('"' | '\'' | '(') => tokenizer.go(
-            |t, c| {
+            |t| {
                 title(
                     t,
-                    c,
                     TitleOptions {
                         title: Token::ResourceTitle,
                         marker: Token::ResourceTitleMarker,
@@ -460,8 +458,8 @@ fn resource_between(tokenizer: &mut Tokenizer, code: Code) -> State {
                 )
             },
             title_after,
-        )(tokenizer, code),
-        _ => resource_end(tokenizer, code),
+        )(tokenizer),
+        _ => resource_end(tokenizer),
     }
 }
 
@@ -471,8 +469,8 @@ fn resource_between(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a](b "c") d
 ///              ^
 /// ```
-fn title_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.attempt_opt(space_or_tab_eol(), resource_end)(tokenizer, code)
+fn title_after(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.attempt_opt(space_or_tab_eol(), resource_end)(tokenizer)
 }
 
 /// In a resource, at the `)`.
@@ -481,11 +479,11 @@ fn title_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a](b) d
 ///          ^
 /// ```
-fn resource_end(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn resource_end(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(')') => {
             tokenizer.enter(Token::ResourceMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::ResourceMarker);
             tokenizer.exit(Token::Resource);
             State::Ok
@@ -500,13 +498,12 @@ fn resource_end(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a][b] d
 ///        ^
 /// ```
-fn full_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn full_reference(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('[') => tokenizer.go(
-            |t, c| {
+            |t| {
                 label(
                     t,
-                    c,
                     LabelOptions {
                         label: Token::Reference,
                         marker: Token::ReferenceMarker,
@@ -515,7 +512,7 @@ fn full_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
                 )
             },
             full_reference_after,
-        )(tokenizer, code),
+        )(tokenizer),
         _ => unreachable!("expected `[`"),
     }
 }
@@ -526,7 +523,7 @@ fn full_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a][b] d
 ///          ^
 /// ```
-fn full_reference_after(tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn full_reference_after(tokenizer: &mut Tokenizer) -> State {
     let events = &tokenizer.events;
     let mut index = events.len() - 1;
     let mut start: Option<usize> = None;
@@ -572,12 +569,12 @@ fn full_reference_after(tokenizer: &mut Tokenizer, _code: Code) -> State {
 /// > | [a][] d
 ///        ^
 /// ```
-fn collapsed_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn collapsed_reference(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('[') => {
             tokenizer.enter(Token::Reference);
             tokenizer.enter(Token::ReferenceMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::ReferenceMarker);
             State::Fn(Box::new(collapsed_reference_open))
         }
@@ -593,11 +590,11 @@ fn collapsed_reference(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | [a][] d
 ///         ^
 /// ```
-fn collapsed_reference_open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn collapsed_reference_open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char(']') => {
             tokenizer.enter(Token::ReferenceMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::ReferenceMarker);
             tokenizer.exit(Token::Reference);
             State::Ok
diff --git a/src/construct/label_start_image.rs b/src/construct/label_start_image.rs
index 54521d4..8c12ffe 100644
--- a/src/construct/label_start_image.rs
+++ b/src/construct/label_start_image.rs
@@ -38,12 +38,12 @@ use crate::tokenizer::{Code, LabelStart, State, Tokenizer};
 /// > | a ![b] c
 ///       ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('!') if tokenizer.parse_state.constructs.label_start_image => {
             tokenizer.enter(Token::LabelImage);
             tokenizer.enter(Token::LabelImageMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LabelImageMarker);
             State::Fn(Box::new(open))
         }
@@ -57,11 +57,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | a ![b] c
 ///        ^
 /// ```
-pub fn open(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn open(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('[') => {
             tokenizer.enter(Token::LabelMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LabelMarker);
             tokenizer.exit(Token::LabelImage);
             let end = tokenizer.events.len() - 1;
diff --git a/src/construct/label_start_link.rs b/src/construct/label_start_link.rs
index f4c2ce8..e13cd77 100644
--- a/src/construct/label_start_link.rs
+++ b/src/construct/label_start_link.rs
@@ -37,13 +37,13 @@ use crate::tokenizer::{Code, LabelStart, State, Tokenizer};
 /// > | a [b] c
 ///       ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('[') if tokenizer.parse_state.constructs.label_start_link => {
             let start = tokenizer.events.len();
             tokenizer.enter(Token::LabelLink);
             tokenizer.enter(Token::LabelMarker);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LabelMarker);
             tokenizer.exit(Token::LabelLink);
             tokenizer.label_start_stack.push(LabelStart {
diff --git a/src/construct/list.rs b/src/construct/list.rs
index 4dfd202..f5bb0ce 100644
--- a/src/construct/list.rs
+++ b/src/construct/list.rs
@@ -136,7 +136,7 @@ impl Kind {
 /// > | * a
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> 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) -> State {
 
     if tokenizer.parse_state.constructs.list {
         tokenizer.enter(Token::ListItem);
-        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer)
     } else {
         State::Nok
     }
@@ -157,17 +157,17 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         // Unordered.
         Code::Char('*' | '+' | '-') => tokenizer.check(thematic_break, |ok| {
             Box::new(if ok { nok } else { before_unordered })
-        })(tokenizer, code),
+        })(tokenizer),
         // Ordered.
         Code::Char(char) if char.is_ascii_digit() && (!tokenizer.interrupt || char == '1') => {
             tokenizer.enter(Token::ListItemPrefix);
             tokenizer.enter(Token::ListItemValue);
-            inside(tokenizer, code, 0)
+            inside(tokenizer, 0)
         }
         _ => State::Nok,
     }
@@ -181,9 +181,9 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///     ^
 /// ```
-fn before_unordered(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn before_unordered(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::ListItemPrefix);
-    marker(tokenizer, code)
+    marker(tokenizer)
 }
 
 /// In an ordered list item value.
@@ -192,15 +192,15 @@ fn before_unordered(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | 1. a
 ///     ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer, size: usize) -> State {
+    match tokenizer.current {
         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)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| inside(t, size + 1)))
         }
         Code::Char('.' | ')') if !tokenizer.interrupt || size < 2 => {
             tokenizer.exit(Token::ListItemValue);
-            marker(tokenizer, code)
+            marker(tokenizer)
         }
         _ => State::Nok,
     }
@@ -214,9 +214,9 @@ fn inside(tokenizer: &mut Tokenizer, code: Code, size: usize) -> State {
 /// > | 1. b
 ///      ^
 /// ```
-fn marker(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn marker(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::ListItemMarker);
-    tokenizer.consume(code);
+    tokenizer.consume();
     tokenizer.exit(Token::ListItemMarker);
     State::Fn(Box::new(marker_after))
 }
@@ -229,14 +229,14 @@ fn marker(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | 1. b
 ///       ^
 /// ```
-fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn marker_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.check(blank_line, move |ok| {
         if ok {
-            Box::new(|t, c| after(t, c, true))
+            Box::new(|t| after(t, true))
         } else {
             Box::new(marker_after_not_blank)
         }
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// After a list item marker, not followed by a blank line.
@@ -245,15 +245,15 @@ fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///      ^
 /// ```
-fn marker_after_not_blank(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn marker_after_not_blank(tokenizer: &mut Tokenizer) -> State {
     // Attempt to parse up to the largest allowed indent, `nok` if there is more whitespace.
     tokenizer.attempt(whitespace, move |ok| {
         if ok {
-            Box::new(|t, c| after(t, c, false))
+            Box::new(|t| after(t, false))
         } else {
             Box::new(prefix_other)
         }
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// In whitespace after a marker.
@@ -262,8 +262,8 @@ fn marker_after_not_blank(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///      ^
 /// ```
-fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.go(space_or_tab_min_max(1, TAB_SIZE), whitespace_after)(tokenizer, code)
+fn whitespace(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.go(space_or_tab_min_max(1, TAB_SIZE), whitespace_after)(tokenizer)
 }
 
 /// After acceptable whitespace.
@@ -272,8 +272,11 @@ fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///      ^
 /// ```
-fn whitespace_after(_tokenizer: &mut Tokenizer, code: Code) -> State {
-    if matches!(code, Code::VirtualSpace | Code::Char('\t' | ' ')) {
+fn whitespace_after(tokenizer: &mut Tokenizer) -> State {
+    if matches!(
+        tokenizer.current,
+        Code::VirtualSpace | Code::Char('\t' | ' ')
+    ) {
         State::Nok
     } else {
         State::Ok
@@ -286,13 +289,13 @@ fn whitespace_after(_tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///      ^
 /// ```
-fn prefix_other(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn prefix_other(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
             tokenizer.enter(Token::SpaceOrTab);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::SpaceOrTab);
-            State::Fn(Box::new(|t, c| after(t, c, false)))
+            State::Fn(Box::new(|t| after(t, false)))
         }
         _ => State::Nok,
     }
@@ -304,7 +307,7 @@ fn prefix_other(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | * a
 ///       ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, _code: Code, blank: bool) -> State {
+fn after(tokenizer: &mut Tokenizer, blank: bool) -> State {
     if blank && tokenizer.interrupt {
         State::Nok
     } else {
@@ -333,10 +336,10 @@ fn after(tokenizer: &mut Tokenizer, _code: Code, blank: bool) -> State {
 /// > |   b
 ///     ^
 /// ```
-pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn cont(tokenizer: &mut Tokenizer) -> State {
     tokenizer.check(blank_line, |ok| {
         Box::new(if ok { blank_cont } else { not_blank_cont })
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// Start of blank list item continuation.
@@ -347,7 +350,7 @@ pub fn cont(tokenizer: &mut Tokenizer, code: Code) -> State {
 ///     ^
 ///   |   b
 /// ```
-pub fn blank_cont(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn blank_cont(tokenizer: &mut Tokenizer) -> State {
     let container = tokenizer.container.as_ref().unwrap();
     let size = container.size;
 
@@ -355,7 +358,7 @@ pub fn blank_cont(tokenizer: &mut Tokenizer, code: Code) -> State {
         State::Nok
     } else {
         // Consume, optionally, at most `size`.
-        tokenizer.go(space_or_tab_min_max(0, size), ok)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, size), ok)(tokenizer)
     }
 }
 
@@ -366,23 +369,23 @@ pub fn blank_cont(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > |   b
 ///     ^
 /// ```
-pub fn not_blank_cont(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn not_blank_cont(tokenizer: &mut Tokenizer) -> State {
     let container = tokenizer.container.as_mut().unwrap();
     let size = container.size;
 
     container.blank_initial = false;
 
     // Consume exactly `size`.
-    tokenizer.go(space_or_tab_min_max(size, size), ok)(tokenizer, code)
+    tokenizer.go(space_or_tab_min_max(size, size), ok)(tokenizer)
 }
 
 /// A state fn to yield [`State::Ok`].
-pub fn ok(_tokenizer: &mut Tokenizer, _code: Code) -> State {
+pub fn ok(_tokenizer: &mut Tokenizer) -> State {
     State::Ok
 }
 
 /// A state fn to yield [`State::Nok`].
-fn nok(_tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn nok(_tokenizer: &mut Tokenizer) -> State {
     State::Nok
 }
 
diff --git a/src/construct/paragraph.rs b/src/construct/paragraph.rs
index d320779..4bce6a4 100644
--- a/src/construct/paragraph.rs
+++ b/src/construct/paragraph.rs
@@ -42,15 +42,15 @@ use crate::util::skip::opt as skip_opt;
 /// > | abc
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             unreachable!("unexpected eol/eof")
         }
         _ => {
             tokenizer.enter(Token::Paragraph);
             tokenizer.enter_with_content(Token::Data, Some(ContentType::Text));
-            inside(tokenizer, code)
+            inside(tokenizer)
         }
     }
 }
@@ -61,8 +61,8 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | abc
 ///     ^^^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(Token::Paragraph);
@@ -72,7 +72,7 @@ fn inside(tokenizer: &mut Tokenizer, code: Code) -> State {
             State::Ok
         }
         _ => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             State::Fn(Box::new(inside))
         }
     }
diff --git a/src/construct/partial_data.rs b/src/construct/partial_data.rs
index f399bac..86492b5 100644
--- a/src/construct/partial_data.rs
+++ b/src/construct/partial_data.rs
@@ -15,13 +15,13 @@ use crate::tokenizer::{Code, EventType, State, Tokenizer};
 /// > | abc
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> State {
-    if stop.contains(&code) {
+pub fn start(tokenizer: &mut Tokenizer, stop: &'static [Code]) -> State {
+    if stop.contains(&tokenizer.current) {
         tokenizer.enter(Token::Data);
-        tokenizer.consume(code);
-        State::Fn(Box::new(move |t, c| data(t, c, stop)))
+        tokenizer.consume();
+        State::Fn(Box::new(move |t| data(t, stop)))
     } else {
-        at_break(tokenizer, code, stop)
+        at_break(tokenizer, stop)
     }
 }
 
@@ -31,22 +31,22 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> St
 /// > | abc
 ///     ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> State {
-    match code {
+fn at_break(tokenizer: &mut Tokenizer, stop: &'static [Code]) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(Box::new(move |t, c| at_break(t, c, stop)))
+            State::Fn(Box::new(move |t| at_break(t, stop)))
         }
-        _ if stop.contains(&code) => {
+        _ if stop.contains(&tokenizer.current) => {
             tokenizer.register_resolver("data".to_string(), Box::new(resolve_data));
             State::Ok
         }
         _ => {
             tokenizer.enter(Token::Data);
-            data(tokenizer, code, stop)
+            data(tokenizer, stop)
         }
     }
 }
@@ -57,19 +57,19 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> Sta
 /// > | abc
 ///     ^^^
 /// ```
-fn data(tokenizer: &mut Tokenizer, code: Code, stop: &'static [Code]) -> State {
-    let done = match code {
+fn data(tokenizer: &mut Tokenizer, stop: &'static [Code]) -> State {
+    let done = match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => true,
-        _ if stop.contains(&code) => true,
+        _ if stop.contains(&tokenizer.current) => true,
         _ => false,
     };
 
     if done {
         tokenizer.exit(Token::Data);
-        at_break(tokenizer, code, stop)
+        at_break(tokenizer, stop)
     } else {
-        tokenizer.consume(code);
-        State::Fn(Box::new(move |t, c| data(t, c, stop)))
+        tokenizer.consume();
+        State::Fn(Box::new(move |t| data(t, stop)))
     }
 }
 
diff --git a/src/construct/partial_destination.rs b/src/construct/partial_destination.rs
index d567876..6a984e2 100644
--- a/src/construct/partial_destination.rs
+++ b/src/construct/partial_destination.rs
@@ -110,20 +110,20 @@ struct Info {
 /// > | aa
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
+pub fn start(tokenizer: &mut Tokenizer, options: Options) -> State {
     let info = Info {
         balance: 0,
         options,
     };
 
-    match code {
+    match tokenizer.current {
         Code::Char('<') => {
             tokenizer.enter(info.options.destination.clone());
             tokenizer.enter(info.options.literal.clone());
             tokenizer.enter(info.options.marker.clone());
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(info.options.marker.clone());
-            State::Fn(Box::new(|t, c| enclosed_before(t, c, info)))
+            State::Fn(Box::new(|t| enclosed_before(t, info)))
         }
         Code::None | Code::CarriageReturnLineFeed | Code::VirtualSpace | Code::Char(' ' | ')') => {
             State::Nok
@@ -134,7 +134,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
             tokenizer.enter(info.options.raw.clone());
             tokenizer.enter(info.options.string.clone());
             tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
-            raw(tokenizer, code, info)
+            raw(tokenizer, info)
         }
     }
 }
@@ -145,10 +145,10 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
 /// > | <aa>
 ///      ^
 /// ```
-fn enclosed_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    if let Code::Char('>') = code {
+fn enclosed_before(tokenizer: &mut Tokenizer, info: Info) -> State {
+    if let Code::Char('>') = tokenizer.current {
         tokenizer.enter(info.options.marker.clone());
-        tokenizer.consume(code);
+        tokenizer.consume();
         tokenizer.exit(info.options.marker.clone());
         tokenizer.exit(info.options.literal.clone());
         tokenizer.exit(info.options.destination);
@@ -156,7 +156,7 @@ fn enclosed_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
     } else {
         tokenizer.enter(info.options.string.clone());
         tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
-        enclosed(tokenizer, code, info)
+        enclosed(tokenizer, info)
     }
 }
 
@@ -166,21 +166,21 @@ fn enclosed_before(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | <aa>
 ///      ^
 /// ```
-fn enclosed(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn enclosed(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('>') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(info.options.string.clone());
-            enclosed_before(tokenizer, code, info)
+            enclosed_before(tokenizer, info)
         }
         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)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| enclosed_escape(t, info)))
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| enclosed(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| enclosed(t, info)))
         }
     }
 }
@@ -191,13 +191,13 @@ fn enclosed(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | <a\*a>
 ///        ^
 /// ```
-fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn enclosed_escape(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('<' | '>' | '\\') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| enclosed(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| enclosed(t, info)))
         }
-        _ => enclosed(tokenizer, code, info),
+        _ => enclosed(tokenizer, info),
     }
 }
 
@@ -207,15 +207,15 @@ fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | aa
 ///     ^
 /// ```
-fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn raw(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char('(') => {
             if info.balance >= info.options.limit {
                 State::Nok
             } else {
-                tokenizer.consume(code);
+                tokenizer.consume();
                 info.balance += 1;
-                State::Fn(Box::new(move |t, c| raw(t, c, info)))
+                State::Fn(Box::new(move |t| raw(t, info)))
             }
         }
         Code::Char(')') => {
@@ -226,9 +226,9 @@ fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 tokenizer.exit(info.options.destination);
                 State::Ok
             } else {
-                tokenizer.consume(code);
+                tokenizer.consume();
                 info.balance -= 1;
-                State::Fn(Box::new(move |t, c| raw(t, c, info)))
+                State::Fn(Box::new(move |t| raw(t, info)))
             }
         }
         Code::None
@@ -247,12 +247,12 @@ fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
         }
         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)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| raw_escape(t, info)))
         }
         Code::Char(_) => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| raw(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| raw(t, info)))
         }
     }
 }
@@ -263,12 +263,12 @@ fn raw(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | a\*a
 ///       ^
 /// ```
-fn raw_escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn raw_escape(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char('(' | ')' | '\\') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(move |t, c| raw(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(move |t| raw(t, info)))
         }
-        _ => raw(tokenizer, code, info),
+        _ => raw(tokenizer, info),
     }
 }
diff --git a/src/construct/partial_label.rs b/src/construct/partial_label.rs
index 3bb3abf..91a0e26 100644
--- a/src/construct/partial_label.rs
+++ b/src/construct/partial_label.rs
@@ -96,8 +96,8 @@ struct Info {
 /// > | [a]
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer, options: Options) -> State {
+    match tokenizer.current {
         Code::Char('[') => {
             let info = Info {
                 connect: false,
@@ -107,10 +107,10 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
             };
             tokenizer.enter(info.options.label.clone());
             tokenizer.enter(info.options.marker.clone());
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(info.options.marker.clone());
             tokenizer.enter(info.options.string.clone());
-            State::Fn(Box::new(|t, c| at_break(t, c, info)))
+            State::Fn(Box::new(|t| at_break(t, info)))
         }
         _ => State::Nok,
     }
@@ -122,15 +122,15 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
 /// > | [a]
 ///      ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn at_break(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         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.consume();
             tokenizer.exit(info.options.marker.clone());
             tokenizer.exit(info.options.label);
             State::Ok
@@ -140,11 +140,11 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 content_type: Some(ContentType::String),
                 connect: info.connect,
             }),
-            |t, c| {
+            |t| {
                 info.connect = true;
-                at_break(t, c, info)
+                at_break(t, info)
             },
-        )(tokenizer, code),
+        )(tokenizer),
         _ => {
             tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
 
@@ -155,7 +155,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 info.connect = true;
             }
 
-            label(tokenizer, code, info)
+            label(tokenizer, info)
         }
     }
 }
@@ -166,36 +166,36 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | [a]
 ///      ^
 /// ```
-fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn label(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r' | '[' | ']') => {
             tokenizer.exit(Token::Data);
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         _ if info.size > LINK_REFERENCE_SIZE_MAX => {
             tokenizer.exit(Token::Data);
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         Code::VirtualSpace | Code::Char('\t' | ' ') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
-            State::Fn(Box::new(|t, c| label(t, c, info)))
+            State::Fn(Box::new(|t| label(t, info)))
         }
         Code::Char('\\') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
             if !info.data {
                 info.data = true;
             }
-            State::Fn(Box::new(|t, c| escape(t, c, info)))
+            State::Fn(Box::new(|t| escape(t, info)))
         }
         Code::Char(_) => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
             if !info.data {
                 info.data = true;
             }
-            State::Fn(Box::new(|t, c| label(t, c, info)))
+            State::Fn(Box::new(|t| label(t, info)))
         }
     }
 }
@@ -206,13 +206,13 @@ fn label(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | [a\*a]
 ///        ^
 /// ```
-fn escape(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn escape(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char('[' | '\\' | ']') => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
-            State::Fn(Box::new(|t, c| label(t, c, info)))
+            State::Fn(Box::new(|t| label(t, info)))
         }
-        _ => label(tokenizer, code, info),
+        _ => label(tokenizer, info),
     }
 }
diff --git a/src/construct/partial_non_lazy_continuation.rs b/src/construct/partial_non_lazy_continuation.rs
index 5835848..bdc22e4 100644
--- a/src/construct/partial_non_lazy_continuation.rs
+++ b/src/construct/partial_non_lazy_continuation.rs
@@ -20,11 +20,11 @@ use crate::tokenizer::{Code, State, Tokenizer};
 ///            ^
 ///   | b
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
             State::Fn(Box::new(after))
         }
@@ -39,7 +39,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | b
 ///     ^
 /// ```
-fn after(tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn after(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.lazy {
         State::Nok
     } else {
diff --git a/src/construct/partial_space_or_tab.rs b/src/construct/partial_space_or_tab.rs
index 30c63e0..a97ac29 100644
--- a/src/construct/partial_space_or_tab.rs
+++ b/src/construct/partial_space_or_tab.rs
@@ -78,7 +78,7 @@ pub fn space_or_tab_min_max(min: usize, max: usize) -> Box<StateFn> {
 
 /// `space_or_tab`, with the given options.
 pub fn space_or_tab_with_options(options: Options) -> Box<StateFn> {
-    Box::new(|t, c| start(t, c, Info { size: 0, options }))
+    Box::new(|t| start(t, Info { size: 0, options }))
 }
 
 /// `space_or_tab`, or optionally `space_or_tab`, one `eol`, and
@@ -96,7 +96,7 @@ pub fn space_or_tab_eol() -> Box<StateFn> {
 
 /// `space_or_tab_eol`, with the given options.
 pub fn space_or_tab_eol_with_options(options: EolOptions) -> Box<StateFn> {
-    Box::new(move |tokenizer, code| {
+    Box::new(move |tokenizer| {
         let mut info = EolInfo {
             connect: false,
             ok: false,
@@ -120,9 +120,9 @@ pub fn space_or_tab_eol_with_options(options: EolOptions) -> Box<StateFn> {
                     }
                 }
 
-                Box::new(|t, c| after_space_or_tab(t, c, info))
+                Box::new(|t| after_space_or_tab(t, info))
             },
-        )(tokenizer, code)
+        )(tokenizer)
     })
 }
 
@@ -132,8 +132,8 @@ pub fn space_or_tab_eol_with_options(options: EolOptions) -> Box<StateFn> {
 /// > | a␠␠b
 ///      ^
 /// ```
-fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn start(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::VirtualSpace | Code::Char('\t' | ' ') if info.options.max > 0 => {
             tokenizer
                 .enter_with_content(info.options.kind.clone(), info.options.content_type.clone());
@@ -143,9 +143,9 @@ fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 link(&mut tokenizer.events, index);
             }
 
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
-            State::Fn(Box::new(|t, c| inside(t, c, info)))
+            State::Fn(Box::new(|t| inside(t, info)))
         }
         _ => {
             if info.options.min == 0 {
@@ -163,12 +163,12 @@ fn start(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | a␠␠b
 ///       ^
 /// ```
-fn inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn inside(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::VirtualSpace | Code::Char('\t' | ' ') if info.size < info.options.max => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
-            State::Fn(Box::new(|t, c| inside(t, c, info)))
+            State::Fn(Box::new(|t| inside(t, info)))
         }
         _ => {
             tokenizer.exit(info.options.kind.clone());
@@ -188,8 +188,8 @@ fn inside(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 ///      ^
 ///   | b
 /// ```
-fn after_space_or_tab(tokenizer: &mut Tokenizer, code: Code, mut info: EolInfo) -> State {
-    match code {
+fn after_space_or_tab(tokenizer: &mut Tokenizer, mut info: EolInfo) -> State {
+    match tokenizer.current {
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter_with_content(Token::LineEnding, info.options.content_type.clone());
 
@@ -200,9 +200,9 @@ fn after_space_or_tab(tokenizer: &mut Tokenizer, code: Code, mut info: EolInfo)
                 info.connect = true;
             }
 
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(Box::new(|t, c| after_eol(t, c, info)))
+            State::Fn(Box::new(|t| after_eol(t, info)))
         }
         _ if info.ok => State::Ok,
         _ => 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) -> State {
+fn after_eol(tokenizer: &mut Tokenizer, info: EolInfo) -> State {
     tokenizer.attempt_opt(
         space_or_tab_with_options(Options {
             kind: Token::SpaceOrTab,
@@ -227,7 +227,7 @@ fn after_eol(tokenizer: &mut Tokenizer, code: Code, info: EolInfo) -> State {
             connect: info.connect,
         }),
         after_more_space_or_tab,
-    )(tokenizer, code)
+    )(tokenizer)
 }
 
 /// `space_or_tab_eol`: after more (optional) `space_or_tab`.
@@ -237,10 +237,10 @@ fn after_eol(tokenizer: &mut Tokenizer, code: Code, info: EolInfo) -> State {
 /// > | b
 ///     ^
 /// ```
-fn after_more_space_or_tab(_tokenizer: &mut Tokenizer, code: Code) -> State {
+fn after_more_space_or_tab(tokenizer: &mut Tokenizer) -> State {
     // Blank line not allowed.
     if matches!(
-        code,
+        tokenizer.current,
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
     ) {
         State::Nok
diff --git a/src/construct/partial_title.rs b/src/construct/partial_title.rs
index 0483681..e9528fd 100644
--- a/src/construct/partial_title.rs
+++ b/src/construct/partial_title.rs
@@ -135,19 +135,19 @@ struct Info {
 /// > | "a"
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer, options: Options) -> State {
+    match tokenizer.current {
         Code::Char('"' | '\'' | '(') => {
             let info = Info {
                 connect: false,
-                kind: Kind::from_code(code),
+                kind: Kind::from_code(tokenizer.current),
                 options,
             };
             tokenizer.enter(info.options.title.clone());
             tokenizer.enter(info.options.marker.clone());
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(info.options.marker.clone());
-            State::Fn(Box::new(|t, c| begin(t, c, info)))
+            State::Fn(Box::new(|t| begin(t, info)))
         }
         _ => State::Nok,
     }
@@ -161,18 +161,18 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code, options: Options) -> State {
 /// > | "a"
 ///      ^
 /// ```
-fn begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn begin(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.enter(info.options.marker.clone());
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(info.options.marker.clone());
             tokenizer.exit(info.options.title);
             State::Ok
         }
         _ => {
             tokenizer.enter(info.options.string.clone());
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
     }
 }
@@ -183,11 +183,11 @@ fn begin(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | "a"
 ///      ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn at_break(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.exit(info.options.string.clone());
-            begin(tokenizer, code, info)
+            begin(tokenizer, info)
         }
         Code::None => State::Nok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => tokenizer.go(
@@ -195,11 +195,11 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 content_type: Some(ContentType::String),
                 connect: info.connect,
             }),
-            |t, c| {
+            |t| {
                 info.connect = true;
-                at_break(t, c, info)
+                at_break(t, info)
             },
-        )(tokenizer, code),
+        )(tokenizer),
         _ => {
             tokenizer.enter_with_content(Token::Data, Some(ContentType::String));
 
@@ -210,7 +210,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
                 info.connect = true;
             }
 
-            title(tokenizer, code, info)
+            title(tokenizer, info)
         }
     }
 }
@@ -221,23 +221,23 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
 /// > | "a"
 ///      ^
 /// ```
-fn title(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn title(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.exit(Token::Data);
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.exit(Token::Data);
-            at_break(tokenizer, code, info)
+            at_break(tokenizer, info)
         }
         Code::Char('\\') => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| escape(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| escape(t, info)))
         }
         _ => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| title(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| title(t, info)))
         }
     }
 }
@@ -248,12 +248,12 @@ fn title(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | "a\*b"
 ///      ^
 /// ```
-fn escape(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn escape(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
-            tokenizer.consume(code);
-            State::Fn(Box::new(|t, c| title(t, c, info)))
+            tokenizer.consume();
+            State::Fn(Box::new(|t| title(t, info)))
         }
-        _ => title(tokenizer, code, info),
+        _ => title(tokenizer, info),
     }
 }
diff --git a/src/construct/partial_whitespace.rs b/src/construct/partial_whitespace.rs
index 023c52f..afff1c4 100644
--- a/src/construct/partial_whitespace.rs
+++ b/src/construct/partial_whitespace.rs
@@ -27,7 +27,7 @@ use super::partial_space_or_tab::space_or_tab;
 use crate::tokenizer::{Code, State, Tokenizer};
 
 /// Parse initial or final whitespace.
-pub fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn whitespace(tokenizer: &mut Tokenizer) -> State {
     tokenizer.go(
         // Nothing if there’s no whitespace.
         space_or_tab(),
@@ -41,22 +41,22 @@ pub fn whitespace(tokenizer: &mut Tokenizer, code: Code) -> State {
             // If there’s whitespace, and we were not at an eol/eof, there must be one here.
             at_eol
         },
-    )(tokenizer, code)
+    )(tokenizer)
 }
 
 /// After whitespace, at an eol/eof.
-fn at_eol(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn at_eol(tokenizer: &mut Tokenizer) -> State {
     if matches!(
-        code,
+        tokenizer.current,
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
     ) {
-        ok(tokenizer, code)
+        ok(tokenizer)
     } else {
         State::Nok
     }
 }
 
 /// Fine.
-fn ok(_tokenizer: &mut Tokenizer, _code: Code) -> State {
+fn ok(_tokenizer: &mut Tokenizer) -> State {
     State::Ok
 }
diff --git a/src/construct/thematic_break.rs b/src/construct/thematic_break.rs
index 3c9085a..41dc6ae 100644
--- a/src/construct/thematic_break.rs
+++ b/src/construct/thematic_break.rs
@@ -134,7 +134,7 @@ struct Info {
 /// > | ***
 ///     ^
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
     let max = if tokenizer.parse_state.constructs.code_indented {
         TAB_SIZE - 1
     } else {
@@ -143,7 +143,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 
     if tokenizer.parse_state.constructs.thematic_break {
         tokenizer.enter(Token::ThematicBreak);
-        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer, code)
+        tokenizer.go(space_or_tab_min_max(0, max), before)(tokenizer)
     } else {
         State::Nok
     }
@@ -155,13 +155,12 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ***
 ///     ^
 /// ```
-fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::Char('*' | '-' | '_') => at_break(
             tokenizer,
-            code,
             Info {
-                kind: Kind::from_code(code),
+                kind: Kind::from_code(tokenizer.current),
                 size: 0,
             },
         ),
@@ -175,8 +174,8 @@ fn before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | ***
 ///     ^
 /// ```
-fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
-    match code {
+fn at_break(tokenizer: &mut Tokenizer, info: Info) -> State {
+    match tokenizer.current {
         Code::None | Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')
             if info.size >= THEMATIC_BREAK_MARKER_COUNT_MIN =>
         {
@@ -187,7 +186,7 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
         }
         Code::Char(char) if char == info.kind.as_char() => {
             tokenizer.enter(Token::ThematicBreakSequence);
-            sequence(tokenizer, code, info)
+            sequence(tokenizer, info)
         }
         _ => State::Nok,
     }
@@ -199,16 +198,16 @@ fn at_break(tokenizer: &mut Tokenizer, code: Code, info: Info) -> State {
 /// > | ***
 ///     ^
 /// ```
-fn sequence(tokenizer: &mut Tokenizer, code: Code, mut info: Info) -> State {
-    match code {
+fn sequence(tokenizer: &mut Tokenizer, mut info: Info) -> State {
+    match tokenizer.current {
         Code::Char(char) if char == info.kind.as_char() => {
-            tokenizer.consume(code);
+            tokenizer.consume();
             info.size += 1;
-            State::Fn(Box::new(|t, c| sequence(t, c, info)))
+            State::Fn(Box::new(|t| sequence(t, info)))
         }
         _ => {
             tokenizer.exit(Token::ThematicBreakSequence);
-            tokenizer.attempt_opt(space_or_tab(), |t, c| at_break(t, c, info))(tokenizer, code)
+            tokenizer.attempt_opt(space_or_tab(), |t| at_break(t, info))(tokenizer)
         }
     }
 }
diff --git a/src/content/document.rs b/src/content/document.rs
index d3159d3..97d1299 100644
--- a/src/content/document.rs
+++ b/src/content/document.rs
@@ -120,7 +120,7 @@ pub fn document(parse_state: &mut ParseState, point: Point) -> Vec<Event> {
 ///     ^
 ///   | > b
 /// ```
-fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
+fn start(tokenizer: &mut Tokenizer) -> State {
     let info = DocumentInfo {
         index: 0,
         continued: 0,
@@ -130,7 +130,7 @@ fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
         interrupt_before: false,
         stack: vec![],
     };
-    line_start(tokenizer, code, info)
+    line_start(tokenizer, info)
 }
 
 /// Start of a line.
@@ -141,13 +141,13 @@ fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// > | > b
 ///     ^
 /// ```
-fn line_start(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo) -> State {
+fn line_start(tokenizer: &mut Tokenizer, mut info: DocumentInfo) -> State {
     info.index = tokenizer.events.len();
     info.inject.push((vec![], vec![]));
     info.continued = 0;
     // Containers would only be interrupting if we’ve continued.
     tokenizer.interrupt = false;
-    container_existing_before(tokenizer, code, info)
+    container_existing_before(tokenizer, info)
 }
 
 /// Before existing containers.
@@ -157,11 +157,7 @@ fn line_start(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo) ->
 /// > | > b
 ///     ^
 /// ```
-fn container_existing_before(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    mut info: DocumentInfo,
-) -> State {
+fn container_existing_before(tokenizer: &mut Tokenizer, mut info: DocumentInfo) -> State {
     // If there are more existing containers, check whether the next one continues.
     if info.continued < info.stack.len() {
         let container = info.stack.remove(info.continued);
@@ -173,15 +169,15 @@ fn container_existing_before(
         tokenizer.container = Some(container);
         tokenizer.attempt(cont, move |ok| {
             if ok {
-                Box::new(|t, c| container_existing_after(t, c, info))
+                Box::new(|t| container_existing_after(t, info))
             } else {
-                Box::new(|t, c| container_existing_missing(t, c, info))
+                Box::new(|t| container_existing_missing(t, info))
             }
-        })(tokenizer, code)
+        })(tokenizer)
     }
     // Otherwise, check new containers.
     else {
-        container_new_before(tokenizer, code, info)
+        container_new_before(tokenizer, info)
     }
 }
 
@@ -192,14 +188,10 @@ fn container_existing_before(
 /// > | > b
 ///     ^
 /// ```
-fn container_existing_missing(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    mut info: DocumentInfo,
-) -> State {
+fn container_existing_missing(tokenizer: &mut Tokenizer, mut info: DocumentInfo) -> State {
     let container = tokenizer.container.take().unwrap();
     info.stack.insert(info.continued, container);
-    container_new_before(tokenizer, code, info)
+    container_new_before(tokenizer, info)
 }
 
 /// After an existing container.
@@ -209,15 +201,11 @@ fn container_existing_missing(
 /// > |   b
 ///       ^
 /// ```
-fn container_existing_after(
-    tokenizer: &mut Tokenizer,
-    code: Code,
-    mut info: DocumentInfo,
-) -> State {
+fn container_existing_after(tokenizer: &mut Tokenizer, mut info: DocumentInfo) -> State {
     let container = tokenizer.container.take().unwrap();
     info.stack.insert(info.continued, container);
     info.continued += 1;
-    container_existing_before(tokenizer, code, info)
+    container_existing_before(tokenizer, info)
 }
 
 /// Before a new container.
@@ -228,7 +216,7 @@ fn container_existing_after(
 /// > | > b
 ///     ^
 /// ```
-fn container_new_before(tokenizer: &mut Tokenizer, code: Code, info: DocumentInfo) -> State {
+fn container_new_before(tokenizer: &mut Tokenizer, info: DocumentInfo) -> State {
     // If we have completely continued, restore the flow’s past `interrupt`
     // status.
     if info.continued == info.stack.len() {
@@ -237,7 +225,7 @@ fn container_new_before(tokenizer: &mut Tokenizer, code: Code, info: DocumentInf
         // …and if we’re in a concrete construct, new containers can’t “pierce”
         // into them.
         if tokenizer.concrete {
-            return containers_after(tokenizer, code, info);
+            return containers_after(tokenizer, info);
         }
     }
 
@@ -251,9 +239,9 @@ fn container_new_before(tokenizer: &mut Tokenizer, code: Code, info: DocumentInf
 
     tokenizer.attempt(block_quote, move |ok| {
         if ok {
-            Box::new(|t, c| container_new_after(t, c, info))
+            Box::new(|t| container_new_after(t, info))
         } else {
-            Box::new(|tokenizer, code| {
+            Box::new(|tokenizer| {
                 // List item?
                 tokenizer.container = Some(ContainerState {
                     kind: Container::ListItem,
@@ -267,11 +255,11 @@ fn container_new_before(tokenizer: &mut Tokenizer, code: Code, info: DocumentInf
                     } else {
                         containers_after
                     };
-                    Box::new(move |t, c| func(t, c, info))
-                })(tokenizer, code)
+                    Box::new(move |t| func(t, info))
+                })(tokenizer)
             })
         }
-    })(tokenizer, code)
+    })(tokenizer)
 }
 
 /// After a new container.
@@ -282,7 +270,7 @@ fn container_new_before(tokenizer: &mut Tokenizer, code: Code, info: DocumentInf
 /// > | > b
 ///       ^
 /// ```
-fn container_new_after(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo) -> State {
+fn container_new_after(tokenizer: &mut Tokenizer, mut info: DocumentInfo) -> State {
     let container = tokenizer.container.take().unwrap();
 
     // Remove from the event stack.
@@ -311,7 +299,6 @@ fn container_new_after(tokenizer: &mut Tokenizer, code: Code, mut info: Document
     // close the flow and those containers.
     if info.continued != info.stack.len() {
         info = exit_containers(tokenizer, info, &Phase::Prefix);
-        tokenizer.expect(code, true);
     }
 
     // Try another new container.
@@ -319,7 +306,7 @@ fn container_new_after(tokenizer: &mut Tokenizer, code: Code, mut info: Document
     info.continued += 1;
     info.interrupt_before = false;
     tokenizer.interrupt = false;
-    container_new_before(tokenizer, code, info)
+    container_new_before(tokenizer, info)
 }
 
 /// After containers, before flow.
@@ -330,7 +317,7 @@ fn container_new_after(tokenizer: &mut Tokenizer, code: Code, mut info: Document
 /// > | > b
 ///       ^
 /// ```
-fn containers_after(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo) -> State {
+fn containers_after(tokenizer: &mut Tokenizer, mut info: DocumentInfo) -> State {
     // Store the container events we parsed.
     info.inject
         .last_mut()
@@ -349,8 +336,8 @@ fn containers_after(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInf
     tokenizer.go_until(
         state,
         |code| matches!(code, Code::CarriageReturnLineFeed | Code::Char('\n' | '\r')),
-        move |state| Box::new(move |t, c| flow_end(t, c, info, state)),
-    )(tokenizer, code)
+        move |state| Box::new(move |t| flow_end(t, info, state)),
+    )(tokenizer)
 }
 
 /// After flow (after eol or at eof).
@@ -360,7 +347,7 @@ fn containers_after(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInf
 /// > | > b
 ///     ^  ^
 /// ```
-fn flow_end(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo, result: State) -> State {
+fn flow_end(tokenizer: &mut Tokenizer, mut info: DocumentInfo, result: State) -> State {
     let paragraph = !tokenizer.events.is_empty()
         && tokenizer.events[skip::opt_back(
             &tokenizer.events,
@@ -376,7 +363,6 @@ fn flow_end(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo, resul
 
     if info.continued != info.stack.len() {
         info = exit_containers(tokenizer, info, &Phase::After);
-        tokenizer.expect(code, true);
     }
 
     info.paragraph_before = paragraph;
@@ -395,7 +381,7 @@ fn flow_end(tokenizer: &mut Tokenizer, code: Code, mut info: DocumentInfo, resul
         State::Nok => unreachable!("unexpected `nok` from flow"),
         State::Fn(func) => {
             info.next = func;
-            line_start(tokenizer, code, info)
+            line_start(tokenizer, info)
         }
     }
 }
diff --git a/src/content/flow.rs b/src/content/flow.rs
index 2b2ee6d..ea09cd9 100644
--- a/src/content/flow.rs
+++ b/src/content/flow.rs
@@ -39,12 +39,12 @@ use crate::tokenizer::{Code, State, Tokenizer};
 /// |    bravo
 /// |***
 /// ```
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         _ => tokenizer.attempt(blank_line, |ok| {
             Box::new(if ok { blank_line_after } else { initial_before })
-        })(tokenizer, code),
+        })(tokenizer),
     }
 }
 
@@ -60,8 +60,8 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// |~~~js
 /// |<div>
 /// ```
-fn initial_before(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn initial_before(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         _ => tokenizer.attempt_n(
             vec![
@@ -74,7 +74,7 @@ fn initial_before(tokenizer: &mut Tokenizer, code: Code) -> State {
                 Box::new(definition),
             ],
             |ok| Box::new(if ok { after } else { before_paragraph }),
-        )(tokenizer, code),
+        )(tokenizer),
     }
 }
 
@@ -85,12 +85,12 @@ fn initial_before(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// ```markdown
 /// ␠␠|
 /// ```
-fn blank_line_after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn blank_line_after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::BlankLineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::BlankLineEnding);
             // Feel free to interrupt.
             tokenizer.interrupt = false;
@@ -109,12 +109,12 @@ fn blank_line_after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// asd
 /// ~~~|
 /// ```
-fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+fn after(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         Code::CarriageReturnLineFeed | Code::Char('\n' | '\r') => {
             tokenizer.enter(Token::LineEnding);
-            tokenizer.consume(code);
+            tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
             State::Fn(Box::new(start))
         }
@@ -127,6 +127,6 @@ fn after(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// ```markdown
 /// |asd
 /// ```
-fn before_paragraph(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.go(paragraph, after)(tokenizer, code)
+fn before_paragraph(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.go(paragraph, after)(tokenizer)
 }
diff --git a/src/content/string.rs b/src/content/string.rs
index 5a3149a..6d45f94 100644
--- a/src/content/string.rs
+++ b/src/content/string.rs
@@ -27,8 +27,8 @@ const MARKERS: [Code; 5] = [
 ];
 
 /// Before string.
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         _ => tokenizer.attempt_n(
             vec![
@@ -40,11 +40,11 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
                 let func = if ok { start } else { before_data };
                 Box::new(func)
             },
-        )(tokenizer, code),
+        )(tokenizer),
     }
 }
 
 /// At data.
-fn before_data(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.go(|t, c| data(t, c, &MARKERS), start)(tokenizer, code)
+fn before_data(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.go(|t| data(t, &MARKERS), start)(tokenizer)
 }
diff --git a/src/content/text.rs b/src/content/text.rs
index 4e49a3d..a9cf17c 100644
--- a/src/content/text.rs
+++ b/src/content/text.rs
@@ -45,8 +45,8 @@ const MARKERS: [Code; 12] = [
 ];
 
 /// Before text.
-pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
-    match code {
+pub fn start(tokenizer: &mut Tokenizer) -> State {
+    match tokenizer.current {
         Code::None => State::Ok,
         _ => tokenizer.attempt_n(
             vec![
@@ -67,7 +67,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
                 let func = if ok { start } else { before_data };
                 Box::new(func)
             },
-        )(tokenizer, code),
+        )(tokenizer),
     }
 }
 
@@ -76,6 +76,6 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> State {
 /// ```markdown
 /// |qwe
 /// ```
-fn before_data(tokenizer: &mut Tokenizer, code: Code) -> State {
-    tokenizer.go(|t, c| data(t, c, &MARKERS), start)(tokenizer, code)
+fn before_data(tokenizer: &mut Tokenizer) -> State {
+    tokenizer.go(|t| data(t, &MARKERS), start)(tokenizer)
 }
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index 2c6726b..5ccffa8 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -88,7 +88,7 @@ pub struct Event {
 /// The essence of the state machine are functions: `StateFn`.
 /// It’s responsible for dealing with that single passed [`Code`][].
 /// It yields a [`State`][].
-pub type StateFn = dyn FnOnce(&mut Tokenizer, Code) -> State;
+pub type StateFn = dyn FnOnce(&mut Tokenizer) -> State;
 
 /// Callback that can be registered and is called when the tokenizer is done.
 ///
@@ -184,7 +184,7 @@ pub struct Tokenizer<'a> {
     /// Track whether this tokenizer is done.
     drained: bool,
     /// Current character code.
-    current: Code,
+    pub current: Code,
     /// Previous character code.
     pub previous: Code,
     /// Current relative and absolute place in the file.
@@ -282,10 +282,8 @@ impl<'a> Tokenizer<'a> {
     }
 
     /// Prepare for a next code to get consumed.
-    pub fn expect(&mut self, code: Code, force: bool) {
-        if !force {
-            assert!(self.consumed, "expected previous character to be consumed");
-        }
+    pub fn expect(&mut self, code: Code) {
+        assert!(self.consumed, "expected previous character to be consumed");
         self.consumed = false;
         self.current = code;
     }
@@ -313,17 +311,13 @@ impl<'a> Tokenizer<'a> {
     /// Consume the current character.
     /// Each [`StateFn`][] is expected to call this to signal that this code is
     /// used, or call a next `StateFn`.
-    pub fn consume(&mut self, code: Code) {
-        assert_eq!(
-            code, self.current,
-            "expected given code to equal expected code"
-        );
-        log::debug!("consume: `{:?}` ({:?})", code, self.point);
+    pub fn consume(&mut self) {
+        log::debug!("consume: `{:?}` ({:?})", self.current, self.point);
         assert!(!self.consumed, "expected code to not have been consumed: this might be because `x(code)` instead of `x` was returned");
 
         self.move_to(self.index + 1);
 
-        self.previous = code;
+        self.previous = self.current;
         // Mark as consumed.
         self.consumed = true;
     }
@@ -478,8 +472,8 @@ impl<'a> Tokenizer<'a> {
     #[allow(clippy::unused_self)]
     pub fn go(
         &mut self,
-        state_fn: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
-        after: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+        state_fn: impl FnOnce(&mut Tokenizer) -> State + 'static,
+        after: impl FnOnce(&mut Tokenizer) -> State + 'static,
     ) -> Box<StateFn> {
         attempt_impl(
             state_fn,
@@ -502,7 +496,7 @@ impl<'a> Tokenizer<'a> {
     #[allow(clippy::unused_self)]
     pub fn go_until(
         &mut self,
-        state_fn: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+        state_fn: impl FnOnce(&mut Tokenizer) -> State + 'static,
         until: impl Fn(Code) -> bool + 'static,
         done: impl FnOnce(State) -> Box<StateFn> + 'static,
     ) -> Box<StateFn> {
@@ -529,7 +523,7 @@ impl<'a> Tokenizer<'a> {
     /// captured codes to its future states.
     pub fn check(
         &mut self,
-        state_fn: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+        state_fn: impl FnOnce(&mut Tokenizer) -> State + 'static,
         done: impl FnOnce(bool) -> Box<StateFn> + 'static,
     ) -> Box<StateFn> {
         let previous = self.capture();
@@ -560,7 +554,7 @@ impl<'a> Tokenizer<'a> {
     /// `done` is called, and all captured codes are fed to its future states.
     pub fn attempt(
         &mut self,
-        state_fn: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+        state_fn: impl FnOnce(&mut Tokenizer) -> State + 'static,
         done: impl FnOnce(bool) -> Box<StateFn> + 'static,
     ) -> Box<StateFn> {
         let previous = self.capture();
@@ -599,7 +593,7 @@ impl<'a> Tokenizer<'a> {
                 if ok {
                     done(ok)
                 } else {
-                    Box::new(|t, code| t.attempt_n(state_fns, done)(t, code))
+                    Box::new(|t| t.attempt_n(state_fns, done)(t))
                 }
             })
         }
@@ -609,8 +603,8 @@ impl<'a> Tokenizer<'a> {
     /// about `ok`.
     pub fn attempt_opt(
         &mut self,
-        state_fn: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
-        after: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+        state_fn: impl FnOnce(&mut Tokenizer) -> State + 'static,
+        after: impl FnOnce(&mut Tokenizer) -> State + 'static,
     ) -> Box<StateFn> {
         self.attempt(state_fn, |_ok| Box::new(after))
     }
@@ -623,7 +617,7 @@ impl<'a> Tokenizer<'a> {
         &mut self,
         min: usize,
         max: usize,
-        start: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+        start: impl FnOnce(&mut Tokenizer) -> State + 'static,
         drain: bool,
     ) -> State {
         assert!(!self.drained, "cannot feed after drain");
@@ -652,7 +646,7 @@ impl<'a> Tokenizer<'a> {
     }
 
     /// Flush the tokenizer.
-    pub fn flush(&mut self, start: impl FnOnce(&mut Tokenizer, Code) -> State + 'static) -> State {
+    pub fn flush(&mut self, start: impl FnOnce(&mut Tokenizer) -> State + 'static) -> State {
         flush_impl(self, self.index, start)
     }
 }
@@ -662,12 +656,12 @@ impl<'a> Tokenizer<'a> {
 /// Recurses into itself.
 /// Used in [`Tokenizer::attempt`][Tokenizer::attempt] and  [`Tokenizer::check`][Tokenizer::check].
 fn attempt_impl(
-    state: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+    state: impl FnOnce(&mut Tokenizer) -> State + 'static,
     pause: Option<Box<dyn Fn(Code) -> bool + 'static>>,
     start: usize,
     done: impl FnOnce((usize, usize), &mut Tokenizer, State) -> State + 'static,
 ) -> Box<StateFn> {
-    Box::new(move |tokenizer, code| {
+    Box::new(move |tokenizer| {
         if let Some(ref func) = pause {
             if tokenizer.index > start && func(tokenizer.previous) {
                 return done(
@@ -678,7 +672,7 @@ fn attempt_impl(
             }
         }
 
-        let state = state(tokenizer, code);
+        let state = state(tokenizer);
 
         match state {
             State::Ok => {
@@ -700,7 +694,7 @@ fn feed_impl(
     tokenizer: &mut Tokenizer,
     min: usize,
     max: usize,
-    start: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+    start: impl FnOnce(&mut Tokenizer) -> State + 'static,
 ) -> State {
     let mut state = State::Fn(Box::new(start));
 
@@ -716,8 +710,8 @@ fn feed_impl(
             }
             State::Fn(func) => {
                 log::debug!("main: passing: `{:?}` ({:?})", code, tokenizer.index);
-                tokenizer.expect(code, false);
-                state = func(tokenizer, code);
+                tokenizer.expect(code);
+                state = func(tokenizer);
             }
         }
     }
@@ -729,7 +723,7 @@ fn feed_impl(
 fn flush_impl(
     tokenizer: &mut Tokenizer,
     max: usize,
-    start: impl FnOnce(&mut Tokenizer, Code) -> State + 'static,
+    start: impl FnOnce(&mut Tokenizer) -> State + 'static,
 ) -> State {
     let mut state = State::Fn(Box::new(start));
     tokenizer.consumed = true;
@@ -744,8 +738,8 @@ fn flush_impl(
                     Code::None
                 };
                 log::debug!("main: flushing {:?}", code);
-                tokenizer.expect(code, false);
-                state = func(tokenizer, code);
+                tokenizer.expect(code);
+                state = func(tokenizer);
             }
         }
     }