diff --git a/Cargo.lock b/Cargo.lock
index f7fbf1b79..ea123fa64 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3864,9 +3864,9 @@ dependencies = [
 
 [[package]]
 name = "minijinja"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9ca8daf4b0b4029777f1bc6e1aedd1aec7b74c276a43bc6f620a8e1a1c0a90e"
+checksum = "2c37e1b517d1dcd0e51dc36c4567b9d5a29262b3ec8da6cb5d35e27a8fb529b5"
 dependencies = [
  "memo-map",
  "self_cell",
diff --git a/Cargo.toml b/Cargo.toml
index 24717ace8..ccc1ae5b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -176,7 +176,7 @@ features = [
 
 # Templates
 [workspace.dependencies.minijinja]
-version = "2.4.0"
+version = "2.5.0"
 features = ["loader", "json", "speedups", "unstable_machinery"]
 
 # Additional filters for minijinja
diff --git a/crates/i18n-scan/src/minijinja.rs b/crates/i18n-scan/src/minijinja.rs
index 1a305dce7..f56506970 100644
--- a/crates/i18n-scan/src/minijinja.rs
+++ b/crates/i18n-scan/src/minijinja.rs
@@ -6,7 +6,7 @@
 
 pub use minijinja::machinery::parse;
 use minijinja::{
-    machinery::ast::{Call, Const, Expr, Macro, Spanned, Stmt},
+    machinery::ast::{Call, CallArg, Const, Expr, Macro, Spanned, Stmt},
     ErrorKind,
 };
 
@@ -90,9 +90,9 @@ pub fn find_in_stmt<'a>(context: &mut Context, stmt: &'a Stmt<'a>) -> Result<(),
     Ok(())
 }
 
-fn as_const<'a>(expr: &'a Expr<'a>) -> Option<&'a Const> {
-    match expr {
-        Expr::Const(const_) => Some(const_),
+fn as_const<'a>(call_arg: &'a CallArg<'a>) -> Option<&'a Const> {
+    match call_arg {
+        CallArg::Pos(Expr::Const(const_)) => Some(const_),
         _ => None,
     }
 }
@@ -122,13 +122,10 @@ fn find_in_call<'a>(
                     "t() first argument must be a string literal",
                 ))?;
 
-            let has_count = call.args.iter().any(|arg| {
-                if let Expr::Kwargs(kwargs) = arg {
-                    kwargs.pairs.iter().any(|(key, _value)| *key == "count")
-                } else {
-                    false
-                }
-            });
+            let has_count = call
+                .args
+                .iter()
+                .any(|arg| matches!(arg, CallArg::Kwarg("count", _)));
 
             let key = Key::new(
                 if has_count {
@@ -146,13 +143,34 @@ fn find_in_call<'a>(
     }
 
     find_in_expr(context, &call.expr)?;
-    for arg in &call.args {
-        find_in_expr(context, arg)?;
+    find_in_call_args(context, &call.args)?;
+
+    Ok(())
+}
+
+fn find_in_call_args<'a>(
+    context: &mut Context,
+    args: &'a [CallArg<'a>],
+) -> Result<(), minijinja::Error> {
+    for arg in args {
+        find_in_call_arg(context, arg)?;
     }
 
     Ok(())
 }
 
+fn find_in_call_arg<'a>(
+    context: &mut Context,
+    arg: &'a CallArg<'a>,
+) -> Result<(), minijinja::Error> {
+    match arg {
+        CallArg::Pos(expr)
+        | CallArg::Kwarg(_, expr)
+        | CallArg::PosSplat(expr)
+        | CallArg::KwargSplat(expr) => find_in_expr(context, expr),
+    }
+}
+
 fn find_in_stmts<'a>(context: &mut Context, stmts: &'a [Stmt<'a>]) -> Result<(), minijinja::Error> {
     for stmt in stmts {
         find_in_stmt(context, stmt)?;
@@ -185,11 +203,11 @@ fn find_in_expr<'a>(context: &mut Context, expr: &'a Expr<'a>) -> Result<(), min
         }
         Expr::Filter(filter) => {
             find_in_optional_expr(context, &filter.expr)?;
-            find_in_exprs(context, &filter.args)?;
+            find_in_call_args(context, &filter.args)?;
         }
         Expr::Test(test) => {
             find_in_expr(context, &test.expr)?;
-            find_in_exprs(context, &test.args)?;
+            find_in_call_args(context, &test.args)?;
         }
         Expr::GetAttr(get_attr) => {
             find_in_expr(context, &get_attr.expr)?;
@@ -208,11 +226,6 @@ fn find_in_expr<'a>(context: &mut Context, expr: &'a Expr<'a>) -> Result<(), min
             find_in_exprs(context, &map.keys)?;
             find_in_exprs(context, &map.values)?;
         }
-        Expr::Kwargs(kwargs) => {
-            for (_key, value) in &kwargs.pairs {
-                find_in_expr(context, value)?;
-            }
-        }
     }
 
     Ok(())