diff --git a/biscuit-auth/Cargo.toml b/biscuit-auth/Cargo.toml
index a7756e39..d67584f0 100644
--- a/biscuit-auth/Cargo.toml
+++ b/biscuit-auth/Cargo.toml
@@ -27,20 +27,18 @@ pem = ["ed25519-dalek/pem", "ed25519-dalek/pkcs8"]
 
 [dependencies]
 rand_core = "^0.6"
-sha2 = "^0.9"
-prost = "0.10"
-prost-types = "0.10"
+prost = "0.14.3"
+prost-types = "0.14.3"
 regex = { version = "1.5", default-features = false, features = ["std"] }
-nom = { version = "7", default-features = false, features = ["std"] }
+nom = { version = "8.0.0", default-features = false, features = ["std"] }
 hex = "0.4"
 zeroize = { version = "1.5", default-features = false }
-thiserror = "1"
+thiserror = "2.0.18"
 rand = { version = "0.8" }
 wasm-bindgen = { version = "0.2", optional = true }
-base64 = "0.13.0"
+base64 = "0.22.1"
 ed25519-dalek = { version = "2.0.0", features = ["rand_core", "zeroize"] }
 serde = { version = "1.0.132", optional = true, features = ["derive"] }
-getrandom = { version = "0.2.15" }
 time = { version = "0.3.7", features = ["formatting", "parsing"] }
 uuid = { version = "1", optional = true }
 biscuit-parser = { version = "0.2.0", path = "../biscuit-parser" }
@@ -51,7 +49,6 @@ chrono = { version = "0.4.26", optional = true, default-features = false, featur
 serde_json = "1.0.117"
 ecdsa = { version = "0.16.9", features = ["signing", "verifying", "pem", "alloc", "pkcs8", "serde"] }
 p256 = "0.13.2"
-pkcs8 = "0.9.0"
 elliptic-curve = { version = "0.13.8", features = ["pkcs8"] }
 
 [dev-dependencies]
@@ -59,7 +56,7 @@ bencher = "0.1.5"
 rand = "0.8"
 chrono = { version = "0.4.26", features = ["serde", "clock"] }
 colored-diff = "0.2.3"
-prost-build = "0.10"
+prost-build = "0.14.3"
 serde = { version = "1.0.130", features = ["derive"] }
 serde_json = "1.0.67"
 codspeed-bencher-compat = "2.6.0"
diff --git a/biscuit-auth/examples/testcases.rs b/biscuit-auth/examples/testcases.rs
index eedcefa5..67cee100 100644
--- a/biscuit-auth/examples/testcases.rs
+++ b/biscuit-auth/examples/testcases.rs
@@ -821,9 +821,7 @@ fn reordered_blocks(target: &str, root: &KeyPair, test: bool) -> TestResult {
     let token = print_blocks(&biscuit3);
 
     let mut serialized = biscuit3.container().clone();
-    let mut blocks = vec![];
-    blocks.push(serialized.blocks[1].clone());
-    blocks.push(serialized.blocks[0].clone());
+    let blocks = vec![serialized.blocks[1].clone(), serialized.blocks[0].clone()];
     serialized.blocks = blocks;
 
     let data = if test {
diff --git a/biscuit-auth/src/error.rs b/biscuit-auth/src/error.rs
index 143ebe3f..f041ab58 100644
--- a/biscuit-auth/src/error.rs
+++ b/biscuit-auth/src/error.rs
@@ -67,10 +67,11 @@ impl From<base64::DecodeError> for Token {
             base64::DecodeError::InvalidByte(offset, byte) => {
                 Base64Error::InvalidByte(offset, byte)
             }
-            base64::DecodeError::InvalidLength => Base64Error::InvalidLength,
+            base64::DecodeError::InvalidLength(len) => Base64Error::InvalidLength(len),
             base64::DecodeError::InvalidLastSymbol(offset, byte) => {
                 Base64Error::InvalidLastSymbol(offset, byte)
             }
+            base64::DecodeError::InvalidPadding => Base64Error::InvalidPadding,
         };
 
         Token::Base64(err)
@@ -90,8 +91,9 @@ impl From<Execution> for Token {
 #[cfg_attr(feature = "serde-error", derive(serde::Serialize, serde::Deserialize))]
 pub enum Base64Error {
     InvalidByte(usize, u8),
-    InvalidLength,
+    InvalidLength(usize),
     InvalidLastSymbol(usize, u8),
+    InvalidPadding,
 }
 
 impl std::fmt::Display for Base64Error {
@@ -100,10 +102,13 @@ impl std::fmt::Display for Base64Error {
             Base64Error::InvalidByte(index, byte) => {
                 write!(f, "Invalid byte {byte}, offset {index}.")
             }
-            Base64Error::InvalidLength => write!(f, "Encoded text cannot have a 6-bit remainder."),
+            Base64Error::InvalidLength(len) => {
+                write!(f, "Invalid input length: {len}.")
+            }
             Base64Error::InvalidLastSymbol(index, byte) => {
                 write!(f, "Invalid last symbol {byte}, offset {index}.")
             }
+            Base64Error::InvalidPadding => write!(f, "Invalid padding"),
         }
     }
 }
@@ -315,8 +320,8 @@ mod tests {
         );
 
         assert_eq!(
-            format!("{}", Token::Base64(Base64Error::InvalidLength)),
-            "Cannot decode base64 token: Encoded text cannot have a 6-bit remainder."
+            format!("{}", Token::Base64(Base64Error::InvalidLength(6))),
+            "Cannot decode base64 token: Invalid input length: 6."
         );
 
         assert_eq!(
diff --git a/biscuit-auth/src/format/convert.rs b/biscuit-auth/src/format/convert.rs
index d1932601..2b0bcf8f 100644
--- a/biscuit-auth/src/format/convert.rs
+++ b/biscuit-auth/src/format/convert.rs
@@ -4,6 +4,8 @@
  */
 //! helper functions for conversion between internal structures and Protobuf
 
+use prost::UnknownEnumValue;
+
 use super::schema;
 use crate::builder::Convert;
 use crate::crypto::PublicKey;
@@ -18,6 +20,7 @@ use crate::token::{DATALOG_3_1, DATALOG_3_2, DATALOG_3_3, MAX_SCHEMA_VERSION, MI
 
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
+use std::convert::TryFrom;
 
 pub fn token_block_to_proto_block(input: &Block) -> schema::Block {
     schema::Block {
@@ -380,12 +383,13 @@ pub fn proto_policy_to_policy(
         queries.push(c);
     }
 
-    let kind = if let Some(i) = Kind::from_i32(input.kind) {
-        i
-    } else {
-        return Err(error::Format::DeserializationError(
-            "deserialization error: invalid policy kind".to_string(),
-        ));
+    let kind = match Kind::try_from(input.kind) {
+        Ok(i) => i,
+        Err(UnknownEnumValue(i)) => {
+            return Err(error::Format::DeserializationError(format!(
+                "deserialization error: invalid policy kind `{i}`"
+            )));
+        }
     };
 
     let kind = match kind {
@@ -710,24 +714,24 @@ fn proto_op_to_token_op(op: &schema::Op) -> Result<Op, error::Format> {
     Ok(match op.content.as_ref() {
         Some(op::Content::Value(id)) => Op::Value(proto_id_to_token_term(id)?),
         Some(op::Content::Unary(u)) => {
-            match (op_unary::Kind::from_i32(u.kind), u.ffi_name.as_ref()) {
-                (Some(op_unary::Kind::Negate), None) => Op::Unary(Unary::Negate),
-                (Some(op_unary::Kind::Parens), None) => Op::Unary(Unary::Parens),
-                (Some(op_unary::Kind::Length), None) => Op::Unary(Unary::Length),
-                (Some(op_unary::Kind::TypeOf), None) => Op::Unary(Unary::TypeOf),
-                (Some(op_unary::Kind::Ffi), Some(n)) => Op::Unary(Unary::Ffi(*n)),
-                (Some(op_unary::Kind::Ffi), None) => {
+            match (op_unary::Kind::try_from(u.kind), u.ffi_name.as_ref()) {
+                (Ok(op_unary::Kind::Negate), None) => Op::Unary(Unary::Negate),
+                (Ok(op_unary::Kind::Parens), None) => Op::Unary(Unary::Parens),
+                (Ok(op_unary::Kind::Length), None) => Op::Unary(Unary::Length),
+                (Ok(op_unary::Kind::TypeOf), None) => Op::Unary(Unary::TypeOf),
+                (Ok(op_unary::Kind::Ffi), Some(n)) => Op::Unary(Unary::Ffi(*n)),
+                (Ok(op_unary::Kind::Ffi), None) => {
                     return Err(error::Format::DeserializationError(
                         "deserialization error: missing ffi name".to_string(),
                     ))
                 }
-                (Some(_), Some(_)) => {
+                (Ok(_), Some(_)) => {
                     return Err(error::Format::DeserializationError(
                         "deserialization error: ffi name set on a regular unary operation"
                             .to_string(),
                     ))
                 }
-                (None, _) => {
+                (Err(_), _) => {
                     return Err(error::Format::DeserializationError(
                         "deserialization error: unary operation is empty".to_string(),
                     ))
@@ -735,53 +739,53 @@ fn proto_op_to_token_op(op: &schema::Op) -> Result<Op, error::Format> {
             }
         }
         Some(op::Content::Binary(b)) => {
-            match (op_binary::Kind::from_i32(b.kind), b.ffi_name.as_ref()) {
-                (Some(op_binary::Kind::LessThan), None) => Op::Binary(Binary::LessThan),
-                (Some(op_binary::Kind::GreaterThan), None) => Op::Binary(Binary::GreaterThan),
-                (Some(op_binary::Kind::LessOrEqual), None) => Op::Binary(Binary::LessOrEqual),
-                (Some(op_binary::Kind::GreaterOrEqual), None) => Op::Binary(Binary::GreaterOrEqual),
-                (Some(op_binary::Kind::Equal), None) => Op::Binary(Binary::Equal),
-                (Some(op_binary::Kind::Contains), None) => Op::Binary(Binary::Contains),
-                (Some(op_binary::Kind::Prefix), None) => Op::Binary(Binary::Prefix),
-                (Some(op_binary::Kind::Suffix), None) => Op::Binary(Binary::Suffix),
-                (Some(op_binary::Kind::Regex), None) => Op::Binary(Binary::Regex),
-                (Some(op_binary::Kind::Add), None) => Op::Binary(Binary::Add),
-                (Some(op_binary::Kind::Sub), None) => Op::Binary(Binary::Sub),
-                (Some(op_binary::Kind::Mul), None) => Op::Binary(Binary::Mul),
-                (Some(op_binary::Kind::Div), None) => Op::Binary(Binary::Div),
-                (Some(op_binary::Kind::And), None) => Op::Binary(Binary::And),
-                (Some(op_binary::Kind::Or), None) => Op::Binary(Binary::Or),
-                (Some(op_binary::Kind::Intersection), None) => Op::Binary(Binary::Intersection),
-                (Some(op_binary::Kind::Union), None) => Op::Binary(Binary::Union),
-                (Some(op_binary::Kind::BitwiseAnd), None) => Op::Binary(Binary::BitwiseAnd),
-                (Some(op_binary::Kind::BitwiseOr), None) => Op::Binary(Binary::BitwiseOr),
-                (Some(op_binary::Kind::BitwiseXor), None) => Op::Binary(Binary::BitwiseXor),
-                (Some(op_binary::Kind::NotEqual), None) => Op::Binary(Binary::NotEqual),
-                (Some(op_binary::Kind::HeterogeneousEqual), None) => {
+            match (op_binary::Kind::try_from(b.kind), b.ffi_name.as_ref()) {
+                (Ok(op_binary::Kind::LessThan), None) => Op::Binary(Binary::LessThan),
+                (Ok(op_binary::Kind::GreaterThan), None) => Op::Binary(Binary::GreaterThan),
+                (Ok(op_binary::Kind::LessOrEqual), None) => Op::Binary(Binary::LessOrEqual),
+                (Ok(op_binary::Kind::GreaterOrEqual), None) => Op::Binary(Binary::GreaterOrEqual),
+                (Ok(op_binary::Kind::Equal), None) => Op::Binary(Binary::Equal),
+                (Ok(op_binary::Kind::Contains), None) => Op::Binary(Binary::Contains),
+                (Ok(op_binary::Kind::Prefix), None) => Op::Binary(Binary::Prefix),
+                (Ok(op_binary::Kind::Suffix), None) => Op::Binary(Binary::Suffix),
+                (Ok(op_binary::Kind::Regex), None) => Op::Binary(Binary::Regex),
+                (Ok(op_binary::Kind::Add), None) => Op::Binary(Binary::Add),
+                (Ok(op_binary::Kind::Sub), None) => Op::Binary(Binary::Sub),
+                (Ok(op_binary::Kind::Mul), None) => Op::Binary(Binary::Mul),
+                (Ok(op_binary::Kind::Div), None) => Op::Binary(Binary::Div),
+                (Ok(op_binary::Kind::And), None) => Op::Binary(Binary::And),
+                (Ok(op_binary::Kind::Or), None) => Op::Binary(Binary::Or),
+                (Ok(op_binary::Kind::Intersection), None) => Op::Binary(Binary::Intersection),
+                (Ok(op_binary::Kind::Union), None) => Op::Binary(Binary::Union),
+                (Ok(op_binary::Kind::BitwiseAnd), None) => Op::Binary(Binary::BitwiseAnd),
+                (Ok(op_binary::Kind::BitwiseOr), None) => Op::Binary(Binary::BitwiseOr),
+                (Ok(op_binary::Kind::BitwiseXor), None) => Op::Binary(Binary::BitwiseXor),
+                (Ok(op_binary::Kind::NotEqual), None) => Op::Binary(Binary::NotEqual),
+                (Ok(op_binary::Kind::HeterogeneousEqual), None) => {
                     Op::Binary(Binary::HeterogeneousEqual)
                 }
-                (Some(op_binary::Kind::HeterogeneousNotEqual), None) => {
+                (Ok(op_binary::Kind::HeterogeneousNotEqual), None) => {
                     Op::Binary(Binary::HeterogeneousNotEqual)
                 }
-                (Some(op_binary::Kind::LazyAnd), None) => Op::Binary(Binary::LazyAnd),
-                (Some(op_binary::Kind::LazyOr), None) => Op::Binary(Binary::LazyOr),
-                (Some(op_binary::Kind::All), None) => Op::Binary(Binary::All),
-                (Some(op_binary::Kind::Any), None) => Op::Binary(Binary::Any),
-                (Some(op_binary::Kind::Get), None) => Op::Binary(Binary::Get),
-                (Some(op_binary::Kind::Ffi), Some(n)) => Op::Binary(Binary::Ffi(*n)),
-                (Some(op_binary::Kind::Ffi), None) => {
+                (Ok(op_binary::Kind::LazyAnd), None) => Op::Binary(Binary::LazyAnd),
+                (Ok(op_binary::Kind::LazyOr), None) => Op::Binary(Binary::LazyOr),
+                (Ok(op_binary::Kind::All), None) => Op::Binary(Binary::All),
+                (Ok(op_binary::Kind::Any), None) => Op::Binary(Binary::Any),
+                (Ok(op_binary::Kind::Get), None) => Op::Binary(Binary::Get),
+                (Ok(op_binary::Kind::Ffi), Some(n)) => Op::Binary(Binary::Ffi(*n)),
+                (Ok(op_binary::Kind::Ffi), None) => {
                     return Err(error::Format::DeserializationError(
                         "deserialization error: missing ffi name".to_string(),
                     ))
                 }
-                (Some(_), Some(_)) => {
+                (Ok(_), Some(_)) => {
                     return Err(error::Format::DeserializationError(
                         "deserialization error: ffi name set on a regular binary operation"
                             .to_string(),
                     ))
                 }
-                (Some(op_binary::Kind::TryOr), None) => Op::Binary(Binary::TryOr),
-                (None, _) => {
+                (Ok(op_binary::Kind::TryOr), None) => Op::Binary(Binary::TryOr),
+                (Err(_), _) => {
                     return Err(error::Format::DeserializationError(
                         "deserialization error: binary operation is empty".to_string(),
                     ))
diff --git a/biscuit-auth/src/token/authorizer/snapshot.rs b/biscuit-auth/src/token/authorizer/snapshot.rs
index d7c269a2..bf12d113 100644
--- a/biscuit-auth/src/token/authorizer/snapshot.rs
+++ b/biscuit-auth/src/token/authorizer/snapshot.rs
@@ -2,6 +2,7 @@
  * Copyright (c) 2019 Geoffroy Couprie <contact@geoffroycouprie.com> and Contributors to the Eclipse Foundation.
  * SPDX-License-Identifier: Apache-2.0
  */
+use base64::prelude::*;
 use prost::Message;
 use std::{collections::HashMap, time::Duration};
 
@@ -180,7 +181,7 @@ impl super::Authorizer {
     }
 
     pub fn from_base64_snapshot(input: &str) -> Result<Self, error::Token> {
-        let bytes = base64::decode_config(input, base64::URL_SAFE)?;
+        let bytes = BASE64_URL_SAFE.decode(input)?;
         Self::from_raw_snapshot(&bytes)
     }
 
@@ -270,7 +271,7 @@ impl super::Authorizer {
 
     pub fn to_base64_snapshot(&self) -> Result<String, error::Format> {
         let snapshot_bytes = self.to_raw_snapshot()?;
-        Ok(base64::encode_config(snapshot_bytes, base64::URL_SAFE))
+        Ok(BASE64_URL_SAFE.encode(snapshot_bytes))
     }
 }
 
diff --git a/biscuit-auth/src/token/builder/authorizer.rs b/biscuit-auth/src/token/builder/authorizer.rs
index 14d7b72f..18839aba 100644
--- a/biscuit-auth/src/token/builder/authorizer.rs
+++ b/biscuit-auth/src/token/builder/authorizer.rs
@@ -9,6 +9,7 @@ use std::{
     time::{Duration, SystemTime},
 };
 
+use base64::prelude::*;
 use biscuit_parser::parser::parse_source;
 use prost::Message;
 
@@ -635,7 +636,7 @@ impl AuthorizerBuilder {
     }
 
     pub fn from_base64_snapshot(input: &str) -> Result<Self, error::Token> {
-        let bytes = base64::decode_config(input, base64::URL_SAFE)?;
+        let bytes = BASE64_URL_SAFE.decode(input)?;
         Self::from_raw_snapshot(&bytes)
     }
 
@@ -696,6 +697,6 @@ impl AuthorizerBuilder {
 
     pub fn to_base64_snapshot(&self) -> Result<String, error::Format> {
         let snapshot_bytes = self.to_raw_snapshot()?;
-        Ok(base64::encode_config(snapshot_bytes, base64::URL_SAFE))
+        Ok(BASE64_URL_SAFE.encode(snapshot_bytes))
     }
 }
diff --git a/biscuit-auth/src/token/mod.rs b/biscuit-auth/src/token/mod.rs
index 218804c9..cddeca7c 100644
--- a/biscuit-auth/src/token/mod.rs
+++ b/biscuit-auth/src/token/mod.rs
@@ -6,6 +6,7 @@
 use std::fmt::Display;
 use std::iter::once;
 
+use base64::prelude::*;
 use builder::{BiscuitBuilder, BlockBuilder};
 use prost::Message;
 use rand_core::{CryptoRng, RngCore};
@@ -142,7 +143,7 @@ impl Biscuit {
         self.container
             .to_vec()
             .map_err(error::Token::Format)
-            .map(|v| base64::encode_config(v, base64::URL_SAFE))
+            .map(|v| BASE64_URL_SAFE.encode(v))
     }
 
     /// serializes the token
@@ -346,7 +347,7 @@ impl Biscuit {
         T: AsRef<[u8]>,
         KP: RootKeyProvider,
     {
-        let decoded = base64::decode_config(slice, base64::URL_SAFE)?;
+        let decoded = BASE64_URL_SAFE.decode(slice)?;
         Biscuit::from_with_symbols(&decoded, key_provider, symbols)
     }
 
diff --git a/biscuit-auth/src/token/third_party.rs b/biscuit-auth/src/token/third_party.rs
index 7150c96a..d3706f89 100644
--- a/biscuit-auth/src/token/third_party.rs
+++ b/biscuit-auth/src/token/third_party.rs
@@ -4,6 +4,7 @@
  */
 use std::cmp::max;
 
+use base64::prelude::*;
 use prost::Message;
 
 use crate::{
@@ -59,7 +60,7 @@ impl ThirdPartyRequest {
     }
 
     pub fn serialize_base64(&self) -> Result<String, error::Token> {
-        Ok(base64::encode_config(self.serialize()?, base64::URL_SAFE))
+        Ok(BASE64_URL_SAFE.encode(self.serialize()?))
     }
 
     pub fn deserialize(slice: &[u8]) -> Result<Self, error::Token> {
@@ -88,7 +89,7 @@ impl ThirdPartyRequest {
     where
         T: AsRef<[u8]>,
     {
-        let decoded = base64::decode_config(slice, base64::URL_SAFE)?;
+        let decoded = BASE64_URL_SAFE.decode(slice)?;
         Self::deserialize(&decoded)
     }
 
@@ -149,7 +150,7 @@ impl ThirdPartyBlock {
     }
 
     pub fn serialize_base64(&self) -> Result<String, error::Token> {
-        Ok(base64::encode_config(self.serialize()?, base64::URL_SAFE))
+        Ok(BASE64_URL_SAFE.encode(self.serialize()?))
     }
 }
 
diff --git a/biscuit-auth/src/token/unverified.rs b/biscuit-auth/src/token/unverified.rs
index 9eea9c53..2012cd28 100644
--- a/biscuit-auth/src/token/unverified.rs
+++ b/biscuit-auth/src/token/unverified.rs
@@ -2,7 +2,10 @@
  * Copyright (c) 2019 Geoffroy Couprie <contact@geoffroycouprie.com> and Contributors to the Eclipse Foundation.
  * SPDX-License-Identifier: Apache-2.0
  */
-use prost::Message;
+use std::convert::TryFrom as _;
+
+use base64::prelude::*;
+use prost::{Message, UnknownEnumValue};
 
 use super::{default_symbol_table, Biscuit, Block};
 use crate::{
@@ -120,7 +123,7 @@ impl UnverifiedBiscuit {
         self.container
             .to_vec()
             .map_err(error::Token::Format)
-            .map(|v| base64::encode_config(v, base64::URL_SAFE))
+            .map(|v| BASE64_URL_SAFE.encode(v))
     }
 
     /// deserializes from raw bytes with a custom symbol table
@@ -145,7 +148,7 @@ impl UnverifiedBiscuit {
     where
         T: AsRef<[u8]>,
     {
-        let decoded = base64::decode_config(slice, base64::URL_SAFE)?;
+        let decoded = BASE64_URL_SAFE.decode(slice)?;
         Self::from_with_symbols(&decoded, symbols)
     }
 
@@ -317,12 +320,13 @@ impl UnverifiedBiscuit {
             error::Format::DeserializationError(format!("deserialization error: {e:?}"))
         })?;
 
-        let algorithm =
-            Algorithm::from_i32(external_signature.public_key.algorithm).ok_or_else(|| {
-                error::Format::DeserializationError(
-                    "deserialization error: invalid external key algorithm".to_string(),
-                )
-            })?;
+        let algorithm = Algorithm::try_from(external_signature.public_key.algorithm).map_err(
+            |UnknownEnumValue(v)| {
+                error::Format::DeserializationError(format!(
+                    "deserialization error: invalid external key algorithm `{v}`"
+                ))
+            },
+        )?;
         let external_key =
             PublicKey::from_bytes(&external_signature.public_key.key, algorithm.into()).map_err(
                 |e| {
@@ -371,7 +375,7 @@ impl UnverifiedBiscuit {
     where
         T: AsRef<[u8]>,
     {
-        let decoded = base64::decode_config(slice, base64::URL_SAFE)?;
+        let decoded = BASE64_URL_SAFE.decode(slice)?;
         self.append_third_party(&decoded)
     }
 }
diff --git a/biscuit-parser/Cargo.toml b/biscuit-parser/Cargo.toml
index ed500325..0e89088a 100644
--- a/biscuit-parser/Cargo.toml
+++ b/biscuit-parser/Cargo.toml
@@ -12,11 +12,11 @@ repository = "https://github.com/biscuit-auth/biscuit-rust"
 
 [dependencies]
 hex = "0.4.3"
-nom = "7.1.1"
+nom = "8.0.0"
 proc-macro2 = "1"
 quote = "1.0.21"
 serde = { version = "1.0.132", optional = true, features = ["derive"] }
-thiserror = "1.0.32"
+thiserror = "2.0.18"
 time = {version = "0.3.7", features = ["formatting", "parsing"]}
 
 [features]
diff --git a/biscuit-parser/src/parser.rs b/biscuit-parser/src/parser.rs
index e22d88e8..14f4fbc7 100644
--- a/biscuit-parser/src/parser.rs
+++ b/biscuit-parser/src/parser.rs
@@ -10,15 +10,12 @@ use crate::builder::{self, CheckKind, PublicKey};
 use nom::{
     branch::alt,
     bytes::complete::{escaped_transform, tag, tag_no_case, take_until, take_while, take_while1},
-    character::{
-        complete::{char, digit1, multispace0 as space0, satisfy},
-        is_alphabetic, is_alphanumeric,
-    },
+    character::complete::{char, digit1, multispace0 as space0, satisfy},
     combinator::{consumed, cut, eof, map, map_res, opt, recognize, value},
     error::{ErrorKind, FromExternalError, ParseError},
     multi::{many0, separated_list0, separated_list1},
-    sequence::{delimited, pair, preceded, separated_pair, terminated, tuple},
-    IResult, Offset, Parser,
+    sequence::{delimited, pair, preceded, separated_pair, terminated},
+    AsChar as _, IResult, Offset, Parser,
 };
 use std::{
     collections::{BTreeMap, BTreeSet},
@@ -34,7 +31,8 @@ pub fn fact(i: &str) -> IResult<&str, builder::Fact, Error> {
         preceded(space0, eof),
         |input| format!("unexpected trailing data after fact: '{input}'"),
         " ,\n",
-    )(i)?;
+    )
+    .parse(i)?;
 
     Ok((i, fact))
 }
@@ -51,7 +49,8 @@ pub fn fact_inner(i: &str) -> IResult<&str, builder::Fact, Error> {
             cut(term_in_fact),
         )),
         preceded(space0, char(')')),
-    )(i)?;
+    )
+    .parse(i)?;
 
     Ok((i, builder::Fact::new(fact_name.to_string(), terms)))
 }
@@ -69,7 +68,7 @@ pub fn check(i: &str) -> IResult<&str, builder::Check, Error> {
         }
         },
         " ,\n",
-    )(i)?;
+    ).parse(i)?;
 
     Ok((i, check))
 }
@@ -81,9 +80,10 @@ fn check_inner(i: &str) -> IResult<&str, builder::Check, Error> {
         map(tag_no_case("check if"), |_| CheckKind::One),
         map(tag_no_case("check all"), |_| CheckKind::All),
         map(tag_no_case("reject if"), |_| CheckKind::Reject),
-    ))(i)?;
+    ))
+    .parse(i)?;
 
-    let (i, queries) = cut(check_body)(i)?;
+    let (i, queries) = cut(check_body).parse(i)?;
     Ok((i, builder::Check { queries, kind }))
 }
 
@@ -100,22 +100,22 @@ pub fn policy(i: &str) -> IResult<&str, builder::Policy, Error> {
         }
         },
         " ,\n",
-    )(i)?;
+    ).parse(i)?;
 
     Ok((i, policy))
 }
 
 fn policy_inner(i: &str) -> IResult<&str, builder::Policy, Error> {
-    alt((allow, deny))(i)
+    alt((allow, deny)).parse(i)
 }
 
 /// parse an allow rule
 pub fn allow(i: &str) -> IResult<&str, builder::Policy, Error> {
     let (i, _) = space0(i)?;
 
-    let (i, _) = tag_no_case("allow if")(i)?;
+    let (i, _) = tag_no_case("allow if").parse(i)?;
 
-    let (i, queries) = cut(check_body)(i)?;
+    let (i, queries) = cut(check_body).parse(i)?;
     Ok((
         i,
         builder::Policy {
@@ -129,9 +129,9 @@ pub fn allow(i: &str) -> IResult<&str, builder::Policy, Error> {
 pub fn deny(i: &str) -> IResult<&str, builder::Policy, Error> {
     let (i, _) = space0(i)?;
 
-    let (i, _) = tag_no_case("deny if")(i)?;
+    let (i, _) = tag_no_case("deny if").parse(i)?;
 
-    let (i, queries) = cut(check_body)(i)?;
+    let (i, queries) = cut(check_body).parse(i)?;
     Ok((
         i,
         builder::Policy {
@@ -146,7 +146,8 @@ pub fn check_body(i: &str) -> IResult<&str, Vec<builder::Rule>, Error> {
     let (i, mut queries) = separated_list1(
         preceded(space0, tag_no_case("or")),
         preceded(space0, cut(rule_body)),
-    )(i)?;
+    )
+    .parse(i)?;
 
     let queries = queries
         .drain(..)
@@ -176,7 +177,8 @@ pub fn rule(i: &str) -> IResult<&str, builder::Rule, Error> {
             _ => format!("expected the next term or expression after ',', but got '{input}'"),
         },
         " ,\n",
-    )(i)?;
+    )
+    .parse(i)?;
 
     Ok((i, rule))
 }
@@ -186,12 +188,13 @@ pub fn rule_inner(i: &str) -> IResult<&str, builder::Rule, Error> {
         let (i, head) = rule_head(i)?;
         let (i, _) = space0(i)?;
 
-        let (i, _) = tag("<-")(i)?;
+        let (i, _) = tag("<-").parse(i)?;
 
-        let (i, (body, expressions, scopes)) = cut(rule_body)(i)?;
+        let (i, (body, expressions, scopes)) = cut(rule_body).parse(i)?;
 
         Ok((i, (head, body, expressions, scopes)))
-    })(i)?;
+    })
+    .parse(i)?;
 
     let rule = builder::Rule::new(head, body, expressions, scopes);
 
@@ -215,7 +218,8 @@ fn predicate(i: &str) -> IResult<&str, builder::Predicate, Error> {
         char('('),
         cut(separated_list1(preceded(space0, char(',')), cut(term))),
         preceded(space0, char(')')),
-    )(i)?;
+    )
+    .parse(i)?;
 
     Ok((
         i,
@@ -235,7 +239,8 @@ fn rule_head(i: &str) -> IResult<&str, builder::Predicate, Error> {
         char('('),
         cut(separated_list0(preceded(space0, char(',')), cut(term))),
         preceded(space0, char(')')),
-    )(i)?;
+    )
+    .parse(i)?;
 
     Ok((
         i,
@@ -261,7 +266,8 @@ pub fn rule_body(
     let (i, mut elements) = separated_list1(
         preceded(space0, char(',')),
         preceded(space0, cut(predicate_or_expression)),
-    )(i)?;
+    )
+    .parse(i)?;
 
     let mut predicates = Vec::new();
     let mut expressions = Vec::new();
@@ -291,12 +297,13 @@ fn predicate_or_expression(i: &str) -> IResult<&str, PredOrExpr, Error> {
     reduce(
         alt((map(predicate, PredOrExpr::P), map(expr, PredOrExpr::E))),
         ",;",
-    )(i)
+    )
+    .parse(i)
 }
 
 fn scopes(i: &str) -> IResult<&str, Vec<builder::Scope>, Error> {
-    if let Ok((i, _)) = preceded(space0, tag::<_, _, ()>("trusting"))(i) {
-        separated_list1(preceded(space0, char(',')), preceded(space0, cut(scope)))(i)
+    if let Ok((i, _)) = preceded(space0, tag::<_, _, ()>("trusting")).parse(i) {
+        separated_list1(preceded(space0, char(',')), preceded(space0, cut(scope))).parse(i)
     } else {
         Ok((i, vec![]))
     }
@@ -310,7 +317,8 @@ fn scope(i: &str) -> IResult<&str, builder::Scope, Error> {
         map(delimited(char('{'), name, char('}')), |n| {
             builder::Scope::Parameter(n.to_string())
         }),
-    ))(i)
+    ))
+    .parse(i)
 }
 
 pub fn public_key(i: &str) -> IResult<&str, builder::PublicKey, Error> {
@@ -323,7 +331,8 @@ pub fn public_key(i: &str) -> IResult<&str, builder::PublicKey, Error> {
             key,
             algorithm: builder::Algorithm::Secp256r1,
         }),
-    ))(i)
+    ))
+    .parse(i)
 }
 
 #[derive(Debug, PartialEq)]
@@ -364,7 +373,7 @@ impl Expr {
 
 fn unary_negate(i: &str) -> IResult<&str, Expr, Error> {
     let (i, _) = space0(i)?;
-    let (i, _) = tag("!")(i)?;
+    let (i, _) = tag("!").parse(i)?;
     let (i, _) = space0(i)?;
     let (i, value) = expr6(i)?;
 
@@ -376,11 +385,11 @@ fn unary_negate(i: &str) -> IResult<&str, Expr, Error> {
 
 fn unary_parens(i: &str) -> IResult<&str, Expr, Error> {
     let (i, _) = space0(i)?;
-    let (i, _) = tag("(")(i)?;
+    let (i, _) = tag("(").parse(i)?;
     let (i, _) = space0(i)?;
     let (i, value) = expr(i)?;
     let (i, _) = space0(i)?;
-    let (i, _) = tag(")")(i)?;
+    let (i, _) = tag(")").parse(i)?;
 
     Ok((
         i,
@@ -390,12 +399,12 @@ fn unary_parens(i: &str) -> IResult<&str, Expr, Error> {
 
 fn binary_op_0(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    value(Binary::LazyOr, tag("||"))(i)
+    value(Binary::LazyOr, tag("||")).parse(i)
 }
 
 fn binary_op_1(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    value(Binary::LazyAnd, tag("&&"))(i)
+    value(Binary::LazyAnd, tag("&&")).parse(i)
 }
 
 fn binary_op_2(i: &str) -> IResult<&str, builder::Binary, Error> {
@@ -409,41 +418,42 @@ fn binary_op_2(i: &str) -> IResult<&str, builder::Binary, Error> {
         value(Binary::NotEqual, tag("!==")),
         value(Binary::HeterogeneousEqual, tag("==")),
         value(Binary::HeterogeneousNotEqual, tag("!=")),
-    ))(i)
+    ))
+    .parse(i)
 }
 
 fn binary_op_3(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    value(Binary::BitwiseXor, tag("^"))(i)
+    value(Binary::BitwiseXor, tag("^")).parse(i)
 }
 
 fn binary_op_4(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    value(Binary::BitwiseOr, tag("|"))(i)
+    value(Binary::BitwiseOr, tag("|")).parse(i)
 }
 
 fn binary_op_5(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    value(Binary::BitwiseAnd, tag("&"))(i)
+    value(Binary::BitwiseAnd, tag("&")).parse(i)
 }
 
 fn binary_op_6(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    alt((value(Binary::Add, tag("+")), value(Binary::Sub, tag("-"))))(i)
+    alt((value(Binary::Add, tag("+")), value(Binary::Sub, tag("-")))).parse(i)
 }
 
 fn binary_op_7(i: &str) -> IResult<&str, builder::Binary, Error> {
     use builder::Binary;
-    alt((value(Binary::Mul, tag("*")), value(Binary::Div, tag("/"))))(i)
+    alt((value(Binary::Mul, tag("*")), value(Binary::Div, tag("/")))).parse(i)
 }
 
 fn extern_un(i: &str) -> IResult<&str, builder::Unary, Error> {
-    let (i, func) = preceded(tag("extern::"), name)(i)?;
+    let (i, func) = preceded(tag("extern::"), name).parse(i)?;
     Ok((i, builder::Unary::Ffi(func.to_string())))
 }
 
 fn extern_bin(i: &str) -> IResult<&str, builder::Binary, Error> {
-    let (i, func) = preceded(tag("extern::"), name)(i)?;
+    let (i, func) = preceded(tag("extern::"), name).parse(i)?;
     Ok((i, builder::Binary::Ffi(func.to_string())))
 }
 
@@ -462,13 +472,14 @@ fn binary_op_8(i: &str) -> IResult<&str, builder::Binary, Error> {
         value(Binary::Get, tag("get")),
         value(Binary::TryOr, tag("try_or")),
         extern_bin,
-    ))(i)
+    ))
+    .parse(i)
 }
 
 /// Innermost parser for an expression: either a parenthesised expression,
 /// or a single term.
 fn expr_term(i: &str) -> IResult<&str, Expr, Error> {
-    alt((unary_parens, reduce(map(term, Expr::Value), " ,\n);")))(i)
+    alt((unary_parens, reduce(map(term, Expr::Value), " ,\n);"))).parse(i)
 }
 
 fn fold_exprs(initial: Expr, remainder: Vec<(builder::Binary, Expr)>) -> Expr {
@@ -501,7 +512,7 @@ fn fold_exprs(initial: Expr, remainder: Vec<(builder::Binary, Expr)>) -> Expr {
 pub fn expr(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr1(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_0), expr1)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_0), expr1)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
@@ -512,7 +523,7 @@ pub fn expr(i: &str) -> IResult<&str, Expr, Error> {
 fn expr1(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr2(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_1), expr2)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_1), expr2)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
@@ -523,7 +534,7 @@ fn expr1(i: &str) -> IResult<&str, Expr, Error> {
 fn expr2(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr3(i)?;
 
-    if let Ok((i, (op, remainder))) = tuple((preceded(space0, binary_op_2), expr3))(i) {
+    if let Ok((i, (op, remainder))) = (preceded(space0, binary_op_2), expr3).parse(i) {
         Ok((
             i,
             Expr::Binary(
@@ -543,7 +554,7 @@ fn expr2(i: &str) -> IResult<&str, Expr, Error> {
 fn expr3(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr4(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_3), expr4)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_3), expr4)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
@@ -554,7 +565,7 @@ fn expr3(i: &str) -> IResult<&str, Expr, Error> {
 fn expr4(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr5(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_4), expr5)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_4), expr5)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
@@ -565,7 +576,7 @@ fn expr4(i: &str) -> IResult<&str, Expr, Error> {
 fn expr5(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr6(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_5), expr6)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_5), expr6)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
@@ -576,7 +587,7 @@ fn expr5(i: &str) -> IResult<&str, Expr, Error> {
 fn expr6(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr7(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_6), expr7)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_6), expr7)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
@@ -587,14 +598,14 @@ fn expr6(i: &str) -> IResult<&str, Expr, Error> {
 fn expr7(i: &str) -> IResult<&str, Expr, Error> {
     let (i, initial) = expr8(i)?;
 
-    let (i, remainder) = many0(tuple((preceded(space0, binary_op_7), expr8)))(i)?;
+    let (i, remainder) = many0((preceded(space0, binary_op_7), expr8)).parse(i)?;
 
     Ok((i, fold_exprs(initial, remainder)))
 }
 
 /// This level handles `!` (prefix negation)
 fn expr8(i: &str) -> IResult<&str, Expr, Error> {
-    alt((unary_negate, expr9))(i)
+    alt((unary_negate, expr9)).parse(i)
 }
 
 /// This level handles methods. Methods can take either zero or one
@@ -650,24 +661,24 @@ fn expr9(i: &str) -> IResult<&str, Expr, Error> {
 fn binary_method(i: &str) -> IResult<&str, (builder::Binary, Option<Vec<String>>, Expr), Error> {
     let (i, op) = binary_op_8(i)?;
 
-    let (i, _) = char('(')(i)?;
+    let (i, _) = char('(').parse(i)?;
     let (i, _) = space0(i)?;
     // we only support a single argument for now
     match op {
         builder::Binary::All | builder::Binary::Any => {
-            let (i, param) = preceded(char('$'), name)(i)?;
+            let (i, param) = preceded(char('$'), name).parse(i)?;
             let (i, _) = space0(i)?;
-            let (i, _) = tag("->")(i)?;
+            let (i, _) = tag("->").parse(i)?;
             let (i, _) = space0(i)?;
             let (i, arg) = expr(i)?;
             let (i, _) = space0(i)?;
-            let (i, _) = char(')')(i)?;
+            let (i, _) = char(')').parse(i)?;
             Ok((i, (op, Some(vec![param.to_owned()]), arg)))
         }
         _ => {
             let (i, arg) = expr(i)?;
             let (i, _) = space0(i)?;
-            let (i, _) = char(')')(i)?;
+            let (i, _) = char(')').parse(i)?;
 
             Ok((i, (op, None, arg)))
         }
@@ -680,38 +691,39 @@ fn unary_method(i: &str) -> IResult<&str, builder::Unary, Error> {
         value(Unary::Length, tag("length")),
         value(Unary::TypeOf, tag("type")),
         extern_un,
-    ))(i)?;
+    ))
+    .parse(i)?;
 
-    let (i, _) = char('(')(i)?;
+    let (i, _) = char('(').parse(i)?;
     let (i, _) = space0(i)?;
-    let (i, _) = char(')')(i)?;
+    let (i, _) = char(')').parse(i)?;
 
     Ok((i, op))
 }
 
 fn name(i: &str) -> IResult<&str, &str, Error> {
-    let is_name_char = |c: char| is_alphanumeric(c as u8) || c == '_' || c == ':';
+    let is_name_char = |c: char| c.is_alphanum() || c == '_' || c == ':';
 
-    reduce(take_while1(is_name_char), " ,:(\n;")(i)
+    reduce(take_while1(is_name_char), " ,:(\n;").parse(i)
 }
 
 fn parameter_name(i: &str) -> IResult<&str, &str, Error> {
-    let is_name_char = |c: char| is_alphanumeric(c as u8) || c == '_' || c == ':';
+    let is_name_char = |c: char| c.is_alphanum() || c == '_' || c == ':';
 
     error(
         recognize(preceded(
-            satisfy(|c: char| is_alphabetic(c as u8)),
+            satisfy(|c: char| c.is_alpha()),
             take_while(is_name_char),
         )),
         |_| {
             "invalid parameter name: it must start with an alphabetic character, followed by alphanumeric characters, underscores or colons".to_string()
         },
         " ,:(\n;",
-    )(i)
+    ).parse(i)
 }
 
 fn printable(i: &str) -> IResult<&str, &str, Error> {
-    take_while1(|c: char| c != '\\' && c != '"')(i)
+    take_while1(|c: char| c != '\\' && c != '"').parse(i)
 }
 
 fn parse_string_internal(i: &str) -> IResult<&str, String, Error> {
@@ -723,14 +735,16 @@ fn parse_string_internal(i: &str) -> IResult<&str, String, Error> {
             map(char('"'), |_| "\""),
             map(char('n'), |_| "\n"),
         )),
-    )(i)
+    )
+    .parse(i)
 }
 
 fn parse_string(i: &str) -> IResult<&str, String, Error> {
     alt((
         value("".to_string(), tag("\"\"")),
         delimited(char('"'), parse_string_internal, char('"')),
-    ))(i)
+    ))
+    .parse(i)
 }
 
 fn string(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -738,7 +752,7 @@ fn string(i: &str) -> IResult<&str, builder::Term, Error> {
 }
 
 fn parse_integer(i: &str) -> IResult<&str, i64, Error> {
-    map_res(recognize(pair(opt(char('-')), digit1)), |s: &str| s.parse())(i)
+    map_res(recognize(pair(opt(char('-')), digit1)), |s: &str| s.parse()).parse(i)
 }
 
 fn integer(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -754,7 +768,8 @@ fn parse_date(i: &str) -> IResult<&str, u64, Error> {
             |s| time::OffsetDateTime::parse(s, &time::format_description::well_known::Rfc3339),
         ),
         |t| t.unix_timestamp().try_into(),
-    )(i)
+    )
+    .parse(i)
 }
 
 fn date(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -762,7 +777,7 @@ fn date(i: &str) -> IResult<&str, builder::Term, Error> {
 }
 
 fn parse_bytes(i: &str) -> IResult<&str, Vec<u8>, Error> {
-    preceded(tag("hex:"), parse_hex)(i)
+    preceded(tag("hex:"), parse_hex).parse(i)
 }
 
 fn parse_hex(i: &str) -> IResult<&str, Vec<u8>, Error> {
@@ -772,7 +787,8 @@ fn parse_hex(i: &str) -> IResult<&str, Vec<u8>, Error> {
             c.is_ascii_digit() || (b'a'..=b'f').contains(&c) || (b'A'..=b'F').contains(&c)
         }),
         hex::decode,
-    )(i)
+    )
+    .parse(i)
 }
 
 fn bytes(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -780,18 +796,19 @@ fn bytes(i: &str) -> IResult<&str, builder::Term, Error> {
 }
 
 fn variable(i: &str) -> IResult<&str, builder::Term, Error> {
-    map(preceded(char('$'), name), builder::variable)(i)
+    map(preceded(char('$'), name), builder::variable).parse(i)
 }
 
 fn parameter(i: &str) -> IResult<&str, builder::Term, Error> {
     map(
         delimited(char('{'), parameter_name, char('}')),
         builder::parameter,
-    )(i)
+    )
+    .parse(i)
 }
 
 fn parse_bool(i: &str) -> IResult<&str, bool, Error> {
-    alt((value(true, tag("true")), value(false, tag("false"))))(i)
+    alt((value(true, tag("true")), value(false, tag("false")))).parse(i)
 }
 
 fn boolean(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -799,20 +816,22 @@ fn boolean(i: &str) -> IResult<&str, builder::Term, Error> {
 }
 
 fn null(i: &str) -> IResult<&str, builder::Term, Error> {
-    tag("null")(i).map(|(i, _)| (i, builder::null()))
+    tag("null").parse(i).map(|(i, _)| (i, builder::null()))
 }
 
 fn set(i: &str) -> IResult<&str, builder::Term, Error> {
-    alt((empty_set, non_empty_set))(i)
+    alt((empty_set, non_empty_set)).parse(i)
 }
 
 fn empty_set(i: &str) -> IResult<&str, builder::Term, Error> {
-    tag("{,}")(i).map(|(i, _)| (i, builder::set(BTreeSet::new())))
+    tag("{,}")
+        .parse(i)
+        .map(|(i, _)| (i, builder::set(BTreeSet::new())))
 }
 
 fn non_empty_set(i: &str) -> IResult<&str, builder::Term, Error> {
-    let (i, _) = preceded(space0, char('{'))(i)?;
-    let (i, mut list) = cut(separated_list1(preceded(space0, char(',')), term_in_set))(i)?;
+    let (i, _) = preceded(space0, char('{')).parse(i)?;
+    let (i, mut list) = cut(separated_list1(preceded(space0, char(',')), term_in_set)).parse(i)?;
 
     let mut set = BTreeSet::new();
 
@@ -859,25 +878,26 @@ fn non_empty_set(i: &str) -> IResult<&str, builder::Term, Error> {
         set.insert(term);
     }
 
-    let (i, _) = preceded(space0, char('}'))(i)?;
+    let (i, _) = preceded(space0, char('}')).parse(i)?;
 
     Ok((i, builder::set(set)))
 }
 
 fn array(i: &str) -> IResult<&str, builder::Term, Error> {
-    let (i, _) = preceded(space0, char('['))(i)?;
-    let (i, array) = cut(separated_list0(preceded(space0, char(',')), term_in_fact))(i)?;
-    let (i, _) = preceded(space0, char(']'))(i)?;
+    let (i, _) = preceded(space0, char('[')).parse(i)?;
+    let (i, array) = cut(separated_list0(preceded(space0, char(',')), term_in_fact)).parse(i)?;
+    let (i, _) = preceded(space0, char(']')).parse(i)?;
 
     Ok((i, builder::array(array)))
 }
 
 fn parse_map(i: &str) -> IResult<&str, builder::Term, Error> {
-    let (i, _) = preceded(space0, char('{'))(i)?;
+    let (i, _) = preceded(space0, char('{')).parse(i)?;
     let (i, mut list) = cut(separated_list0(
         preceded(space0, char(',')),
         separated_pair(map_key, preceded(space0, char(':')), term_in_fact),
-    ))(i)?;
+    ))
+    .parse(i)?;
 
     let mut map = BTreeMap::new();
 
@@ -885,7 +905,7 @@ fn parse_map(i: &str) -> IResult<&str, builder::Term, Error> {
         map.insert(key, term);
     }
 
-    let (i, _) = preceded(space0, char('}'))(i)?;
+    let (i, _) = preceded(space0, char('}')).parse(i)?;
 
     Ok((i, builder::map(map)))
 }
@@ -900,7 +920,8 @@ fn map_key(i: &str) -> IResult<&str, builder::MapKey, Error> {
             map(parse_string, |s| builder::MapKey::Str(s.to_string())),
             map(parse_integer, builder::MapKey::Integer),
         )),
-    )(i)
+    )
+    .parse(i)
 }
 
 fn term(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -909,7 +930,8 @@ fn term(i: &str) -> IResult<&str, builder::Term, Error> {
         alt((
             parameter, string, date, variable, integer, bytes, boolean, null, array, parse_map, set,
         )),
-    )(i)
+    )
+    .parse(i)
 }
 
 fn term_in_fact(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -926,7 +948,8 @@ fn term_in_fact(i: &str) -> IResult<&str, builder::Term, Error> {
             },
             " ,)\n;",
         ),
-    )(i)
+    )
+    .parse(i)
 }
 
 fn term_in_set(i: &str) -> IResult<&str, builder::Term, Error> {
@@ -943,23 +966,24 @@ fn term_in_set(i: &str) -> IResult<&str, builder::Term, Error> {
             },
             " ,}\n;",
         ),
-    )(i)
+    )
+    .parse(i)
 }
 
 fn line_comment(i: &str) -> IResult<&str, (), Error> {
     let (i, _) = space0(i)?;
-    let (i, _) = tag("//")(i)?;
-    let (i, _) = take_while(|c| c != '\r' && c != '\n')(i)?;
-    let (i, _) = alt((tag("\n"), tag("\r\n"), eof))(i)?;
+    let (i, _) = tag("//").parse(i)?;
+    let (i, _) = take_while(|c| c != '\r' && c != '\n').parse(i)?;
+    let (i, _) = alt((tag("\n"), tag("\r\n"), eof)).parse(i)?;
 
     Ok((i, ()))
 }
 
 fn multiline_comment(i: &str) -> IResult<&str, (), Error> {
     let (i, _) = space0(i)?;
-    let (i, _) = tag("/*")(i)?;
-    let (i, _) = take_until("*/")(i)?;
-    let (i, _) = tag("*/")(i)?;
+    let (i, _) = tag("/*").parse(i)?;
+    let (i, _) = take_until("*/").parse(i)?;
+    let (i, _) = tag("*/").parse(i)?;
 
     Ok((i, ()))
 }
@@ -983,7 +1007,7 @@ enum SourceElement<'a> {
 
 pub fn sep(i: &str) -> IResult<&str, &str, Error> {
     let (i, _) = space0(i)?;
-    alt((tag(";"), eof))(i)
+    alt((tag(";"), eof)).parse(i)
 }
 
 pub fn parse_source(mut i: &str) -> Result<SourceResult, Vec<Error>> {
@@ -1017,7 +1041,8 @@ pub fn parse_source(mut i: &str) -> Result<SourceResult, Vec<Error>> {
                 map(multiline_comment, |_| SourceElement::Comment),
             )),
             space0,
-        )(i)
+        )
+        .parse(i)
         {
             Ok((i2, o)) => {
                 match o {
@@ -1067,7 +1092,7 @@ pub fn parse_block_source(mut i: &str) -> Result<SourceResult, Vec<Error>> {
     let mut result = SourceResult::default();
     let mut errors = Vec::new();
 
-    match opt(terminated(consumed(scopes), sep))(i) {
+    match opt(terminated(consumed(scopes), sep)).parse(i) {
         Ok((i2, opt_scopes)) => {
             if let Some((_, scopes)) = opt_scopes {
                 i = i2;
@@ -1129,7 +1154,8 @@ pub fn parse_block_source(mut i: &str) -> Result<SourceResult, Vec<Error>> {
                 map(multiline_comment, |_| SourceElement::Comment),
             )),
             space0,
-        )(i)
+        )
+        .parse(i)
         {
             Ok((i2, o)) => {
                 match o {
@@ -1214,7 +1240,7 @@ fn error<'a, F, O, P>(
     reducer: &'static str,
 ) -> impl FnMut(&'a str) -> IResult<&'a str, O, Error<'a>>
 where
-    P: nom::Parser<&'a str, O, Error<'a>>,
+    P: nom::Parser<&'a str, Output = O, Error = Error<'a>>,
     F: Fn(&'a str) -> String,
 {
     move |i: &str| match parser.parse(i) {
@@ -1250,7 +1276,7 @@ fn reduce<'a, O, P>(
     reducer: &'static str,
 ) -> impl FnMut(&'a str) -> IResult<&'a str, O, Error<'a>>
 where
-    P: nom::Parser<&'a str, O, Error<'a>>,
+    P: nom::Parser<&'a str, Output = O, Error = Error<'a>>,
 {
     move |i: &str| match parser.parse(i) {
         Ok(res) => Ok(res),
diff --git a/biscuit-quote/Cargo.toml b/biscuit-quote/Cargo.toml
index 3da15970..f838c5dd 100644
--- a/biscuit-quote/Cargo.toml
+++ b/biscuit-quote/Cargo.toml
@@ -13,7 +13,7 @@ proc-macro = true
 biscuit-parser = { path = "../biscuit-parser", features = ["datalog-macro"], version = "0.2.0" }
 proc-macro2 = "1"
 quote = "1.0.14"
-syn = { version = "1.0.85", features = ["full", "extra-traits"] }
+syn = { version = "2.0.117", default-features = false }
 proc-macro-error2 = "2.0"
 
 [dev-dependencies]