diff --git a/dprint_plugin/src/lib.rs b/dprint_plugin/src/lib.rs
index 605e319..13edef7 100644
--- a/dprint_plugin/src/lib.rs
+++ b/dprint_plugin/src/lib.rs
@@ -8,7 +8,7 @@ use dprint_core::{
 };
 use markup_fmt::{
     config::{FormatOptions, Quotes},
-    detect_language, format_text, FormatError,
+    detect_language, format_text, FormatError, Hints,
 };
 use std::path::Path;
 
@@ -83,8 +83,8 @@ impl SyncPluginHandler<FormatOptions> for MarkupFmtPluginHandler {
             std::str::from_utf8(&file_text)?,
             language,
             config,
-            |path, code, print_width| {
-                let additional_config = build_additional_config(path, print_width, config);
+            |path, code, hints| {
+                let additional_config = build_additional_config(hints, config);
                 format_with_host(path, code.into(), &additional_config).and_then(|result| {
                     match result {
                         Some(code) => String::from_utf8(code)
@@ -116,39 +116,25 @@ impl SyncPluginHandler<FormatOptions> for MarkupFmtPluginHandler {
 generate_plugin_code!(MarkupFmtPluginHandler, MarkupFmtPluginHandler);
 
 #[doc(hidden)]
-pub fn build_additional_config(
-    path: &Path,
-    print_width: usize,
-    config: &FormatOptions,
-) -> ConfigKeyMap {
+pub fn build_additional_config(hints: Hints, config: &FormatOptions) -> ConfigKeyMap {
     let mut additional_config = ConfigKeyMap::new();
-    additional_config.insert("lineWidth".into(), (print_width as i32).into());
-    additional_config.insert("printWidth".into(), (print_width as i32).into());
+    additional_config.insert("lineWidth".into(), (hints.print_width as i32).into());
+    additional_config.insert("printWidth".into(), (hints.print_width as i32).into());
 
-    let file_name = path.file_name().and_then(|s| s.to_str());
-    match &file_name {
-        Some("expr.ts" | "binding.ts" | "type_params.ts") => {
-            // dprint-plugin-typescript
-            additional_config.insert("semiColons".into(), "asi".into());
-            // Biome
-            additional_config.insert("semicolons".into(), "asNeeded".into());
-        }
-        Some("attr_expr.tsx") => {
-            // Only for dprint-plugin-typescript currently,
-            // because it conflicts with the `quoteStyle` option in Biome.
-            match config.language.quotes {
-                Quotes::Double => {
-                    additional_config.insert("quoteStyle".into(), "alwaysSingle".into());
-                }
-                Quotes::Single => {
-                    additional_config.insert("quoteStyle".into(), "alwaysDouble".into());
-                }
+    if hints.attr {
+        // Only for dprint-plugin-typescript currently,
+        // because it conflicts with the `quoteStyle` option in Biome.
+        match config.language.quotes {
+            Quotes::Double => {
+                additional_config.insert("quoteStyle".into(), "alwaysSingle".into());
+            }
+            Quotes::Single => {
+                additional_config.insert("quoteStyle".into(), "alwaysDouble".into());
             }
         }
-        Some("style_attr.css") => {
-            additional_config.insert("singleLineTopLevelDeclarations".into(), true.into());
-        }
-        _ => {}
+    }
+    if hints.ext == "css" {
+        additional_config.insert("singleLineTopLevelDeclarations".into(), true.into());
     }
 
     additional_config
diff --git a/dprint_plugin/tests/integration.rs b/dprint_plugin/tests/integration.rs
index b2d9c63..d63cec7 100644
--- a/dprint_plugin/tests/integration.rs
+++ b/dprint_plugin/tests/integration.rs
@@ -15,9 +15,9 @@ fn integration_with_dprint_ts_snapshot() {
                 &input,
                 detect_language(path).unwrap(),
                 &options,
-                |path, code, print_width| -> anyhow::Result<Cow<str>> {
+                |path, code, hints| -> anyhow::Result<Cow<str>> {
                     let additional_config =
-                        dprint_plugin_markup::build_additional_config(path, print_width, &options);
+                        dprint_plugin_markup::build_additional_config(hints, &options);
                     if let Some(syntax) = malva::detect_syntax(path) {
                         malva::format_text(
                             code,
@@ -100,9 +100,9 @@ fn integration_with_biome_snapshot() {
                 &input,
                 detect_language(path).unwrap(),
                 &options,
-                |path, code, print_width| -> anyhow::Result<Cow<str>> {
+                |path, code, hints| -> anyhow::Result<Cow<str>> {
                     let additional_config =
-                        dprint_plugin_markup::build_additional_config(path, print_width, &options);
+                        dprint_plugin_markup::build_additional_config(hints, &options);
                     if let Some(syntax) = malva::detect_syntax(path) {
                         malva::format_text(
                             code,
diff --git a/markup_fmt/src/ctx.rs b/markup_fmt/src/ctx.rs
index 3a7c3e1..ef0ded3 100644
--- a/markup_fmt/src/ctx.rs
+++ b/markup_fmt/src/ctx.rs
@@ -15,7 +15,7 @@ const QUOTES: [&str; 3] = ["\"", "\"", "'"];
 
 pub(crate) struct Ctx<'b, E, F>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints<'b>) -> Result<Cow<'a, str>, E>,
 {
     pub(crate) source: &'b str,
     pub(crate) language: Language,
@@ -29,7 +29,7 @@ where
 
 impl<'b, E, F> Ctx<'b, E, F>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints<'b>) -> Result<Cow<'a, str>, E>,
 {
     pub(crate) fn script_indent(&self) -> bool {
         match self.language {
@@ -97,12 +97,12 @@ where
     }
 
     pub(crate) fn format_general_expr(&mut self, code: &str, start: usize) -> String {
-        self.format_expr(code, Path::new("expr.tsx"), start)
+        self.format_expr(code, Path::new("expr.tsx"), false, start)
     }
 
     pub(crate) fn format_attr_expr(&mut self, code: &str, start: usize) -> String {
         let code = UNESCAPING_AC.replace_all(code, &QUOTES);
-        let formatted = self.format_expr(&code, Path::new("attr_expr.tsx"), start);
+        let formatted = self.format_expr(&code, Path::new("attr_expr.tsx"), true, start);
         if memchr(b'\'', formatted.as_bytes()).is_some()
             && memchr(b'"', formatted.as_bytes()).is_some()
         {
@@ -115,7 +115,7 @@ where
         }
     }
 
-    fn format_expr(&mut self, code: &str, path: &Path, start: usize) -> String {
+    fn format_expr(&mut self, code: &str, path: &Path, attr: bool, start: usize) -> String {
         if code.trim().is_empty() {
             String::new()
         } else {
@@ -134,9 +134,14 @@ where
                 path,
                 wrapped,
                 code,
-                self.print_width
-                    .saturating_sub(self.indent_level)
-                    .saturating_sub(2), // this is technically wrong, just workaround
+                Hints {
+                    print_width: self
+                        .print_width
+                        .saturating_sub(self.indent_level)
+                        .saturating_sub(2), // this is technically wrong, just workaround
+                    attr,
+                    ext: "tsx",
+                },
             );
             let formatted = formatted.trim_matches(|c: char| c.is_ascii_whitespace() || c == ';');
             let formatted = formatted
@@ -170,9 +175,14 @@ where
                 Path::new("binding.ts"),
                 wrapped,
                 code,
-                self.print_width
-                    .saturating_sub(self.indent_level)
-                    .saturating_sub(2), // this is technically wrong, just workaround
+                Hints {
+                    print_width: self
+                        .print_width
+                        .saturating_sub(self.indent_level)
+                        .saturating_sub(2), // this is technically wrong, just workaround
+                    attr: false,
+                    ext: "ts",
+                },
             );
             let formatted = formatted.trim_matches(|c: char| c.is_ascii_whitespace() || c == ';');
             formatted
@@ -199,9 +209,14 @@ where
                 Path::new("type_params.ts"),
                 wrapped,
                 code,
-                self.print_width
-                    .saturating_sub(self.indent_level)
-                    .saturating_sub(TYPE_PARAMS_INDENT), // this is technically wrong, just workaround
+                Hints {
+                    print_width: self
+                        .print_width
+                        .saturating_sub(self.indent_level)
+                        .saturating_sub(TYPE_PARAMS_INDENT), // this is technically wrong, just workaround
+                    attr: true,
+                    ext: "ts",
+                },
             );
             let formatted = formatted.trim_matches(|c: char| c.is_ascii_whitespace() || c == ';');
             formatted
@@ -221,9 +236,14 @@ where
                 Path::new("stmt_header.js"),
                 wrapped,
                 code,
-                self.print_width
-                    .saturating_sub(self.indent_level)
-                    .saturating_sub(keyword.len() + 1), // this is technically wrong, just workaround
+                Hints {
+                    print_width: self
+                        .print_width
+                        .saturating_sub(self.indent_level)
+                        .saturating_sub(keyword.len() + 1), // this is technically wrong, just workaround
+                    attr: false,
+                    ext: "js",
+                },
             );
             formatted
                 .strip_prefix(keyword)
@@ -240,7 +260,7 @@ where
     pub(crate) fn format_script<'a>(
         &mut self,
         code: &'a str,
-        lang: &str,
+        lang: &'b str,
         start: usize,
     ) -> Cow<'a, str> {
         self.format_with_external_formatter(
@@ -251,20 +271,25 @@ where
                 .replace(|c: char| !c.is_ascii_whitespace(), " ")
                 + code,
             code,
-            self.print_width
-                .saturating_sub(self.indent_level)
-                .saturating_sub(if self.script_indent() {
-                    self.indent_width
-                } else {
-                    0
-                }),
+            Hints {
+                print_width: self
+                    .print_width
+                    .saturating_sub(self.indent_level)
+                    .saturating_sub(if self.script_indent() {
+                        self.indent_width
+                    } else {
+                        0
+                    }),
+                attr: false,
+                ext: lang,
+            },
         )
     }
 
     pub(crate) fn format_style<'a>(
         &mut self,
         code: &'a str,
-        lang: &str,
+        lang: &'b str,
         start: usize,
     ) -> Cow<'a, str> {
         self.format_with_external_formatter(
@@ -275,13 +300,18 @@ where
                 .replace(|c: char| !c.is_ascii_whitespace(), " ")
                 + code,
             code,
-            self.print_width
-                .saturating_sub(self.indent_level)
-                .saturating_sub(if self.style_indent() {
-                    self.indent_width
-                } else {
-                    0
-                }),
+            Hints {
+                print_width: self
+                    .print_width
+                    .saturating_sub(self.indent_level)
+                    .saturating_sub(if self.style_indent() {
+                        self.indent_width
+                    } else {
+                        0
+                    }),
+                attr: false,
+                ext: lang,
+            },
         )
     }
 
@@ -294,13 +324,18 @@ where
                 .replace(|c: char| !c.is_ascii_whitespace(), " ")
                 + code,
             code,
-            self.print_width
-                .saturating_sub(self.indent_level)
-                .saturating_sub(if self.style_indent() {
-                    self.indent_width
-                } else {
-                    0
-                }),
+            Hints {
+                print_width: self
+                    .print_width
+                    .saturating_sub(self.indent_level)
+                    .saturating_sub(if self.style_indent() {
+                        self.indent_width
+                    } else {
+                        0
+                    }),
+                attr: true,
+                ext: "css",
+            },
         )
         .trim()
         .to_owned()
@@ -315,13 +350,18 @@ where
                 .replace(|c: char| !c.is_ascii_whitespace(), " ")
                 + code,
             code,
-            self.print_width
-                .saturating_sub(self.indent_level)
-                .saturating_sub(if self.script_indent() {
-                    self.indent_width
-                } else {
-                    0
-                }),
+            Hints {
+                print_width: self
+                    .print_width
+                    .saturating_sub(self.indent_level)
+                    .saturating_sub(if self.script_indent() {
+                        self.indent_width
+                    } else {
+                        0
+                    }),
+                attr: false,
+                ext: "json",
+            },
         )
     }
 
@@ -330,9 +370,9 @@ where
         path: &Path,
         code: String,
         _original_code: &'a str,
-        print_width: usize,
+        hints: Hints<'b>,
     ) -> Cow<'a, str> {
-        match (self.external_formatter)(path, &code, print_width) {
+        match (self.external_formatter)(path, &code, hints) {
             Ok(Cow::Owned(formatted)) => Cow::from(formatted),
             Ok(Cow::Borrowed(..)) => Cow::from(code),
             Err(e) => {
@@ -343,16 +383,25 @@ where
     }
 }
 
+/// Hints provide some useful additional information to the external formatter.
+pub struct Hints<'s> {
+    pub print_width: usize,
+    /// Whether the code is inside attribute.
+    pub attr: bool,
+    /// Fake file extension.
+    pub ext: &'s str,
+}
+
 pub(crate) trait NestWithCtx {
     fn nest_with_ctx<'b, E, F>(self, ctx: &mut Ctx<'b, E, F>) -> Self
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>;
+        F: for<'a> FnMut(&Path, &'a str, Hints<'b>) -> Result<Cow<'a, str>, E>;
 }
 
 impl NestWithCtx for Doc<'_> {
     fn nest_with_ctx<'b, E, F>(self, ctx: &mut Ctx<'b, E, F>) -> Self
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints<'b>) -> Result<Cow<'a, str>, E>,
     {
         ctx.indent_level += ctx.indent_width;
         let doc = self.nest(ctx.indent_width);
diff --git a/markup_fmt/src/lib.rs b/markup_fmt/src/lib.rs
index d057aa7..3827a75 100644
--- a/markup_fmt/src/lib.rs
+++ b/markup_fmt/src/lib.rs
@@ -10,7 +10,7 @@ mod printer;
 mod state;
 
 use crate::{config::FormatOptions, ctx::Ctx, parser::Parser, printer::DocGen, state::State};
-pub use crate::{error::*, parser::Language};
+pub use crate::{ctx::Hints, error::*, parser::Language};
 use std::{borrow::Cow, path::Path};
 use tiny_pretty::{IndentKind, PrintOptions};
 
@@ -56,7 +56,7 @@ pub fn format_text<E, F>(
     external_formatter: F,
 ) -> Result<String, FormatError<E>>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     let mut parser = Parser::new(code, language.clone());
     let ast = parser.parse_root().map_err(FormatError::Syntax)?;
diff --git a/markup_fmt/src/printer.rs b/markup_fmt/src/printer.rs
index 3ed42d2..43c51d3 100644
--- a/markup_fmt/src/printer.rs
+++ b/markup_fmt/src/printer.rs
@@ -1,7 +1,7 @@
 use crate::{
     ast::*,
     config::{Quotes, VSlotStyle, WhitespaceSensitivity},
-    ctx::{Ctx, NestWithCtx},
+    ctx::{Ctx, Hints, NestWithCtx},
     helpers,
     state::State,
     Language,
@@ -11,15 +11,15 @@ use std::{borrow::Cow, path::Path};
 use tiny_pretty::Doc;
 
 pub(super) trait DocGen<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>;
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>;
 }
 
 impl<'s> DocGen<'s> for AngularCase<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("@case (")
             .append(Doc::text(ctx.format_general_expr(self.expr.0, self.expr.1)))
@@ -34,9 +34,9 @@ impl<'s> DocGen<'s> for AngularCase<'s> {
 }
 
 impl<'s> DocGen<'s> for AngularElseIf<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut docs = Vec::with_capacity(5);
         docs.push(Doc::text("@else if ("));
@@ -57,9 +57,9 @@ impl<'s> DocGen<'s> for AngularElseIf<'s> {
 }
 
 impl<'s> DocGen<'s> for AngularFor<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut docs = Vec::with_capacity(5);
         docs.push(Doc::text("@for ("));
@@ -101,9 +101,9 @@ impl<'s> DocGen<'s> for AngularFor<'s> {
 }
 
 impl<'s> DocGen<'s> for AngularIf<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut docs = Vec::with_capacity(5);
         docs.push(Doc::text("@if ("));
@@ -139,9 +139,9 @@ impl<'s> DocGen<'s> for AngularIf<'s> {
 }
 
 impl<'s> DocGen<'s> for AngularInterpolation<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{{")
             .append(Doc::line_or_space())
@@ -156,9 +156,9 @@ impl<'s> DocGen<'s> for AngularInterpolation<'s> {
 }
 
 impl<'s> DocGen<'s> for AngularLet<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("@let ")
             .append(Doc::text(self.name))
@@ -169,9 +169,9 @@ impl<'s> DocGen<'s> for AngularLet<'s> {
 }
 
 impl<'s> DocGen<'s> for AngularSwitch<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut docs = Vec::with_capacity(5);
         docs.push(Doc::text("@switch ("));
@@ -199,9 +199,9 @@ impl<'s> DocGen<'s> for AngularSwitch<'s> {
 }
 
 impl<'s> DocGen<'s> for AstroAttribute<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let expr_code = ctx.format_general_expr(self.expr.0, self.expr.1);
         let expr = Doc::text("{")
@@ -224,9 +224,9 @@ impl<'s> DocGen<'s> for AstroAttribute<'s> {
 }
 
 impl<'s> DocGen<'s> for AstroExpr<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         const PLACEHOLDER: &str = "$AstroTpl$";
         let script = self
@@ -289,9 +289,9 @@ impl<'s> DocGen<'s> for AstroExpr<'s> {
 }
 
 impl<'s> DocGen<'s> for Attribute<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         match self {
             Attribute::Native(native_attribute) => native_attribute.doc(ctx, state),
@@ -305,9 +305,9 @@ impl<'s> DocGen<'s> for Attribute<'s> {
 }
 
 impl<'s> DocGen<'s> for Comment<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         if ctx.options.format_comments {
             Doc::text("<!--")
@@ -326,9 +326,9 @@ impl<'s> DocGen<'s> for Comment<'s> {
 }
 
 impl<'s> DocGen<'s> for Doctype<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         use crate::config::DoctypeKeywordCase;
 
@@ -349,9 +349,9 @@ impl<'s> DocGen<'s> for Doctype<'s> {
 }
 
 impl<'s> DocGen<'s> for Element<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let tag_name = self
             .tag_name
@@ -571,10 +571,12 @@ impl<'s> DocGen<'s> for Element<'s> {
                                     }
                                     _ => None,
                                 })
-                                .unwrap_or(if matches!(ctx.language, Language::Astro) {
-                                    "ts"
-                                } else {
-                                    "js"
+                                .unwrap_or_else(|| {
+                                    if matches!(ctx.language, Language::Astro) {
+                                        "ts"
+                                    } else {
+                                        "js"
+                                    }
                                 }),
                             text_node.start,
                         )
@@ -710,9 +712,9 @@ impl<'s> DocGen<'s> for Element<'s> {
 }
 
 impl<'s> DocGen<'s> for FrontMatter<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         if matches!(ctx.language, Language::Astro) {
             let formatted = ctx.format_script(self.raw, "tsx", self.start);
@@ -730,9 +732,9 @@ impl<'s> DocGen<'s> for FrontMatter<'s> {
 }
 
 impl<'s> DocGen<'s> for JinjaBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::list(
             self.body
@@ -749,9 +751,9 @@ impl<'s> DocGen<'s> for JinjaBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for JinjaComment<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         if ctx.options.format_comments {
             Doc::text("{#")
@@ -770,9 +772,9 @@ impl<'s> DocGen<'s> for JinjaComment<'s> {
 }
 
 impl<'s> DocGen<'s> for JinjaInterpolation<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{{")
             .append(Doc::line_or_space())
@@ -785,9 +787,9 @@ impl<'s> DocGen<'s> for JinjaInterpolation<'s> {
 }
 
 impl<'s> DocGen<'s> for JinjaTag<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let (prefix, content) = self
             .content
@@ -812,9 +814,9 @@ impl<'s> DocGen<'s> for JinjaTag<'s> {
 }
 
 impl<'s> DocGen<'s> for NativeAttribute<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let name = Doc::text(self.name);
         if let Some((value, value_start)) = self.value {
@@ -917,9 +919,9 @@ impl<'s> DocGen<'s> for NativeAttribute<'s> {
 }
 
 impl<'s> DocGen<'s> for NodeKind<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         match self {
             NodeKind::AngularFor(angular_for) => angular_for.doc(ctx, state),
@@ -962,9 +964,9 @@ impl<'s> DocGen<'s> for NodeKind<'s> {
 }
 
 impl<'s> DocGen<'s> for Root<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let is_whole_document_like = self.children.iter().any(|child| match &child.kind {
             NodeKind::Doctype(..) => true,
@@ -999,9 +1001,9 @@ impl<'s> DocGen<'s> for Root<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteAtTag<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{@")
             .append(Doc::text(self.name))
@@ -1012,9 +1014,9 @@ impl<'s> DocGen<'s> for SvelteAtTag<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteAttribute<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let expr_code = ctx.format_general_expr(self.expr.0, self.expr.1);
         let expr = Doc::text("{")
@@ -1062,9 +1064,9 @@ impl<'s> DocGen<'s> for SvelteAttribute<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteAwaitBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut head = Vec::with_capacity(5);
         head.push(Doc::text("{#await "));
@@ -1110,9 +1112,9 @@ impl<'s> DocGen<'s> for SvelteAwaitBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteCatchBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let children = format_control_structure_block_children(&self.children, ctx, state);
         if let Some((binding, start)) = self.binding {
@@ -1127,9 +1129,9 @@ impl<'s> DocGen<'s> for SvelteCatchBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteEachBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut head = Vec::with_capacity(5);
         head.push(Doc::text("{#each "));
@@ -1180,9 +1182,9 @@ impl<'s> DocGen<'s> for SvelteEachBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteElseIfBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{:else if ")
             .append(Doc::text(ctx.format_general_expr(self.expr.0, self.expr.1)))
@@ -1196,9 +1198,9 @@ impl<'s> DocGen<'s> for SvelteElseIfBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteIfBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         let mut docs = Vec::with_capacity(5);
         docs.push(Doc::text("{#if "));
@@ -1229,9 +1231,9 @@ impl<'s> DocGen<'s> for SvelteIfBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteInterpolation<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{")
             .append(Doc::line_or_nil())
@@ -1246,9 +1248,9 @@ impl<'s> DocGen<'s> for SvelteInterpolation<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteKeyBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{#key ")
             .append(Doc::text(ctx.format_general_expr(self.expr.0, self.expr.1)))
@@ -1263,9 +1265,9 @@ impl<'s> DocGen<'s> for SvelteKeyBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for SvelteThenBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{:then ")
             .append(Doc::text(
@@ -1281,9 +1283,9 @@ impl<'s> DocGen<'s> for SvelteThenBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for TextNode<'s> {
-    fn doc<E, F>(&self, _: &mut Ctx<E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, _: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         // for #16
         Doc::flat_or_break(Doc::text(self.raw.split_ascii_whitespace().join(" ")), {
@@ -1302,9 +1304,9 @@ impl<'s> DocGen<'s> for TextNode<'s> {
 }
 
 impl<'s> DocGen<'s> for VentoBlock<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::list(
             self.body
@@ -1316,9 +1318,9 @@ impl<'s> DocGen<'s> for VentoBlock<'s> {
 }
 
 impl<'s> DocGen<'s> for VentoComment<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         if ctx.options.format_comments {
             Doc::text("{{#")
@@ -1337,9 +1339,9 @@ impl<'s> DocGen<'s> for VentoComment<'s> {
 }
 
 impl<'s> DocGen<'s> for VentoEval<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{{>")
             .append(Doc::line_or_space())
@@ -1356,9 +1358,9 @@ impl<'s> DocGen<'s> for VentoEval<'s> {
 }
 
 impl<'s> DocGen<'s> for VentoInterpolation<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{{")
             .append(Doc::line_or_space())
@@ -1380,9 +1382,9 @@ impl<'s> DocGen<'s> for VentoInterpolation<'s> {
 }
 
 impl<'s> DocGen<'s> for VentoTag<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{{")
             .append(Doc::line_or_space())
@@ -1478,9 +1480,9 @@ impl<'s> DocGen<'s> for VentoTag<'s> {
 }
 
 impl<'s> DocGen<'s> for VentoTagOrChildren<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         match self {
             VentoTagOrChildren::Tag(tag) => tag.doc(ctx, state),
@@ -1492,9 +1494,9 @@ impl<'s> DocGen<'s> for VentoTagOrChildren<'s> {
 }
 
 impl<'s> DocGen<'s> for VueDirective<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, state: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, state: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         use crate::config::{VBindStyle, VOnStyle};
 
@@ -1624,9 +1626,9 @@ impl<'s> DocGen<'s> for VueDirective<'s> {
 }
 
 impl<'s> DocGen<'s> for VueInterpolation<'s> {
-    fn doc<E, F>(&self, ctx: &mut Ctx<E, F>, _: &State<'s>) -> Doc<'s>
+    fn doc<E, F>(&self, ctx: &mut Ctx<'s, E, F>, _: &State<'s>) -> Doc<'s>
     where
-        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+        F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
     {
         Doc::text("{{")
             .append(Doc::line_or_space())
@@ -1710,9 +1712,9 @@ fn is_all_ascii_whitespace(s: &str) -> bool {
     !s.is_empty() && s.as_bytes().iter().all(|byte| byte.is_ascii_whitespace())
 }
 
-fn should_ignore_node<E, F>(index: usize, nodes: &[Node], ctx: &Ctx<E, F>) -> bool
+fn should_ignore_node<'s, E, F>(index: usize, nodes: &[Node], ctx: &Ctx<'s, E, F>) -> bool
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     match index.checked_sub(1).and_then(|i| nodes.get(i)) {
         Some(Node {
@@ -1736,9 +1738,9 @@ where
         _ => false,
     }
 }
-fn has_ignore_directive<E, F>(comment: &Comment, ctx: &Ctx<E, F>) -> bool
+fn has_ignore_directive<'s, E, F>(comment: &Comment, ctx: &Ctx<'s, E, F>) -> bool
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     comment
         .raw
@@ -1819,11 +1821,11 @@ fn format_attr_value<'a>(value: impl AsRef<str>, quotes: &Quotes) -> Doc<'a> {
 
 fn format_children_with_inserting_linebreak<'s, E, F>(
     children: &[Node<'s>],
-    ctx: &mut Ctx<'_, E, F>,
+    ctx: &mut Ctx<'s, E, F>,
     state: &State<'s>,
 ) -> Doc<'s>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     Doc::list(
         children
@@ -1907,11 +1909,11 @@ fn is_text_like(node: &Node) -> bool {
 fn format_children_without_inserting_linebreak<'s, E, F>(
     children: &[Node<'s>],
     has_two_more_non_text_children: bool,
-    ctx: &mut Ctx<'_, E, F>,
+    ctx: &mut Ctx<'s, E, F>,
     state: &State<'s>,
 ) -> Doc<'s>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     Doc::list(
         children
@@ -1974,11 +1976,11 @@ fn extract_slot_name(arg_and_modifiers: Option<&str>) -> &str {
 
 fn get_v_slot_style_option<'s, E, F>(
     slot: &'s str,
-    ctx: &Ctx<E, F>,
+    ctx: &Ctx<'s, E, F>,
     state: &State<'s>,
 ) -> Option<VSlotStyle>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     let option = if state
         .current_tag_name
@@ -2066,10 +2068,10 @@ fn format_v_for<'s, E, F>(
     delimiter: &'static str,
     right: &str,
     start: usize,
-    ctx: &mut Ctx<'_, E, F>,
+    ctx: &mut Ctx<'s, E, F>,
 ) -> String
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     let left = ctx.format_general_expr(left, start);
     let right = ctx.format_general_expr(right, start + 4);
@@ -2082,11 +2084,11 @@ where
 
 fn format_control_structure_block_children<'s, E, F>(
     children: &[Node<'s>],
-    ctx: &mut Ctx<'_, E, F>,
+    ctx: &mut Ctx<'s, E, F>,
     state: &State<'s>,
 ) -> Doc<'s>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     match children {
         [Node {
@@ -2109,10 +2111,10 @@ fn format_vento_stmt_header<'s, E, F>(
     tag_keyword: &'static str,
     fake_keyword: &'static str,
     code: &'s str,
-    ctx: &mut Ctx<'_, E, F>,
+    ctx: &mut Ctx<'s, E, F>,
 ) -> Doc<'s>
 where
-    F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    F: for<'a> FnMut(&Path, &'a str, Hints) -> Result<Cow<'a, str>, E>,
 {
     Doc::text(tag_keyword)
         .append(Doc::space())