diff --git a/crates/typos/src/tokens.rs b/crates/typos/src/tokens.rs
index fc3f42b..c5d5366 100644
--- a/crates/typos/src/tokens.rs
+++ b/crates/typos/src/tokens.rs
@@ -145,7 +145,7 @@ mod parser {
     /// later may cause it to fail.
     const NON_TERMINATING_CAP: usize = 1024;
 
-    pub(crate) fn next_identifier<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    pub(crate) fn next_identifier<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -155,7 +155,7 @@ mod parser {
         preceded(ignore, identifier).parse_next(input)
     }
 
-    fn identifier<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn identifier<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -173,7 +173,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn ignore<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn ignore<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -204,7 +204,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn sep1<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn sep1<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -217,7 +217,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn other<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn other<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -234,7 +234,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn ordinal_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn ordinal_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -260,7 +260,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn dec_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn dec_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -269,7 +269,7 @@ mod parser {
         trace("dec_literal", take_while(1.., is_dec_digit_with_sep)).parse_next(input)
     }
 
-    fn hex_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn hex_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -281,7 +281,7 @@ mod parser {
             .parse_next(input)
     }
 
-    fn css_color<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn css_color<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -302,7 +302,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn jwt<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn jwt<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -337,7 +337,7 @@ mod parser {
             || c == '-'
     }
 
-    fn uuid_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn uuid_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -375,7 +375,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn hash_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn hash_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -401,7 +401,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn base64_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn base64_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -425,10 +425,7 @@ mod parser {
                     .iter()
                     .all(|c| !['/', '+'].contains(&c.as_char()))
             {
-                return Err(winnow::error::ErrMode::from_error_kind(
-                    input,
-                    winnow::error::ErrorKind::Slice,
-                ));
+                return Err(winnow::error::ErrMode::from_input(input));
             }
 
             take_while(padding_len..=padding_len, is_base64_padding).parse_next(input)?;
@@ -440,7 +437,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn email_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn email_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -459,7 +456,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn url_literal<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn url_literal<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -492,7 +489,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn url_userinfo<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn url_userinfo<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
@@ -510,7 +507,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn c_escape<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn c_escape<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Stream + StreamIsPartial + PartialEq,
         <T as Stream>::Slice: AsBStr + SliceLen + Default,
@@ -531,7 +528,7 @@ mod parser {
         .parse_next(input)
     }
 
-    fn printf<T>(input: &mut T) -> PResult<<T as Stream>::Slice, ()>
+    fn printf<T>(input: &mut T) -> ModalResult<<T as Stream>::Slice, ()>
     where
         T: Compare<char>,
         T: Stream + StreamIsPartial + PartialEq,
diff --git a/crates/varcon-core/src/parser.rs b/crates/varcon-core/src/parser.rs
index adc6bea..8da9b7b 100644
--- a/crates/varcon-core/src/parser.rs
+++ b/crates/varcon-core/src/parser.rs
@@ -546,7 +546,7 @@ impl Cluster {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Self, ()> {
         trace("cluster", move |input: &mut &str| {
             let header = (
                 "#",
@@ -966,7 +966,7 @@ impl Entry {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Self, ()> {
         trace("entry", move |input: &mut &str| {
             let var_sep = (winnow::ascii::space0, '/', winnow::ascii::space0);
             let variants =
@@ -987,7 +987,7 @@ impl Entry {
         .parse_next(input)
     }
 
-    fn parse_description(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_description(input: &mut &str) -> ModalResult<Self, ()> {
         trace("description", move |input: &mut &str| {
             let mut entry = Self {
                 variants: Vec::new(),
@@ -1023,18 +1023,18 @@ impl Entry {
     }
 }
 
-fn note(input: &mut &str) -> PResult<String, ()> {
+fn note(input: &mut &str) -> ModalResult<String, ()> {
     let (_, _, note) = (NOTE_PREFIX, space1, description).parse_next(input)?;
     Ok(note)
 }
 
 const NOTE_PREFIX: &str = "--";
 
-fn archaic(input: &mut &str) -> PResult<(), ()> {
+fn archaic(input: &mut &str) -> ModalResult<(), ()> {
     "(-)".void().parse_next(input)
 }
 
-fn description(input: &mut &str) -> PResult<String, ()> {
+fn description(input: &mut &str) -> ModalResult<String, ()> {
     let description = winnow::token::take_till(0.., ('\n', '\r', '#', '|')).parse_next(input)?;
     Ok(description.to_owned())
 }
@@ -1573,7 +1573,7 @@ impl Variant {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Self, ()> {
         trace("variant", move |input: &mut &str| {
             let types = winnow::combinator::separated(1.., Type::parse_, space1);
             let columns =
@@ -1592,7 +1592,7 @@ impl Variant {
     }
 }
 
-fn word(input: &mut &str) -> PResult<String, ()> {
+fn word(input: &mut &str) -> ModalResult<String, ()> {
     trace("word", move |input: &mut &str| {
         winnow::token::take_till(1.., |item: char| item.is_ascii_whitespace())
             .map(|s: &str| s.to_owned().replace('_', " "))
@@ -1734,7 +1734,7 @@ impl Type {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Type, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Type, ()> {
         trace("type", move |input: &mut &str| {
             let category = Category::parse_(input)?;
             let tag = opt(Tag::parse_).parse_next(input)?;
@@ -1850,7 +1850,7 @@ impl Category {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Self, ()> {
         trace("category", move |input: &mut &str| {
             let symbols = one_of(['A', 'B', 'Z', 'C', 'D', '_']);
             symbols
@@ -1909,7 +1909,7 @@ impl Tag {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Self, ()> {
         trace("tag", move |input: &mut &str| {
             let symbols = one_of(['.', 'v', 'V', '-', 'x']);
             symbols
@@ -1967,7 +1967,7 @@ impl Pos {
         Self::parse_.parse(input).map_err(|_err| ParseError)
     }
 
-    fn parse_(input: &mut &str) -> PResult<Self, ()> {
+    fn parse_(input: &mut &str) -> ModalResult<Self, ()> {
         trace("pos", move |input: &mut &str| {
             alt((
                 "N".value(Pos::Noun),