diff --git a/.changeset/brave-trees-push.md b/.changeset/brave-trees-push.md
new file mode 100644
index 000000000000..b463b8e1cb17
--- /dev/null
+++ b/.changeset/brave-trees-push.md
@@ -0,0 +1,21 @@
+---
+"@biomejs/biome": patch
+---
+
+Added a new **experimental option** that allows parsing of `.html` files that contain interpolation syntax.
+
+```json5
+// biome.json
+{
+  "html": {
+    // This is the new, experimental option.
+    "parser": {
+      "interpolation": true
+    }
+  }
+}
+```
+
+```html
+<h1>{{ $title }}</h1>
+```
diff --git a/crates/biome_cli/tests/cases/html.rs b/crates/biome_cli/tests/cases/html.rs
new file mode 100644
index 000000000000..d7a27a71318e
--- /dev/null
+++ b/crates/biome_cli/tests/cases/html.rs
@@ -0,0 +1,92 @@
+use crate::run_cli;
+use crate::snap_test::{SnapshotPayload, assert_cli_snapshot};
+use biome_console::BufferConsole;
+use biome_fs::MemoryFileSystem;
+use bpaf::Args;
+use camino::Utf8Path;
+
+#[test]
+fn should_error_when_interpolation_is_disabled() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let html_file = Utf8Path::new("file.html");
+    fs.insert(
+        html_file.into(),
+        r#"<div>{{ $interpolation }}</div>
+"#
+        .as_bytes(),
+    );
+    fs.insert(
+        Utf8Path::new("biome.json").into(),
+        r#"{
+    "html": {
+        "formatter": {
+            "enabled": true
+        }
+    }
+}"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["format", html_file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "should_error_when_interpolation_is_disabled",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn should_not_error_when_interpolation_is_enabled() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let html_file = Utf8Path::new("file.html");
+    fs.insert(
+        html_file.into(),
+        r#"<div>{{ $interpolation }}</div>
+"#
+        .as_bytes(),
+    );
+
+    fs.insert(
+        Utf8Path::new("biome.json").into(),
+        r#"{
+    "html": {
+        "parser": {
+            "interpolation": true
+        },
+        "formatter": {
+            "enabled": true
+        }
+    }
+}"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["format", html_file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "should_not_error_when_interpolation_is_enabled",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/biome_cli/tests/cases/mod.rs b/crates/biome_cli/tests/cases/mod.rs
index 5d2bf39d274b..3616fba4755c 100644
--- a/crates/biome_cli/tests/cases/mod.rs
+++ b/crates/biome_cli/tests/cases/mod.rs
@@ -13,6 +13,7 @@ mod handle_astro_files;
 mod handle_css_files;
 mod handle_svelte_files;
 mod handle_vue_files;
+mod html;
 mod included_files;
 mod linter_domains;
 mod linter_groups_plain;
diff --git a/crates/biome_cli/tests/snapshots/main_cases_html/should_error_when_interpolation_is_disabled.snap b/crates/biome_cli/tests/snapshots/main_cases_html/should_error_when_interpolation_is_disabled.snap
new file mode 100644
index 000000000000..937db2201b3d
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_html/should_error_when_interpolation_is_disabled.snap
@@ -0,0 +1,68 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "html": {
+    "formatter": {
+      "enabled": true
+    }
+  }
+}
+```
+
+## `file.html`
+
+```html
+<div>{{ $interpolation }}</div>
+
+```
+
+# Termination Message
+
+```block
+format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × No files were processed in the specified paths.
+  
+  i Check your biome.json or biome.jsonc to ensure the paths are not ignored by the configuration.
+  
+  i These paths were provided but ignored:
+  
+  - file.html
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file.html:1:6 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+  > 1 │ <div>{{ $interpolation }}</div>
+      │      ^^^^^^^^^^^^^^^^^^^^
+    2 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+
+```
+
+```block
+file.html format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Code formatting aborted due to parsing errors. To format code with errors, enable the 'formatter.formatWithErrors' option.
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 error.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_html/should_not_error_when_interpolation_is_enabled.snap b/crates/biome_cli/tests/snapshots/main_cases_html/should_not_error_when_interpolation_is_enabled.snap
new file mode 100644
index 000000000000..1f4107227038
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_html/should_not_error_when_interpolation_is_enabled.snap
@@ -0,0 +1,31 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "html": {
+    "parser": {
+      "interpolation": true
+    },
+    "formatter": {
+      "enabled": true
+    }
+  }
+}
+```
+
+## `file.html`
+
+```html
+<div>{{ $interpolation }}</div>
+
+```
+
+# Emitted Messages
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+```
diff --git a/crates/biome_configuration/src/html.rs b/crates/biome_configuration/src/html.rs
index 2f17ac510efd..5ebe93b57d9a 100644
--- a/crates/biome_configuration/src/html.rs
+++ b/crates/biome_configuration/src/html.rs
@@ -30,6 +30,7 @@ pub struct HtmlConfiguration {
 pub type HtmlFormatterEnabled = Bool<false>; // Keep it disabled by default while experimental.
 pub type HtmlLinterEnabled = Bool<false>;
 pub type HtmlAssistEnabled = Bool<false>;
+pub type HtmlParseInterpolation = Bool<false>;
 
 /// Options that changes how the HTML parser behaves
 #[derive(
@@ -37,7 +38,10 @@ pub type HtmlAssistEnabled = Bool<false>;
 )]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct HtmlParserConfiguration;
+pub struct HtmlParserConfiguration {
+    /// Enables the parsing of double text expressions such as `{{ expression }}` inside `.html` files
+    pub interpolation: Option<HtmlParseInterpolation>,
+}
 
 /// Options that changes how the HTML formatter behaves
 #[derive(
diff --git a/crates/biome_html_factory/src/generated/node_factory.rs b/crates/biome_html_factory/src/generated/node_factory.rs
index 070fd0d1cbcb..7c63856f3806 100644
--- a/crates/biome_html_factory/src/generated/node_factory.rs
+++ b/crates/biome_html_factory/src/generated/node_factory.rs
@@ -65,7 +65,7 @@ impl HtmlAttributeBuilder {
 }
 pub fn html_attribute_initializer_clause(
     eq_token: SyntaxToken,
-    value: HtmlString,
+    value: AnyHtmlAttributeInitializer,
 ) -> HtmlAttributeInitializerClause {
     HtmlAttributeInitializerClause::unwrap_cast(SyntaxNode::new_detached(
         HtmlSyntaxKind::HTML_ATTRIBUTE_INITIALIZER_CLAUSE,
@@ -179,6 +179,20 @@ impl HtmlDirectiveBuilder {
         ))
     }
 }
+pub fn html_double_text_expression(
+    l_double_curly_token: SyntaxToken,
+    expression: HtmlTextExpression,
+    r_double_curly_token: SyntaxToken,
+) -> HtmlDoubleTextExpression {
+    HtmlDoubleTextExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::HTML_DOUBLE_TEXT_EXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_double_curly_token)),
+            Some(SyntaxElement::Node(expression.into_syntax())),
+            Some(SyntaxElement::Token(r_double_curly_token)),
+        ],
+    ))
+}
 pub fn html_element(
     opening_element: HtmlOpeningElement,
     children: HtmlElementList,
@@ -292,6 +306,20 @@ impl HtmlSelfClosingElementBuilder {
         ))
     }
 }
+pub fn html_single_text_expression(
+    l_curly_token: SyntaxToken,
+    expression: HtmlTextExpression,
+    r_curly_token: SyntaxToken,
+) -> HtmlSingleTextExpression {
+    HtmlSingleTextExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::HTML_SINGLE_TEXT_EXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_curly_token)),
+            Some(SyntaxElement::Node(expression.into_syntax())),
+            Some(SyntaxElement::Token(r_curly_token)),
+        ],
+    ))
+}
 pub fn html_string(value_token: SyntaxToken) -> HtmlString {
     HtmlString::unwrap_cast(SyntaxNode::new_detached(
         HtmlSyntaxKind::HTML_STRING,
@@ -304,32 +332,10 @@ pub fn html_tag_name(value_token: SyntaxToken) -> HtmlTagName {
         [Some(SyntaxElement::Token(value_token))],
     ))
 }
-pub fn html_text_expression(
-    l_double_curly_token: SyntaxToken,
-    expression_token: SyntaxToken,
-    r_double_curly_token: SyntaxToken,
-) -> HtmlTextExpression {
+pub fn html_text_expression(html_literal_token: SyntaxToken) -> HtmlTextExpression {
     HtmlTextExpression::unwrap_cast(SyntaxNode::new_detached(
         HtmlSyntaxKind::HTML_TEXT_EXPRESSION,
-        [
-            Some(SyntaxElement::Token(l_double_curly_token)),
-            Some(SyntaxElement::Token(expression_token)),
-            Some(SyntaxElement::Token(r_double_curly_token)),
-        ],
-    ))
-}
-pub fn svelte_text_expression(
-    l_curly_token: SyntaxToken,
-    expression_token: SyntaxToken,
-    r_curly_token: SyntaxToken,
-) -> SvelteTextExpression {
-    SvelteTextExpression::unwrap_cast(SyntaxNode::new_detached(
-        HtmlSyntaxKind::SVELTE_TEXT_EXPRESSION,
-        [
-            Some(SyntaxElement::Token(l_curly_token)),
-            Some(SyntaxElement::Token(expression_token)),
-            Some(SyntaxElement::Token(r_curly_token)),
-        ],
+        [Some(SyntaxElement::Token(html_literal_token))],
     ))
 }
 pub fn html_attribute_list<I>(items: I) -> HtmlAttributeList
@@ -393,3 +399,13 @@ where
         slots,
     ))
 }
+pub fn html_bogus_text_expression<I>(slots: I) -> HtmlBogusTextExpression
+where
+    I: IntoIterator<Item = Option<SyntaxElement>>,
+    I::IntoIter: ExactSizeIterator,
+{
+    HtmlBogusTextExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::HTML_BOGUS_TEXT_EXPRESSION,
+        slots,
+    ))
+}
diff --git a/crates/biome_html_factory/src/generated/syntax_factory.rs b/crates/biome_html_factory/src/generated/syntax_factory.rs
index 1a51134e4ea1..702aa882a79c 100644
--- a/crates/biome_html_factory/src/generated/syntax_factory.rs
+++ b/crates/biome_html_factory/src/generated/syntax_factory.rs
@@ -14,7 +14,11 @@ impl SyntaxFactory for HtmlSyntaxFactory {
         children: ParsedChildren<Self::Kind>,
     ) -> RawSyntaxNode<Self::Kind> {
         match kind {
-            ASTRO_BOGUS_FRONTMATTER | HTML_BOGUS | HTML_BOGUS_ATTRIBUTE | HTML_BOGUS_ELEMENT => {
+            ASTRO_BOGUS_FRONTMATTER
+            | HTML_BOGUS
+            | HTML_BOGUS_ATTRIBUTE
+            | HTML_BOGUS_ELEMENT
+            | HTML_BOGUS_TEXT_EXPRESSION => {
                 RawSyntaxNode::new(kind, children.into_iter().map(Some))
             }
             ASTRO_FRONTMATTER_ELEMENT => {
@@ -88,7 +92,7 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.next_slot();
                 if let Some(element) = &current_element {
-                    if HtmlString::can_cast(element.kind()) {
+                    if AnyHtmlAttributeInitializer::can_cast(element.kind()) {
                         slots.mark_present();
                         current_element = elements.next();
                     }
@@ -281,6 +285,39 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(HTML_DIRECTIVE, children)
             }
+            HTML_DOUBLE_TEXT_EXPRESSION => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element {
+                    if element.kind() == T!["{{"] {
+                        slots.mark_present();
+                        current_element = elements.next();
+                    }
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element {
+                    if HtmlTextExpression::can_cast(element.kind()) {
+                        slots.mark_present();
+                        current_element = elements.next();
+                    }
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element {
+                    if element.kind() == T!["}}"] {
+                        slots.mark_present();
+                        current_element = elements.next();
+                    }
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        HTML_DOUBLE_TEXT_EXPRESSION.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(HTML_DOUBLE_TEXT_EXPRESSION, children)
+            }
             HTML_ELEMENT => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
@@ -448,12 +485,26 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(HTML_SELF_CLOSING_ELEMENT, children)
             }
-            HTML_STRING => {
+            HTML_SINGLE_TEXT_EXPRESSION => {
                 let mut elements = (&children).into_iter();
-                let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
                 let mut current_element = elements.next();
                 if let Some(element) = &current_element {
-                    if element.kind() == HTML_STRING_LITERAL {
+                    if element.kind() == T!['{'] {
+                        slots.mark_present();
+                        current_element = elements.next();
+                    }
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element {
+                    if HtmlTextExpression::can_cast(element.kind()) {
+                        slots.mark_present();
+                        current_element = elements.next();
+                    }
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element {
+                    if element.kind() == T!['}'] {
                         slots.mark_present();
                         current_element = elements.next();
                     }
@@ -461,18 +512,18 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 slots.next_slot();
                 if current_element.is_some() {
                     return RawSyntaxNode::new(
-                        HTML_STRING.to_bogus(),
+                        HTML_SINGLE_TEXT_EXPRESSION.to_bogus(),
                         children.into_iter().map(Some),
                     );
                 }
-                slots.into_node(HTML_STRING, children)
+                slots.into_node(HTML_SINGLE_TEXT_EXPRESSION, children)
             }
-            HTML_TAG_NAME => {
+            HTML_STRING => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
                 let mut current_element = elements.next();
                 if let Some(element) = &current_element {
-                    if element.kind() == HTML_LITERAL {
+                    if element.kind() == HTML_STRING_LITERAL {
                         slots.mark_present();
                         current_element = elements.next();
                     }
@@ -480,23 +531,16 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 slots.next_slot();
                 if current_element.is_some() {
                     return RawSyntaxNode::new(
-                        HTML_TAG_NAME.to_bogus(),
+                        HTML_STRING.to_bogus(),
                         children.into_iter().map(Some),
                     );
                 }
-                slots.into_node(HTML_TAG_NAME, children)
+                slots.into_node(HTML_STRING, children)
             }
-            HTML_TEXT_EXPRESSION => {
+            HTML_TAG_NAME => {
                 let mut elements = (&children).into_iter();
-                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
                 let mut current_element = elements.next();
-                if let Some(element) = &current_element {
-                    if element.kind() == T!["{{"] {
-                        slots.mark_present();
-                        current_element = elements.next();
-                    }
-                }
-                slots.next_slot();
                 if let Some(element) = &current_element {
                     if element.kind() == HTML_LITERAL {
                         slots.mark_present();
@@ -504,32 +548,18 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                     }
                 }
                 slots.next_slot();
-                if let Some(element) = &current_element {
-                    if element.kind() == T!["}}"] {
-                        slots.mark_present();
-                        current_element = elements.next();
-                    }
-                }
-                slots.next_slot();
                 if current_element.is_some() {
                     return RawSyntaxNode::new(
-                        HTML_TEXT_EXPRESSION.to_bogus(),
+                        HTML_TAG_NAME.to_bogus(),
                         children.into_iter().map(Some),
                     );
                 }
-                slots.into_node(HTML_TEXT_EXPRESSION, children)
+                slots.into_node(HTML_TAG_NAME, children)
             }
-            SVELTE_TEXT_EXPRESSION => {
+            HTML_TEXT_EXPRESSION => {
                 let mut elements = (&children).into_iter();
-                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
                 let mut current_element = elements.next();
-                if let Some(element) = &current_element {
-                    if element.kind() == T!['{'] {
-                        slots.mark_present();
-                        current_element = elements.next();
-                    }
-                }
-                slots.next_slot();
                 if let Some(element) = &current_element {
                     if element.kind() == HTML_LITERAL {
                         slots.mark_present();
@@ -537,20 +567,13 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                     }
                 }
                 slots.next_slot();
-                if let Some(element) = &current_element {
-                    if element.kind() == T!['}'] {
-                        slots.mark_present();
-                        current_element = elements.next();
-                    }
-                }
-                slots.next_slot();
                 if current_element.is_some() {
                     return RawSyntaxNode::new(
-                        SVELTE_TEXT_EXPRESSION.to_bogus(),
+                        HTML_TEXT_EXPRESSION.to_bogus(),
                         children.into_iter().map(Some),
                     );
                 }
-                slots.into_node(SVELTE_TEXT_EXPRESSION, children)
+                slots.into_node(HTML_TEXT_EXPRESSION, children)
             }
             HTML_ATTRIBUTE_LIST => {
                 Self::make_node_list_syntax(kind, children, AnyHtmlAttribute::can_cast)
diff --git a/crates/biome_html_formatter/benches/html_formatter.rs b/crates/biome_html_formatter/benches/html_formatter.rs
index ffca45779aa6..c700a112ecb3 100644
--- a/crates/biome_html_formatter/benches/html_formatter.rs
+++ b/crates/biome_html_formatter/benches/html_formatter.rs
@@ -1,6 +1,6 @@
 use biome_formatter::Printed;
 use biome_html_formatter::{HtmlFormatOptions, format_node};
-use biome_html_parser::parse_html;
+use biome_html_parser::{HtmlParseOptions, parse_html};
 use biome_html_syntax::{HtmlFileSource, HtmlRoot};
 use biome_rowan::AstNode;
 use biome_test_utils::BenchCase;
@@ -37,7 +37,7 @@ fn bench_formatter(criterion: &mut Criterion) {
             Ok(test_case) => {
                 let code = test_case.code();
                 let file_source = HtmlFileSource::try_from(test_case.path()).unwrap_or_default();
-                let parsed = parse_html(code, file_source);
+                let parsed = parse_html(code, HtmlParseOptions::from(&file_source));
                 group.throughput(Throughput::Bytes(code.len() as u64));
                 group.bench_with_input(
                     BenchmarkId::from_parameter(test_case.filename()),
diff --git a/crates/biome_html_formatter/src/astro/auxiliary/expression.rs b/crates/biome_html_formatter/src/astro/auxiliary/expression.rs
new file mode 100644
index 000000000000..960fd5ecc5ca
--- /dev/null
+++ b/crates/biome_html_formatter/src/astro/auxiliary/expression.rs
@@ -0,0 +1,24 @@
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_html_syntax::{AstroExpression, AstroExpressionFields};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAstroExpression;
+impl FormatNodeRule<AstroExpression> for FormatAstroExpression {
+    fn fmt_fields(&self, node: &AstroExpression, f: &mut HtmlFormatter) -> FormatResult<()> {
+        let AstroExpressionFields {
+            l_curly_token,
+            expression_token,
+            r_curly_token,
+        } = node.as_fields();
+
+        write!(
+            f,
+            [
+                l_curly_token.format(),
+                expression_token.format(),
+                r_curly_token.format()
+            ]
+        )
+    }
+}
diff --git a/crates/biome_html_formatter/src/generated.rs b/crates/biome_html_formatter/src/generated.rs
index b1dff930364d..0c3c357a8a06 100644
--- a/crates/biome_html_formatter/src/generated.rs
+++ b/crates/biome_html_formatter/src/generated.rs
@@ -304,6 +304,46 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlDirective {
         )
     }
 }
+impl FormatRule<biome_html_syntax::HtmlDoubleTextExpression>
+    for crate::html::auxiliary::double_text_expression::FormatHtmlDoubleTextExpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::HtmlDoubleTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::HtmlDoubleTextExpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlDoubleTextExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::HtmlDoubleTextExpression,
+        crate::html::auxiliary::double_text_expression::FormatHtmlDoubleTextExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::html::auxiliary::double_text_expression::FormatHtmlDoubleTextExpression::default(
+            ),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlDoubleTextExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::HtmlDoubleTextExpression,
+        crate::html::auxiliary::double_text_expression::FormatHtmlDoubleTextExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::html::auxiliary::double_text_expression::FormatHtmlDoubleTextExpression::default(
+            ),
+        )
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlElement>
     for crate::html::auxiliary::element::FormatHtmlElement
 {
@@ -450,6 +490,46 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlSelfClosingElement
         )
     }
 }
+impl FormatRule<biome_html_syntax::HtmlSingleTextExpression>
+    for crate::html::auxiliary::single_text_expression::FormatHtmlSingleTextExpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::HtmlSingleTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::HtmlSingleTextExpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlSingleTextExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::HtmlSingleTextExpression,
+        crate::html::auxiliary::single_text_expression::FormatHtmlSingleTextExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::html::auxiliary::single_text_expression::FormatHtmlSingleTextExpression::default(
+            ),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlSingleTextExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::HtmlSingleTextExpression,
+        crate::html::auxiliary::single_text_expression::FormatHtmlSingleTextExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::html::auxiliary::single_text_expression::FormatHtmlSingleTextExpression::default(
+            ),
+        )
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlString>
     for crate::html::auxiliary::string::FormatHtmlString
 {
@@ -560,44 +640,6 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlTextExpression {
         )
     }
 }
-impl FormatRule<biome_html_syntax::SvelteTextExpression>
-    for crate::svelte::auxiliary::text_expression::FormatSvelteTextExpression
-{
-    type Context = HtmlFormatContext;
-    #[inline(always)]
-    fn fmt(
-        &self,
-        node: &biome_html_syntax::SvelteTextExpression,
-        f: &mut HtmlFormatter,
-    ) -> FormatResult<()> {
-        FormatNodeRule::<biome_html_syntax::SvelteTextExpression>::fmt(self, node, f)
-    }
-}
-impl AsFormat<HtmlFormatContext> for biome_html_syntax::SvelteTextExpression {
-    type Format<'a> = FormatRefWithRule<
-        'a,
-        biome_html_syntax::SvelteTextExpression,
-        crate::svelte::auxiliary::text_expression::FormatSvelteTextExpression,
-    >;
-    fn format(&self) -> Self::Format<'_> {
-        FormatRefWithRule::new(
-            self,
-            crate::svelte::auxiliary::text_expression::FormatSvelteTextExpression::default(),
-        )
-    }
-}
-impl IntoFormat<HtmlFormatContext> for biome_html_syntax::SvelteTextExpression {
-    type Format = FormatOwnedWithRule<
-        biome_html_syntax::SvelteTextExpression,
-        crate::svelte::auxiliary::text_expression::FormatSvelteTextExpression,
-    >;
-    fn into_format(self) -> Self::Format {
-        FormatOwnedWithRule::new(
-            self,
-            crate::svelte::auxiliary::text_expression::FormatSvelteTextExpression::default(),
-        )
-    }
-}
 impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeList {
     type Format<'a> = FormatRefWithRule<
         'a,
@@ -788,6 +830,44 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlBogusElement {
         )
     }
 }
+impl FormatRule<biome_html_syntax::HtmlBogusTextExpression>
+    for crate::html::bogus::bogus_text_expression::FormatHtmlBogusTextExpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::HtmlBogusTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatBogusNodeRule::<biome_html_syntax::HtmlBogusTextExpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlBogusTextExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::HtmlBogusTextExpression,
+        crate::html::bogus::bogus_text_expression::FormatHtmlBogusTextExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::html::bogus::bogus_text_expression::FormatHtmlBogusTextExpression::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlBogusTextExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::HtmlBogusTextExpression,
+        crate::html::bogus::bogus_text_expression::FormatHtmlBogusTextExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::html::bogus::bogus_text_expression::FormatHtmlBogusTextExpression::default(),
+        )
+    }
+}
 impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyAstroFrontmatterElement {
     type Format<'a> = FormatRefWithRule<
         'a,
@@ -838,6 +918,31 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AnyHtmlAttribute {
         )
     }
 }
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyHtmlAttributeInitializer {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::AnyHtmlAttributeInitializer,
+        crate::html::any::attribute_initializer::FormatAnyHtmlAttributeInitializer,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::html::any::attribute_initializer::FormatAnyHtmlAttributeInitializer::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AnyHtmlAttributeInitializer {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::AnyHtmlAttributeInitializer,
+        crate::html::any::attribute_initializer::FormatAnyHtmlAttributeInitializer,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::html::any::attribute_initializer::FormatAnyHtmlAttributeInitializer::default(),
+        )
+    }
+}
 impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyHtmlContent {
     type Format<'a> = FormatRefWithRule<
         'a,
diff --git a/crates/biome_html_formatter/src/html/any/attribute.rs b/crates/biome_html_formatter/src/html/any/attribute.rs
index 9a0aea4413e7..a52030c5a345 100644
--- a/crates/biome_html_formatter/src/html/any/attribute.rs
+++ b/crates/biome_html_formatter/src/html/any/attribute.rs
@@ -10,6 +10,7 @@ impl FormatRule<AnyHtmlAttribute> for FormatAnyHtmlAttribute {
         match node {
             AnyHtmlAttribute::HtmlAttribute(node) => node.format().fmt(f),
             AnyHtmlAttribute::HtmlBogusAttribute(node) => node.format().fmt(f),
+            AnyHtmlAttribute::HtmlDoubleTextExpression(node) => node.format().fmt(f),
         }
     }
 }
diff --git a/crates/biome_html_formatter/src/html/any/attribute_initializer.rs b/crates/biome_html_formatter/src/html/any/attribute_initializer.rs
new file mode 100644
index 000000000000..79709c0a9cbe
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/any/attribute_initializer.rs
@@ -0,0 +1,15 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+use crate::prelude::*;
+use biome_html_syntax::AnyHtmlAttributeInitializer;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAnyHtmlAttributeInitializer;
+impl FormatRule<AnyHtmlAttributeInitializer> for FormatAnyHtmlAttributeInitializer {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &AnyHtmlAttributeInitializer, f: &mut HtmlFormatter) -> FormatResult<()> {
+        match node {
+            AnyHtmlAttributeInitializer::HtmlSingleTextExpression(node) => node.format().fmt(f),
+            AnyHtmlAttributeInitializer::HtmlString(node) => node.format().fmt(f),
+        }
+    }
+}
diff --git a/crates/biome_html_formatter/src/html/any/mod.rs b/crates/biome_html_formatter/src/html/any/mod.rs
index 7f87f0f7f126..74685e17f3df 100644
--- a/crates/biome_html_formatter/src/html/any/mod.rs
+++ b/crates/biome_html_formatter/src/html/any/mod.rs
@@ -1,6 +1,7 @@
 //! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
 
 pub(crate) mod attribute;
+pub(crate) mod attribute_initializer;
 pub(crate) mod content;
 pub(crate) mod element;
 pub(crate) mod text_expression;
diff --git a/crates/biome_html_formatter/src/html/any/text_expression.rs b/crates/biome_html_formatter/src/html/any/text_expression.rs
index 1fa661c58cb9..11fcc7d56367 100644
--- a/crates/biome_html_formatter/src/html/any/text_expression.rs
+++ b/crates/biome_html_formatter/src/html/any/text_expression.rs
@@ -8,8 +8,9 @@ impl FormatRule<AnyHtmlTextExpression> for FormatAnyHtmlTextExpression {
     type Context = HtmlFormatContext;
     fn fmt(&self, node: &AnyHtmlTextExpression, f: &mut HtmlFormatter) -> FormatResult<()> {
         match node {
-            AnyHtmlTextExpression::HtmlTextExpression(node) => node.format().fmt(f),
-            AnyHtmlTextExpression::SvelteTextExpression(node) => node.format().fmt(f),
+            AnyHtmlTextExpression::HtmlBogusTextExpression(node) => node.format().fmt(f),
+            AnyHtmlTextExpression::HtmlDoubleTextExpression(node) => node.format().fmt(f),
+            AnyHtmlTextExpression::HtmlSingleTextExpression(node) => node.format().fmt(f),
         }
     }
 }
diff --git a/crates/biome_html_formatter/src/html/auxiliary/double_text_expression.rs b/crates/biome_html_formatter/src/html/auxiliary/double_text_expression.rs
new file mode 100644
index 000000000000..bf08ad978c21
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/auxiliary/double_text_expression.rs
@@ -0,0 +1,28 @@
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_html_syntax::{HtmlDoubleTextExpression, HtmlDoubleTextExpressionFields};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlDoubleTextExpression;
+impl FormatNodeRule<HtmlDoubleTextExpression> for FormatHtmlDoubleTextExpression {
+    fn fmt_fields(
+        &self,
+        node: &HtmlDoubleTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        let HtmlDoubleTextExpressionFields {
+            l_double_curly_token,
+            expression,
+            r_double_curly_token,
+        } = node.as_fields();
+
+        write!(
+            f,
+            [
+                l_double_curly_token.format(),
+                expression.format(),
+                r_double_curly_token.format(),
+            ]
+        )
+    }
+}
diff --git a/crates/biome_html_formatter/src/html/auxiliary/mod.rs b/crates/biome_html_formatter/src/html/auxiliary/mod.rs
index f79b0c3b2f17..4a97911822b0 100644
--- a/crates/biome_html_formatter/src/html/auxiliary/mod.rs
+++ b/crates/biome_html_formatter/src/html/auxiliary/mod.rs
@@ -7,10 +7,12 @@ pub(crate) mod cdata_section;
 pub(crate) mod closing_element;
 pub(crate) mod content;
 pub(crate) mod directive;
+pub(crate) mod double_text_expression;
 pub(crate) mod element;
 pub(crate) mod opening_element;
 pub(crate) mod root;
 pub(crate) mod self_closing_element;
+pub(crate) mod single_text_expression;
 pub(crate) mod string;
 pub(crate) mod tag_name;
 pub(crate) mod text_expression;
diff --git a/crates/biome_html_formatter/src/html/auxiliary/single_text_expression.rs b/crates/biome_html_formatter/src/html/auxiliary/single_text_expression.rs
new file mode 100644
index 000000000000..ff5335797265
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/auxiliary/single_text_expression.rs
@@ -0,0 +1,28 @@
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_html_syntax::{HtmlSingleTextExpression, HtmlSingleTextExpressionFields};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlSingleTextExpression;
+impl FormatNodeRule<HtmlSingleTextExpression> for FormatHtmlSingleTextExpression {
+    fn fmt_fields(
+        &self,
+        node: &HtmlSingleTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        let HtmlSingleTextExpressionFields {
+            l_curly_token,
+            expression,
+            r_curly_token,
+        } = node.as_fields();
+
+        write!(
+            f,
+            [
+                l_curly_token.format(),
+                expression.format(),
+                r_curly_token.format()
+            ]
+        )
+    }
+}
diff --git a/crates/biome_html_formatter/src/html/auxiliary/text_expression.rs b/crates/biome_html_formatter/src/html/auxiliary/text_expression.rs
index defe56333c0f..27be4ef2aeac 100644
--- a/crates/biome_html_formatter/src/html/auxiliary/text_expression.rs
+++ b/crates/biome_html_formatter/src/html/auxiliary/text_expression.rs
@@ -1,24 +1,9 @@
 use crate::prelude::*;
-use biome_formatter::write;
-use biome_html_syntax::{HtmlTextExpression, HtmlTextExpressionFields};
-
+use biome_html_syntax::HtmlTextExpression;
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatHtmlTextExpression;
 impl FormatNodeRule<HtmlTextExpression> for FormatHtmlTextExpression {
     fn fmt_fields(&self, node: &HtmlTextExpression, f: &mut HtmlFormatter) -> FormatResult<()> {
-        let HtmlTextExpressionFields {
-            l_double_curly_token,
-            expression_token,
-            r_double_curly_token,
-        } = node.as_fields();
-
-        write!(
-            f,
-            [
-                l_double_curly_token.format(),
-                expression_token.format(),
-                r_double_curly_token.format()
-            ]
-        )
+        format_html_verbatim_node(node.syntax()).fmt(f)
     }
 }
diff --git a/crates/biome_html_formatter/src/html/bogus/bogus_text_expression.rs b/crates/biome_html_formatter/src/html/bogus/bogus_text_expression.rs
new file mode 100644
index 000000000000..74930cdf8ea1
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/bogus/bogus_text_expression.rs
@@ -0,0 +1,5 @@
+use crate::FormatBogusNodeRule;
+use biome_html_syntax::HtmlBogusTextExpression;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlBogusTextExpression;
+impl FormatBogusNodeRule<HtmlBogusTextExpression> for FormatHtmlBogusTextExpression {}
diff --git a/crates/biome_html_formatter/src/html/bogus/mod.rs b/crates/biome_html_formatter/src/html/bogus/mod.rs
index bf030649271b..b221d7faa8ff 100644
--- a/crates/biome_html_formatter/src/html/bogus/mod.rs
+++ b/crates/biome_html_formatter/src/html/bogus/mod.rs
@@ -4,3 +4,4 @@
 pub(crate) mod bogus;
 pub(crate) mod bogus_attribute;
 pub(crate) mod bogus_element;
+pub(crate) mod bogus_text_expression;
diff --git a/crates/biome_html_formatter/src/html/lists/attribute_list.rs b/crates/biome_html_formatter/src/html/lists/attribute_list.rs
index c3e099df857f..64458fdb5d7a 100644
--- a/crates/biome_html_formatter/src/html/lists/attribute_list.rs
+++ b/crates/biome_html_formatter/src/html/lists/attribute_list.rs
@@ -60,6 +60,9 @@ impl FormatRule<HtmlAttributeList> for FormatHtmlAttributeList {
                                             tag_name: self.tag_name.clone(),
                                         })
                                         .fmt(f),
+                                    AnyHtmlAttribute::HtmlDoubleTextExpression(attr) => {
+                                        attr.format().fmt(f)
+                                    }
                                     AnyHtmlAttribute::HtmlBogusAttribute(attr) => {
                                         attr.format().fmt(f)
                                     }
diff --git a/crates/biome_html_formatter/src/lib.rs b/crates/biome_html_formatter/src/lib.rs
index c9aa8d2ec29f..d57886d51998 100644
--- a/crates/biome_html_formatter/src/lib.rs
+++ b/crates/biome_html_formatter/src/lib.rs
@@ -19,7 +19,6 @@ mod cst;
 mod generated;
 mod html;
 pub(crate) mod prelude;
-mod svelte;
 mod trivia;
 pub mod utils;
 mod verbatim;
diff --git a/crates/biome_html_formatter/src/svelte/auxiliary/mod.rs b/crates/biome_html_formatter/src/svelte/auxiliary/mod.rs
deleted file mode 100644
index d49ebf849888..000000000000
--- a/crates/biome_html_formatter/src/svelte/auxiliary/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
-
-pub(crate) mod text_expression;
diff --git a/crates/biome_html_formatter/src/svelte/auxiliary/text_expression.rs b/crates/biome_html_formatter/src/svelte/auxiliary/text_expression.rs
index bbc456377e04..e69de29bb2d1 100644
--- a/crates/biome_html_formatter/src/svelte/auxiliary/text_expression.rs
+++ b/crates/biome_html_formatter/src/svelte/auxiliary/text_expression.rs
@@ -1,10 +0,0 @@
-use crate::prelude::*;
-use biome_html_syntax::SvelteTextExpression;
-use biome_rowan::AstNode;
-#[derive(Debug, Clone, Default)]
-pub(crate) struct FormatSvelteTextExpression;
-impl FormatNodeRule<SvelteTextExpression> for FormatSvelteTextExpression {
-    fn fmt_fields(&self, node: &SvelteTextExpression, f: &mut HtmlFormatter) -> FormatResult<()> {
-        format_html_verbatim_node(node.syntax()).fmt(f)
-    }
-}
diff --git a/crates/biome_html_formatter/src/svelte/mod.rs b/crates/biome_html_formatter/src/svelte/mod.rs
deleted file mode 100644
index 89503df70ca9..000000000000
--- a/crates/biome_html_formatter/src/svelte/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
-
-pub(crate) mod auxiliary;
diff --git a/crates/biome_html_formatter/tests/language.rs b/crates/biome_html_formatter/tests/language.rs
index f716e9984a0e..49c37a161c5e 100644
--- a/crates/biome_html_formatter/tests/language.rs
+++ b/crates/biome_html_formatter/tests/language.rs
@@ -2,7 +2,7 @@ use biome_formatter_test::TestFormatLanguage;
 use biome_fs::BiomePath;
 use biome_html_formatter::HtmlFormatLanguage;
 use biome_html_formatter::context::HtmlFormatContext;
-use biome_html_parser::parse_html;
+use biome_html_parser::{HtmlParseOptions, parse_html};
 use biome_html_syntax::{HtmlFileSource, HtmlLanguage};
 use biome_parser::AnyParse;
 use biome_service::{
@@ -26,7 +26,7 @@ impl TestFormatLanguage for HtmlTestFormatLanguage {
     type FormatLanguage = HtmlFormatLanguage;
 
     fn parse(&self, text: &str) -> AnyParse {
-        parse_html(text, self.source_type).into()
+        parse_html(text, HtmlParseOptions::from(&self.source_type)).into()
     }
 
     fn to_format_language(
diff --git a/crates/biome_html_formatter/tests/quick_test.rs b/crates/biome_html_formatter/tests/quick_test.rs
index 938d92af271e..fae0e5bd1a7e 100644
--- a/crates/biome_html_formatter/tests/quick_test.rs
+++ b/crates/biome_html_formatter/tests/quick_test.rs
@@ -2,7 +2,7 @@ use biome_formatter::{AttributePosition, IndentStyle, LineWidth};
 use biome_formatter_test::check_reformat::CheckReformat;
 use biome_html_formatter::context::HtmlFormatOptions;
 use biome_html_formatter::{HtmlFormatLanguage, format_node};
-use biome_html_parser::parse_html;
+use biome_html_parser::{HtmlParseOptions, parse_html};
 use biome_html_syntax::HtmlFileSource;
 
 mod language {
@@ -25,7 +25,7 @@ foo bar baz boof
 quick brown fox
 "#;
     let source_type = HtmlFileSource::html();
-    let tree = parse_html(src, source_type);
+    let tree = parse_html(src, HtmlParseOptions::from(&source_type));
     let options = HtmlFormatOptions::new(HtmlFileSource::html())
         .with_indent_style(IndentStyle::Space)
         .with_line_width(LineWidth::try_from(80).unwrap())
diff --git a/crates/biome_html_formatter/tests/spec_tests.rs b/crates/biome_html_formatter/tests/spec_tests.rs
index 1e2e624a4036..3746062df367 100644
--- a/crates/biome_html_formatter/tests/spec_tests.rs
+++ b/crates/biome_html_formatter/tests/spec_tests.rs
@@ -4,6 +4,6 @@ mod spec_test;
 mod formatter {
 
     mod html {
-        tests_macros::gen_tests! {"tests/specs/html/**/*.html", crate::spec_test::run, ""}
+        tests_macros::gen_tests! {"tests/specs/html/**/*.{html,vue}", crate::spec_test::run, ""}
     }
 }
diff --git a/crates/biome_html_formatter/tests/specs/html/text_expressions/expressions.vue b/crates/biome_html_formatter/tests/specs/html/text_expressions/expressions.vue
new file mode 100644
index 000000000000..890d97a28128
--- /dev/null
+++ b/crates/biome_html_formatter/tests/specs/html/text_expressions/expressions.vue
@@ -0,0 +1,6 @@
+<template>
+	{{ x => {
+	return "hello"
+} }}
+
+</template>
diff --git a/crates/biome_html_formatter/tests/specs/html/text_expressions/expressions.vue.snap b/crates/biome_html_formatter/tests/specs/html/text_expressions/expressions.vue.snap
new file mode 100644
index 000000000000..e26b7e824664
--- /dev/null
+++ b/crates/biome_html_formatter/tests/specs/html/text_expressions/expressions.vue.snap
@@ -0,0 +1,48 @@
+---
+source: crates/biome_formatter_test/src/snapshot_builder.rs
+info: text_expressions/expressions.vue
+---
+# Input
+
+```vue
+<template>
+	{{ x => {
+	return "hello"
+} }}
+
+</template>
+
+```
+
+
+=============================
+
+# Outputs
+
+## Output 1
+
+-----
+Indent style: Tab
+Indent width: 2
+Line ending: LF
+Line width: 80
+Attribute Position: Auto
+Bracket same line: false
+Whitespace sensitivity: css
+Indent script and style: false
+Self close void elements: never
+-----
+
+```vue
+<template>
+	{{ x => {
+	return "hello"
+} }}
+</template>
+```
+
+
+
+## Unimplemented nodes/tokens
+
+" x => {\n\treturn \"hello\"\n} " => 14..40
diff --git a/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap b/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap
index b4c6dd805f1b..09ab544dce10 100644
--- a/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap
+++ b/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap
@@ -40,24 +40,143 @@ x => {
 ```diff
 --- Prettier
 +++ Biome
-@@ -4,5 +4,5 @@
-   return hello; } }} Magni consectetur in et molestias neque esse voluptatibus
-   voluptas. {{ some_variable }} Eum quia nihil nulla esse. Dolorem asperiores
-   vero est error {{ preserve invalid interpolation }} reprehenderit voluptates
+@@ -1,8 +1,26 @@
+-<!--interpolations in html should be treated as normal text-->
+-<div>
+-  Fuga magnam facilis. Voluptatem quaerat porro.{{ x => { const hello = 'world'
+-  return hello; } }} Magni consectetur in et molestias neque esse voluptatibus
+-  voluptas. {{ some_variable }} Eum quia nihil nulla esse. Dolorem asperiores
+-  vero est error {{ preserve invalid interpolation }} reprehenderit voluptates
 -  minus {{console.log( short_interpolation )}} nemo.
-+  minus {{console.log( short_interpolation ) }} nemo.
- </div>
+-</div>
++<!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
++
++
++x => {
++    const hello = 'world'
++    return hello;
++}
++
++
++
++}} Magni consectetur in et molestias neque esse voluptatibus voluptas. {{
++
++
++    some_variable
++
++
++
++}} Eum quia nihil nulla esse. Dolorem asperiores vero est error {{
++
++                    preserve
++
++                    invalid
++
++                    interpolation
++
++}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
 ```
 
 # Output
 
 ```html
-<!--interpolations in html should be treated as normal text-->
-<div>
-  Fuga magnam facilis. Voluptatem quaerat porro.{{ x => { const hello = 'world'
-  return hello; } }} Magni consectetur in et molestias neque esse voluptatibus
-  voluptas. {{ some_variable }} Eum quia nihil nulla esse. Dolorem asperiores
-  vero est error {{ preserve invalid interpolation }} reprehenderit voluptates
-  minus {{console.log( short_interpolation ) }} nemo.
-</div>
+<!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+
+
+x => {
+    const hello = 'world'
+    return hello;
+}
+
+
+
+}} Magni consectetur in et molestias neque esse voluptatibus voluptas. {{
+
+
+    some_variable
+
+
+
+}} Eum quia nihil nulla esse. Dolorem asperiores vero est error {{
+
+                    preserve
+
+                    invalid
+
+                    interpolation
+
+}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+```
+
+# Errors
+```
+example.html:1:114 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+   > 1 │ <!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+       │                                                                                                                  ^^
+   > 2 │ 
+   > 3 │ 
+   > 4 │ x => {
+        ...
+   > 9 │ 
+  > 10 │ 
+  > 11 │ }} Magni consectetur in et molestias neque esse voluptatibus voluptas. {{
+       │ ^^
+    12 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+example.html:11:72 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+  > 11 │ }} Magni consectetur in et molestias neque esse voluptatibus voluptas. {{
+       │                                                                        ^^
+  > 12 │ 
+        ...
+  > 17 │ 
+  > 18 │ }} Eum quia nihil nulla esse. Dolorem asperiores vero est error {{
+       │ ^^
+    19 │ 
+    20 │                     preserve
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+example.html:18:65 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+  > 18 │ }} Eum quia nihil nulla esse. Dolorem asperiores vero est error {{
+       │                                                                 ^^
+  > 19 │ 
+        ...
+  > 24 │                     interpolation
+  > 25 │ 
+  > 26 │ }} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+       │ ^^
+    27 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+example.html:26:35 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+    24 │                     interpolation
+    25 │ 
+  > 26 │ }} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+       │                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    27 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+
+```
+
+# Lines exceeding max width of 80 characters
+```
+    1: <!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+   26: }} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
 ```
diff --git a/crates/biome_html_parser/benches/html_parser.rs b/crates/biome_html_parser/benches/html_parser.rs
index a00e7bfbbaf7..bbfebbe68661 100644
--- a/crates/biome_html_parser/benches/html_parser.rs
+++ b/crates/biome_html_parser/benches/html_parser.rs
@@ -1,5 +1,5 @@
 use biome_diagnostics::{DiagnosticExt, print_diagnostic_to_string};
-use biome_html_parser::{parse_html, parse_html_with_cache};
+use biome_html_parser::{HtmlParseOptions, parse_html, parse_html_with_cache};
 use biome_html_syntax::HtmlFileSource;
 use biome_rowan::NodeCache;
 use biome_test_utils::BenchCase;
@@ -43,7 +43,8 @@ fn bench_parser(criterion: &mut Criterion) {
                     &code,
                     |b, _| {
                         b.iter(|| {
-                            let result = black_box(parse_html(code, file_source));
+                            let result =
+                                black_box(parse_html(code, HtmlParseOptions::from(&file_source)));
                             diagnostics.extend(result.into_diagnostics());
                         })
                     },
@@ -61,11 +62,19 @@ fn bench_parser(criterion: &mut Criterion) {
                         b.iter_batched(
                             || {
                                 let mut cache = NodeCache::default();
-                                parse_html_with_cache(code, file_source, &mut cache);
+                                parse_html_with_cache(
+                                    code,
+                                    &mut cache,
+                                    HtmlParseOptions::from(&file_source),
+                                );
                                 cache
                             },
                             |mut cache| {
-                                parse_html_with_cache(code, file_source, &mut cache);
+                                parse_html_with_cache(
+                                    code,
+                                    &mut cache,
+                                    HtmlParseOptions::from(&file_source),
+                                );
                             },
                             BatchSize::SmallInput,
                         )
diff --git a/crates/biome_html_parser/src/lexer/mod.rs b/crates/biome_html_parser/src/lexer/mod.rs
index 47189c36a844..a3173f764d9a 100644
--- a/crates/biome_html_parser/src/lexer/mod.rs
+++ b/crates/biome_html_parser/src/lexer/mod.rs
@@ -1,6 +1,6 @@
 mod tests;
 
-use crate::token_source::{HtmlEmbeddedLanguage, HtmlLexContext};
+use crate::token_source::{HtmlEmbeddedLanguage, HtmlLexContext, TextExpressionKind};
 use biome_html_syntax::HtmlSyntaxKind::{
     COMMENT, DOCTYPE_KW, EOF, ERROR_TOKEN, HTML_KW, HTML_LITERAL, HTML_STRING_LITERAL, NEWLINE,
     TOMBSTONE, UNICODE_BOM, WHITESPACE,
@@ -59,10 +59,20 @@ impl<'src> HtmlLexer<'src> {
             b'/' => self.consume_byte(T![/]),
             b'=' => self.consume_byte(T![=]),
             b'!' => self.consume_byte(T![!]),
-            b'{' if self.is_at_l_text_expression() => self.consume_l_text_expression(),
-            b'{' => self.consume_byte(T!['{']),
-            b'}' if self.is_at_r_text_expression() => self.consume_r_text_expression(),
-            b'}' => self.consume_byte(T!['}']),
+            b'{' => {
+                if self.at_opening_double_text_expression() {
+                    self.consume_l_double_text_expression()
+                } else {
+                    self.consume_byte(T!['{'])
+                }
+            }
+            b'}' => {
+                if self.at_closing_double_text_expression() {
+                    self.consume_r_double_text_expression()
+                } else {
+                    self.consume_byte(T!['}'])
+                }
+            }
             b'\'' | b'"' => self.consume_string_literal(current),
             _ if self.current_kind == T![<] && is_tag_name_byte(current) => {
                 // tag names must immediately follow a `<`
@@ -88,13 +98,23 @@ impl<'src> HtmlLexer<'src> {
     fn consume_token(&mut self, current: u8) -> HtmlSyntaxKind {
         match current {
             b'\n' | b'\r' | b'\t' | b' ' => self.consume_newline_or_whitespaces(),
-            b'{' if self.is_at_l_text_expression() => self.consume_l_text_expression(),
-            b'{' => self.consume_byte(T!['{']),
-            b'}' if self.is_at_r_text_expression() => self.consume_r_text_expression(),
-            b'}' => self.consume_byte(T!['}']),
             b'!' if self.current() == T![<] => self.consume_byte(T![!]),
             b'/' if self.current() == T![<] => self.consume_byte(T![/]),
-            b'-' if self.is_at_frontmatter_edge() => self.consume_frontmatter_edge(),
+            b'-' if self.at_frontmatter_edge() => self.consume_frontmatter_edge(),
+            b'{' => {
+                if self.at_opening_double_text_expression() {
+                    self.consume_l_double_text_expression()
+                } else {
+                    self.consume_byte(T!['{'])
+                }
+            }
+            b'}' => {
+                if self.at_closing_double_text_expression() {
+                    self.consume_r_double_text_expression()
+                } else {
+                    self.consume_byte(T!['}'])
+                }
+            }
             b'<' => {
                 // if this truly is the start of a tag, it *must* be immediately followed by a tag name. Whitespace is not allowed.
                 // https://html.spec.whatwg.org/multipage/syntax.html#start-tags
@@ -114,7 +134,7 @@ impl<'src> HtmlLexer<'src> {
                     self.consume_byte(HTML_LITERAL)
                 }
             }
-            _ => self.consume_html_text(),
+            _ => self.consume_html_text(current),
         }
     }
 
@@ -124,6 +144,8 @@ impl<'src> HtmlLexer<'src> {
             b'\n' | b'\r' | b'\t' | b' ' => self.consume_newline_or_whitespaces(),
             b'<' => self.consume_byte(T![<]),
             b'>' => self.consume_byte(T![>]),
+            b'{' => self.consume_byte(T!['{']),
+            b'}' => self.consume_byte(T!['}']),
             b'\'' | b'"' => self.consume_string_literal(current),
             _ => self.consume_unquoted_string_literal(),
         }
@@ -165,7 +187,7 @@ impl<'src> HtmlLexer<'src> {
             }
             self.advance_byte_or_char(byte);
 
-            if context == HtmlLexContext::AstroFencedCodeBlock && self.is_at_frontmatter_edge() {
+            if context == HtmlLexContext::AstroFencedCodeBlock && self.at_frontmatter_edge() {
                 return HTML_LITERAL;
             }
         }
@@ -179,6 +201,44 @@ impl<'src> HtmlLexer<'src> {
         }
     }
 
+    fn consume_double_text_expression(&mut self, current: u8) -> HtmlSyntaxKind {
+        match current {
+            b'}' if self.at_closing_double_text_expression() => {
+                self.consume_r_double_text_expression()
+            }
+            b'<' => self.consume_byte(T![<]),
+            _ => {
+                while let Some(current) = self.current_byte() {
+                    match current {
+                        b'}' if self.at_closing_double_text_expression() => break,
+                        _ => {
+                            self.advance(1);
+                        }
+                    }
+                }
+                HTML_LITERAL
+            }
+        }
+    }
+
+    fn consume_single_text_expression(&mut self, current: u8) -> HtmlSyntaxKind {
+        match current {
+            b'}' if !self.at_closing_double_text_expression() => self.consume_byte(T!['}']),
+            b'<' => self.consume_byte(T![<]),
+            _ => {
+                while let Some(current) = self.current_byte() {
+                    match current {
+                        b'}' if !self.at_closing_double_text_expression() => break,
+                        _ => {
+                            self.advance(1);
+                        }
+                    }
+                }
+                HTML_LITERAL
+            }
+        }
+    }
+
     fn consume_comment(&mut self) -> HtmlSyntaxKind {
         // eat <!--
         self.advance(4);
@@ -223,7 +283,7 @@ impl<'src> HtmlLexer<'src> {
             b'<' if self.at_start_cdata() => self.consume_cdata_start(),
             b'<' => self.consume_byte(T![<]),
             b'-' => {
-                debug_assert!(self.is_at_frontmatter_edge());
+                debug_assert!(self.at_frontmatter_edge());
                 self.advance(3);
                 T![---]
             }
@@ -429,38 +489,41 @@ impl<'src> HtmlLexer<'src> {
         }
     }
 
-    fn consume_l_text_expression(&mut self) -> HtmlSyntaxKind {
-        debug_assert!(self.is_at_l_text_expression());
+    fn consume_l_double_text_expression(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_opening_double_text_expression());
         self.advance(2);
         T!["{{"]
     }
 
-    fn consume_r_text_expression(&mut self) -> HtmlSyntaxKind {
-        debug_assert!(self.is_at_r_text_expression());
+    fn consume_r_double_text_expression(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_closing_double_text_expression());
         self.advance(2);
         T!["}}"]
     }
 
     fn consume_frontmatter_edge(&mut self) -> HtmlSyntaxKind {
-        debug_assert!(self.is_at_frontmatter_edge());
+        debug_assert!(self.at_frontmatter_edge());
         self.advance(3);
         T![---]
     }
 
-    fn at_start_comment(&mut self) -> bool {
+    #[inline(always)]
+    fn at_start_comment(&self) -> bool {
         self.current_byte() == Some(b'<')
             && self.byte_at(1) == Some(b'!')
             && self.byte_at(2) == Some(b'-')
             && self.byte_at(3) == Some(b'-')
     }
 
-    fn at_end_comment(&mut self) -> bool {
+    #[inline(always)]
+    fn at_end_comment(&self) -> bool {
         self.current_byte() == Some(b'-')
             && self.byte_at(1) == Some(b'-')
             && self.byte_at(2) == Some(b'>')
     }
 
-    fn at_start_cdata(&mut self) -> bool {
+    #[inline(always)]
+    fn at_start_cdata(&self) -> bool {
         self.current_byte() == Some(b'<')
             && self.byte_at(1) == Some(b'!')
             && self.byte_at(2) == Some(b'[')
@@ -471,24 +534,26 @@ impl<'src> HtmlLexer<'src> {
             && self.byte_at(7) == Some(b'A')
             && self.byte_at(8) == Some(b'[')
     }
-
-    fn at_end_cdata(&mut self) -> bool {
+    #[inline(always)]
+    fn at_end_cdata(&self) -> bool {
         self.current_byte() == Some(b']')
             && self.byte_at(1) == Some(b']')
             && self.byte_at(2) == Some(b'>')
     }
-
-    fn is_at_frontmatter_edge(&self) -> bool {
+    #[inline(always)]
+    fn at_frontmatter_edge(&self) -> bool {
         self.current_byte() == Some(b'-')
             && self.byte_at(1) == Some(b'-')
             && self.byte_at(2) == Some(b'-')
     }
 
-    fn is_at_l_text_expression(&self) -> bool {
+    #[inline(always)]
+    fn at_opening_double_text_expression(&self) -> bool {
         self.current_byte() == Some(b'{') && self.byte_at(1) == Some(b'{')
     }
 
-    fn is_at_r_text_expression(&self) -> bool {
+    #[inline(always)]
+    fn at_closing_double_text_expression(&self) -> bool {
         self.current_byte() == Some(b'}') && self.byte_at(1) == Some(b'}')
     }
 
@@ -571,76 +636,97 @@ impl<'src> HtmlLexer<'src> {
     ///
     /// - See: <https://html.spec.whatwg.org/#space-separated-tokens>
     /// - See: <https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace>
-    fn consume_html_text(&mut self) -> HtmlSyntaxKind {
+    fn consume_html_text(&mut self, current: u8) -> HtmlSyntaxKind {
         let mut whitespace_started = None;
         let mut seen_newlines = 0;
 
         let mut closing_expression = None;
         let mut was_escaped = false;
 
-        if self.is_at_r_text_expression() {
-            return T!["}}"];
-        }
-
-        while let Some(current) = self.current_byte() {
-            match current {
-                b'\\' => {
-                    was_escaped = true;
-                    whitespace_started = None;
-                    self.advance(1);
+        match current {
+            b'{' => {
+                if self.at_opening_double_text_expression() {
+                    self.consume_l_double_text_expression()
+                } else {
+                    self.consume_byte(T!['{'])
                 }
-                b'}' => {
-                    if was_escaped {
-                        self.advance(1);
-                    } else {
-                        if let Some(checkpoint) = closing_expression {
-                            self.rewind(checkpoint);
+            }
+            b'}' => {
+                if self.at_closing_double_text_expression() {
+                    self.consume_r_double_text_expression()
+                } else {
+                    self.consume_byte(T!['}'])
+                }
+            }
+            _ => {
+                while let Some(current) = self.current_byte() {
+                    match current {
+                        b'{' => {
+                            if was_escaped {
+                                self.advance(1);
+                            } else {
+                                break;
+                            }
+                        }
+                        b'\\' => {
+                            was_escaped = true;
+                            whitespace_started = None;
+                            self.advance(1);
+                        }
+                        b'}' => {
+                            if was_escaped {
+                                self.advance(1);
+                            } else {
+                                if let Some(checkpoint) = closing_expression {
+                                    self.rewind(checkpoint);
+                                    break;
+                                }
+                                closing_expression = Some(self.checkpoint());
+                                whitespace_started = None;
+                                self.advance(1);
+                            }
+                        }
+
+                        b'<' => {
                             break;
                         }
-                        closing_expression = Some(self.checkpoint());
-                        whitespace_started = None;
-                        self.advance(1);
+                        b'\n' | b'\r' => {
+                            if whitespace_started.is_none() {
+                                whitespace_started = Some(self.checkpoint());
+                            }
+                            self.after_newline = true;
+                            seen_newlines += 1;
+                            if seen_newlines > 1 {
+                                break;
+                            }
+                            self.advance(1);
+                        }
+                        b' ' | b'\t' => {
+                            if was_escaped {
+                                was_escaped = false;
+                            }
+                            if whitespace_started.is_none() {
+                                whitespace_started = Some(self.checkpoint());
+                            }
+                            closing_expression = None;
+                            self.advance(1);
+                        }
+                        _ => {
+                            self.advance(1);
+                            whitespace_started = None;
+                            seen_newlines = 0;
+                        }
                     }
                 }
 
-                b'<' => {
-                    break;
+                if let Some(checkpoint) = whitespace_started {
+                    // avoid treating the trailing whitespace as part of the token if there is any
+                    self.rewind(checkpoint);
                 }
-                b'\n' | b'\r' => {
-                    if whitespace_started.is_none() {
-                        whitespace_started = Some(self.checkpoint());
-                    }
-                    self.after_newline = true;
-                    seen_newlines += 1;
-                    if seen_newlines > 1 {
-                        break;
-                    }
-                    self.advance(1);
-                }
-                b' ' | b'\t' => {
-                    if was_escaped {
-                        was_escaped = false;
-                    }
-                    if whitespace_started.is_none() {
-                        whitespace_started = Some(self.checkpoint());
-                    }
-                    closing_expression = None;
-                    self.advance(1);
-                }
-                _ => {
-                    self.advance(1);
-                    whitespace_started = None;
-                    seen_newlines = 0;
-                }
-            }
-        }
 
-        if let Some(checkpoint) = whitespace_started {
-            // avoid treating the trailing whitespace as part of the token if there is any
-            self.rewind(checkpoint);
+                HTML_LITERAL
+            }
         }
-
-        HTML_LITERAL
     }
 }
 
@@ -679,6 +765,10 @@ impl<'src> Lexer<'src> for HtmlLexer<'src> {
                     HtmlLexContext::EmbeddedLanguage(lang) => {
                         self.consume_token_embedded_language(current, lang, context)
                     }
+                    HtmlLexContext::TextExpression(kind) => match kind {
+                        TextExpressionKind::Double => self.consume_double_text_expression(current),
+                        TextExpressionKind::Single => self.consume_single_text_expression(current),
+                    },
                     HtmlLexContext::CdataSection => self.consume_inside_cdata(current),
                     HtmlLexContext::AstroFencedCodeBlock => {
                         self.consume_astro_frontmatter(current, context)
diff --git a/crates/biome_html_parser/src/lib.rs b/crates/biome_html_parser/src/lib.rs
index da24b02bc44c..e1fc03939328 100644
--- a/crates/biome_html_parser/src/lib.rs
+++ b/crates/biome_html_parser/src/lib.rs
@@ -5,9 +5,11 @@ mod parser;
 mod syntax;
 mod token_source;
 
+pub use parser::HtmlParseOptions;
+
 use crate::parser::{HtmlLosslessTreeSink, HtmlParser};
 use crate::syntax::parse_root;
-use biome_html_syntax::{HtmlFileSource, HtmlRoot, HtmlSyntaxNode};
+use biome_html_syntax::{HtmlRoot, HtmlSyntaxNode};
 use biome_parser::AnyParse;
 use biome_parser::diagnostic::ParseDiagnostic;
 use biome_rowan::{AstNode, NodeCache};
@@ -15,10 +17,10 @@ use biome_rowan::{AstNode, NodeCache};
 /// Parses the provided string as HTML program using the provided node cache.
 pub fn parse_html_with_cache(
     source: &str,
-    file_source: HtmlFileSource,
     cache: &mut NodeCache,
+    options: HtmlParseOptions,
 ) -> HtmlParse {
-    let mut parser = HtmlParser::new(source, file_source);
+    let mut parser = HtmlParser::new(source, options);
 
     parse_root(&mut parser);
 
@@ -30,9 +32,11 @@ pub fn parse_html_with_cache(
 
     HtmlParse::new(green, diagnostics)
 }
-pub fn parse_html(source: &str, file_source: HtmlFileSource) -> HtmlParse {
+
+/// Parses an HTML code with the provided options
+pub fn parse_html(source: &str, options: HtmlParseOptions) -> HtmlParse {
     let mut cache = NodeCache::default();
-    parse_html_with_cache(source, file_source, &mut cache)
+    parse_html_with_cache(source, &mut cache, options)
 }
 
 /// A utility struct for managing the result of a parser job
diff --git a/crates/biome_html_parser/src/parser.rs b/crates/biome_html_parser/src/parser.rs
index c4073207ede8..e6b9ad3548be 100644
--- a/crates/biome_html_parser/src/parser.rs
+++ b/crates/biome_html_parser/src/parser.rs
@@ -1,11 +1,13 @@
-use crate::token_source::HtmlTokenSource;
+use crate::token_source::{HtmlTokenSource, HtmlTokenSourceCheckpoint, TextExpressionKind};
 use biome_html_factory::HtmlSyntaxFactory;
-use biome_html_syntax::{HtmlFileSource, HtmlLanguage, HtmlSyntaxKind};
+use biome_html_syntax::{
+    HtmlFileSource, HtmlLanguage, HtmlSyntaxKind, HtmlTextExpressions, HtmlVariant,
+};
 use biome_parser::diagnostic::{ParseDiagnostic, merge_diagnostics};
 use biome_parser::event::Event;
 use biome_parser::prelude::*;
 use biome_parser::tree_sink::LosslessTreeSink;
-use biome_parser::{Parser, ParserContext};
+use biome_parser::{Parser, ParserContext, ParserContextCheckpoint};
 
 pub(crate) type HtmlLosslessTreeSink<'source> =
     LosslessTreeSink<'source, HtmlLanguage, HtmlSyntaxFactory>;
@@ -13,20 +15,20 @@ pub(crate) type HtmlLosslessTreeSink<'source> =
 pub(crate) struct HtmlParser<'source> {
     context: ParserContext<HtmlSyntaxKind>,
     source: HtmlTokenSource<'source>,
-    file_source: HtmlFileSource,
+    options: HtmlParseOptions,
 }
 
 impl<'source> HtmlParser<'source> {
-    pub fn new(source: &'source str, file_source: HtmlFileSource) -> Self {
+    pub fn new(source: &'source str, options: HtmlParseOptions) -> Self {
         Self {
             context: ParserContext::default(),
             source: HtmlTokenSource::from_str(source),
-            file_source,
+            options,
         }
     }
 
-    pub(crate) fn file_source(&self) -> &HtmlFileSource {
-        &self.file_source
+    pub(crate) fn options(&self) -> &HtmlParseOptions {
+        &self.options
     }
 
     pub fn finish(
@@ -43,6 +45,34 @@ impl<'source> HtmlParser<'source> {
 
         (events, diagnostics, trivia)
     }
+
+    pub(crate) fn checkpoint(&mut self) -> HtmlParserCheckpoint {
+        HtmlParserCheckpoint {
+            context: self.context.checkpoint(),
+            source: self.source.checkpoint(),
+            // `state` is not checkpointed because it (currently) only contains
+            // scoped properties that aren't only dependent on checkpoints and
+            // should be reset manually when the scope of their use is exited.
+        }
+    }
+
+    pub fn rewind(&mut self, checkpoint: HtmlParserCheckpoint) {
+        let HtmlParserCheckpoint { context, source } = checkpoint;
+
+        self.context.rewind(context);
+        self.source.rewind(source);
+        // `state` is not checkpointed because it (currently) only contains
+        // scoped properties that aren't only dependent on checkpoints and
+        // should be reset manually when the scope of their use is exited.
+    }
+}
+
+pub struct HtmlParserCheckpoint {
+    pub(super) context: ParserContextCheckpoint,
+    pub(super) source: HtmlTokenSourceCheckpoint,
+    // `state` is not checkpointed because it (currently) only contains
+    // scoped properties that aren't only dependent on checkpoints and
+    // should be reset manually when the scope of their use is exited.
 }
 
 impl<'src> Parser for HtmlParser<'src> {
@@ -65,3 +95,55 @@ impl<'src> Parser for HtmlParser<'src> {
         &mut self.source
     }
 }
+
+#[derive(Default, Debug)]
+pub struct HtmlParseOptions {
+    pub(crate) frontmatter: bool,
+    pub(crate) text_expression: Option<TextExpressionKind>,
+}
+
+impl HtmlParseOptions {
+    pub fn with_single_text_expression(mut self) -> Self {
+        self.text_expression = Some(TextExpressionKind::Single);
+        self
+    }
+
+    pub fn with_double_text_expression(mut self) -> Self {
+        self.text_expression = Some(TextExpressionKind::Double);
+        self
+    }
+
+    pub fn with_frontmatter(mut self) -> Self {
+        self.frontmatter = true;
+        self
+    }
+}
+
+impl From<&HtmlFileSource> for HtmlParseOptions {
+    fn from(file_source: &HtmlFileSource) -> Self {
+        let mut options = Self::default();
+
+        match file_source.variant() {
+            HtmlVariant::Standard(text_expressions) => match text_expressions {
+                HtmlTextExpressions::Single => {
+                    options = options.with_single_text_expression();
+                }
+                HtmlTextExpressions::Double => {
+                    options = options.with_double_text_expression();
+                }
+                HtmlTextExpressions::None => {}
+            },
+            HtmlVariant::Astro => {
+                options = options.with_single_text_expression().with_frontmatter();
+            }
+            HtmlVariant::Vue => {
+                options = options.with_double_text_expression();
+            }
+            HtmlVariant::Svelte => {
+                options = options.with_single_text_expression();
+            }
+        }
+
+        options
+    }
+}
diff --git a/crates/biome_html_parser/src/syntax/mod.rs b/crates/biome_html_parser/src/syntax/mod.rs
index ca828b5530e3..343db9d12479 100644
--- a/crates/biome_html_parser/src/syntax/mod.rs
+++ b/crates/biome_html_parser/src/syntax/mod.rs
@@ -4,10 +4,9 @@ mod parse_error;
 use crate::parser::HtmlParser;
 use crate::syntax::astro::parse_astro_fence;
 use crate::syntax::parse_error::*;
-use crate::token_source::{HtmlEmbeddedLanguage, HtmlLexContext};
-use biome_console::markup;
+use crate::token_source::{HtmlEmbeddedLanguage, HtmlLexContext, TextExpressionKind};
 use biome_html_syntax::HtmlSyntaxKind::*;
-use biome_html_syntax::{HtmlSyntaxKind, HtmlVariant, T};
+use biome_html_syntax::{HtmlSyntaxKind, T};
 use biome_parser::Parser;
 use biome_parser::parse_lists::ParseNodeList;
 use biome_parser::parse_recovery::{ParseRecoveryTokenSet, RecoveryResult};
@@ -16,10 +15,12 @@ use biome_parser::prelude::ParsedSyntax::Absent;
 use biome_parser::prelude::*;
 
 pub(crate) enum HtmlSyntaxFeatures {
-    /// Exclusive to those documents that support front matter at the top of the file
-    Frontmatter,
-    /// Exclusive to those documents that support text expressions
-    TextExpressions,
+    /// Exclusive to those documents that support Astro
+    Astro,
+    /// Exclusive to those documents that support text expressions with {{ }}
+    DoubleTextExpressions,
+    /// Exclusive to those documents that support text expressions with { }
+    SingleTextExpressions,
 }
 
 impl SyntaxFeature for HtmlSyntaxFeatures {
@@ -27,16 +28,20 @@ impl SyntaxFeature for HtmlSyntaxFeatures {
 
     fn is_supported(&self, p: &HtmlParser) -> bool {
         match self {
-            Self::Frontmatter => p.file_source().is_astro(),
-            Self::TextExpressions => match p.file_source().variant() {
-                HtmlVariant::Standard | HtmlVariant::Astro | HtmlVariant::Svelte => false,
-                HtmlVariant::Vue => true,
-            },
+            Self::Astro => p.options().frontmatter,
+            Self::DoubleTextExpressions => {
+                p.options().text_expression == Some(TextExpressionKind::Double)
+            }
+            Self::SingleTextExpressions => {
+                p.options().text_expression == Some(TextExpressionKind::Single)
+            }
         }
     }
 }
 
 const RECOVER_ATTRIBUTE_LIST: TokenSet<HtmlSyntaxKind> = token_set!(T![>], T![<], T![/]);
+const RECOVER_TEXT_EXPRESSION_LIST: TokenSet<HtmlSyntaxKind> =
+    token_set!(T![<], T![>], T!['}'], T!["}}"]);
 
 /// These elements are effectively always self-closing. They should not have a closing tag (if they do, it should be a parsing error). They might not contain a `/` like in `<img />`.
 static VOID_ELEMENTS: &[&str] = &[
@@ -53,7 +58,7 @@ pub(crate) fn parse_root(p: &mut HtmlParser) {
     p.eat(UNICODE_BOM);
 
     if p.at(T![---]) {
-        HtmlSyntaxFeatures::Frontmatter
+        HtmlSyntaxFeatures::Astro
             .parse_exclusive_syntax(
                 p,
                 |p| parse_astro_fence(p),
@@ -187,7 +192,7 @@ fn parse_closing_tag(p: &mut HtmlParser) -> ParsedSyntax {
         p.error(closing_tag_should_not_have_attributes(p, p.cur_range()));
         p.bump_remap_with_context(HTML_BOGUS, HtmlLexContext::InsideTag);
     }
-    p.bump_with_context(T![>], HtmlLexContext::Regular);
+    p.expect(T![>]);
     Present(m.complete(p, HTML_CLOSING_ELEMENT))
 }
 
@@ -203,17 +208,22 @@ impl ParseNodeList for ElementList {
         match p.cur() {
             T!["<![CDATA["] => parse_cdata_section(p),
             T![<] => parse_element(p),
-            T!["{{"] => parse_text_expression(p).or_else(|| {
+            T!["{{"] => HtmlSyntaxFeatures::DoubleTextExpressions.parse_exclusive_syntax(
+                p,
+                |p| parse_double_text_expression(p, HtmlLexContext::Regular),
+                |p, m| disabled_interpolation(p, m.range(p)),
+            ),
+            T!['{'] => parse_single_text_expression(p, HtmlLexContext::Regular).or_else(|| {
                 let m = p.start();
-                p.bump_remap_with_context(HTML_LITERAL, HtmlLexContext::InsideTag);
+                p.bump_remap(HTML_LITERAL);
                 Present(m.complete(p, HTML_CONTENT))
             }),
-            T!["}}"] => {
+            T!["}}"] | T!['}'] => {
                 // The closing text expression should be handled by other functions.
                 // If we're here, we assume that text expressions are enabled and
                 // we remap to HTML_LITERAL
                 let m = p.start();
-                p.bump_remap_with_context(HTML_LITERAL, HtmlLexContext::InsideTag);
+                p.bump_remap(HTML_LITERAL);
                 Present(m.complete(p, HTML_CONTENT))
             }
             HTML_LITERAL => {
@@ -254,7 +264,6 @@ impl ParseNodeList for AttributeList {
     const LIST_KIND: Self::Kind = HTML_ATTRIBUTE_LIST;
 
     fn parse_element(&mut self, p: &mut Self::Parser<'_>) -> ParsedSyntax {
-        // Absent
         parse_attribute(p)
     }
 
@@ -279,18 +288,31 @@ fn parse_attribute(p: &mut HtmlParser) -> ParsedSyntax {
     if !is_at_attribute_start(p) {
         return Absent;
     }
+
     let m = p.start();
-    parse_literal(p, HTML_ATTRIBUTE_NAME).or_add_diagnostic(p, expected_attribute);
-    if p.at(T![=]) {
-        parse_attribute_initializer(p).ok();
+    if p.at(T!["{{"]) {
+        HtmlSyntaxFeatures::DoubleTextExpressions
+            .parse_exclusive_syntax(
+                p,
+                |p| parse_double_text_expression(p, HtmlLexContext::InsideTag),
+                |p, marker| disabled_interpolation(p, marker.range(p)),
+            )
+            .ok();
+
         Present(m.complete(p, HTML_ATTRIBUTE))
     } else {
-        Present(m.complete(p, HTML_ATTRIBUTE))
+        parse_literal(p, HTML_ATTRIBUTE_NAME).or_add_diagnostic(p, expected_attribute);
+        if p.at(T![=]) {
+            parse_attribute_initializer(p).ok();
+            Present(m.complete(p, HTML_ATTRIBUTE))
+        } else {
+            Present(m.complete(p, HTML_ATTRIBUTE))
+        }
     }
 }
 
 fn is_at_attribute_start(p: &mut HtmlParser) -> bool {
-    p.at(HTML_LITERAL) || p.at(T!["{{"]) || p.at(T!["}}"])
+    p.at(HTML_LITERAL) || p.at(T!["{{"]) || p.at(T!['{'])
 }
 
 fn parse_literal(p: &mut HtmlParser, kind: HtmlSyntaxKind) -> ParsedSyntax {
@@ -300,8 +322,8 @@ fn parse_literal(p: &mut HtmlParser, kind: HtmlSyntaxKind) -> ParsedSyntax {
     let m = p.start();
 
     if p.at(T!["{{"]) {
-        if HtmlSyntaxFeatures::TextExpressions.is_supported(p) {
-            parse_text_expression(p).ok();
+        if HtmlSyntaxFeatures::DoubleTextExpressions.is_supported(p) {
+            parse_double_text_expression(p, HtmlLexContext::Regular).ok();
         } else {
             p.bump_remap_with_context(
                 HTML_LITERAL,
@@ -353,7 +375,41 @@ fn parse_attribute_initializer(p: &mut HtmlParser) -> ParsedSyntax {
     }
     let m = p.start();
     p.bump_with_context(T![=], HtmlLexContext::AttributeValue);
-    parse_attribute_string_literal(p).or_add_diagnostic(p, expected_initializer);
+    if p.at(T!['{']) {
+        HtmlSyntaxFeatures::SingleTextExpressions
+            .parse_exclusive_syntax(
+                p,
+                |p| parse_single_text_expression(p, HtmlLexContext::InsideTag),
+                |p, m| {
+                    p.err_builder("Expressions are only valid inside Astro files.", m.range(p))
+                        .with_hint("Remove it or rename the file to have the .astro extension.")
+                },
+            )
+            .or_recover_with_token_set(
+                p,
+                &ParseRecoveryTokenSet::new(HTML_BOGUS_TEXT_EXPRESSION, RECOVER_ATTRIBUTE_LIST),
+                expected_attribute,
+            )
+            .ok();
+    } else if p.at(T!["{{"]) {
+        HtmlSyntaxFeatures::DoubleTextExpressions
+            .parse_exclusive_syntax(
+                p,
+                |p| parse_double_text_expression(p, HtmlLexContext::InsideTag),
+                |p, m| {
+                    p.err_builder("Text expressions aren't supported.", m.range(p))
+                        .with_hint("Remove it or add the option.")
+                },
+            )
+            .or_recover_with_token_set(
+                p,
+                &ParseRecoveryTokenSet::new(HTML_BOGUS_TEXT_EXPRESSION, RECOVER_ATTRIBUTE_LIST),
+                expected_attribute,
+            )
+            .ok();
+    } else {
+        parse_attribute_string_literal(p).or_add_diagnostic(p, expected_initializer);
+    }
     Present(m.complete(p, HTML_ATTRIBUTE_INITIALIZER_CLAUSE))
 }
 
@@ -375,32 +431,141 @@ fn parse_cdata_section(p: &mut HtmlParser) -> ParsedSyntax {
 /// ```vue
 /// {{ expression }}
 /// ```
-fn parse_text_expression(p: &mut HtmlParser) -> ParsedSyntax {
-    if !HtmlSyntaxFeatures::TextExpressions.is_supported(p) {
+fn parse_double_text_expression(p: &mut HtmlParser, context: HtmlLexContext) -> ParsedSyntax {
+    if !is_at_opening_double_expression(p) {
+        return Absent;
+    }
+    let checkpoint = p.checkpoint();
+    let m = p.start();
+    let opening_range = p.cur_range();
+    p.bump_with_context(
+        T!["{{"],
+        HtmlLexContext::TextExpression(TextExpressionKind::Double),
+    );
+
+    TextExpression::new_double().parse_element(p).ok();
+
+    if p.at(T!["}}"]) {
+        p.expect_with_context(T!["}}"], context);
+        Present(m.complete(p, HTML_DOUBLE_TEXT_EXPRESSION))
+    } else if p.at(T![<]) {
+        let diagnostic = expected_text_expression(p, p.cur_range(), opening_range);
+        p.error(diagnostic);
+        Present(m.complete(p, HTML_BOGUS_TEXT_EXPRESSION))
+    } else {
+        m.abandon(p);
+        p.rewind(checkpoint);
+
+        let recovery =
+            ParseRecoveryTokenSet::new(HTML_BOGUS_TEXT_EXPRESSION, RECOVER_TEXT_EXPRESSION_LIST);
+        if let Ok(m) = recovery.enable_recovery_on_line_break().recover(p) {
+            let diagnostic = expected_text_expression(p, m.range(p), opening_range);
+            p.error(diagnostic);
+            return Present(m);
+        } else {
+            Absent
+        }
+    }
+}
+
+pub(crate) fn is_at_opening_double_expression(p: &mut HtmlParser) -> bool {
+    p.at(T!["{{"])
+}
+
+// Parsers a single tag expression. `context` is applied after lexing the last token `}`
+pub(crate) fn parse_single_text_expression(
+    p: &mut HtmlParser,
+    context: HtmlLexContext,
+) -> ParsedSyntax {
+    if !HtmlSyntaxFeatures::SingleTextExpressions.is_supported(p) {
         return Absent;
     }
-    if !is_at_l_text_expression(p) {
+
+    if !p.at(T!['{']) {
         return Absent;
     }
+    let checkpoint = p.checkpoint();
     let m = p.start();
-    let range = p.cur_range();
-    p.bump(T!["{{"]);
+    let opening_range = p.cur_range();
+
+    p.bump_with_context(
+        T!['{'],
+        HtmlLexContext::TextExpression(TextExpressionKind::Single),
+    );
+
+    TextExpression::new_single().parse_element(p).ok();
+
+    if p.at(T!['}']) {
+        p.bump_remap_with_context(T!['}'], context);
+        Present(m.complete(p, HTML_SINGLE_TEXT_EXPRESSION))
+    } else if p.at(T![<]) {
+        let diagnostic = expected_text_expression(p, p.cur_range(), opening_range);
+        p.error(diagnostic);
+        Present(m.complete(p, HTML_BOGUS_TEXT_EXPRESSION))
+    } else {
+        m.abandon(p);
+        p.rewind(checkpoint);
+        let recovery =
+            ParseRecoveryTokenSet::new(HTML_BOGUS_TEXT_EXPRESSION, RECOVER_TEXT_EXPRESSION_LIST);
+        if let Ok(m) = recovery.enable_recovery_on_line_break().recover(p) {
+            let diagnostic = expected_text_expression(p, m.range(p), opening_range);
+            p.error(diagnostic);
+            Present(m)
+        } else {
+            Absent
+        }
+    }
+}
 
-    while p.at(HTML_LITERAL) {
-        p.bump(HTML_LITERAL);
+struct TextExpression {
+    kind: TextExpressionKind,
+}
+
+impl TextExpression {
+    pub fn new_single() -> Self {
+        Self {
+            kind: TextExpressionKind::Single,
+        }
     }
-    if p.at(T![<]) && !p.at(EOF) {
-        p.error(
-            p.err_builder(markup!("Found a text expression that doesn't have the closing "<Emphasis>"}}"</Emphasis>), p.cur_range())
-                .with_detail(range, "This is where the opening expression was found:"),
-        );
-        m.abandon(p);
-        return Absent;
+
+    pub fn new_double() -> Self {
+        Self {
+            kind: TextExpressionKind::Double,
+        }
     }
-    p.expect(T!["}}"]);
-    Present(m.complete(p, HTML_TEXT_EXPRESSION))
 }
 
-pub(crate) fn is_at_l_text_expression(p: &mut HtmlParser) -> bool {
-    p.at(T!["{{"])
+impl TextExpression {
+    fn parse_element(&mut self, p: &mut HtmlParser) -> ParsedSyntax {
+        if p.at(EOF) || p.at(T![<]) {
+            return Absent;
+        }
+
+        let m = p.start();
+
+        match self.kind {
+            TextExpressionKind::Single => {
+                if p.at(T!["}}"]) {
+                    p.bump_remap_with_context(
+                        HTML_LITERAL,
+                        HtmlLexContext::TextExpression(self.kind),
+                    );
+                } else {
+                    p.bump_remap_any_with_context(HtmlLexContext::TextExpression(self.kind));
+                }
+            }
+            TextExpressionKind::Double => {
+                if p.at(T!['}']) {
+                    p.bump_remap_with_context(
+                        HTML_LITERAL,
+                        HtmlLexContext::TextExpression(self.kind),
+                    )
+                } else {
+                    p.bump_remap_any_with_context(HtmlLexContext::TextExpression(self.kind))
+                }
+            }
+        }
+
+        Present(m.complete(p, HTML_TEXT_EXPRESSION))
+    }
 }
diff --git a/crates/biome_html_parser/src/syntax/parse_error.rs b/crates/biome_html_parser/src/syntax/parse_error.rs
index 5a03383fe4fd..ff22fddbebe6 100644
--- a/crates/biome_html_parser/src/syntax/parse_error.rs
+++ b/crates/biome_html_parser/src/syntax/parse_error.rs
@@ -1,5 +1,7 @@
 use crate::parser::HtmlParser;
+use biome_console::markup;
 use biome_html_syntax::TextRange;
+use biome_parser::Parser;
 use biome_parser::diagnostic::{ParseDiagnostic, expect_one_of, expected_node};
 use biome_parser::prelude::ToDiagnostic;
 
@@ -7,6 +9,25 @@ pub(crate) fn expected_attribute(p: &HtmlParser, range: TextRange) -> ParseDiagn
     expected_node("attribute", range, p).into_diagnostic(p)
 }
 
+pub(crate) fn disabled_interpolation(p: &HtmlParser, range: TextRange) -> ParseDiagnostic {
+    p.err_builder("Text expressions aren't supported.", range).with_hint(markup!("Remove it or enable the parsing using the "<Emphasis>"html.parser.textExpression"</Emphasis>" option."))
+}
+
+pub(crate) fn expected_text_expression(
+    p: &HtmlParser,
+    curr_range: TextRange,
+    opening_range: TextRange,
+) -> ParseDiagnostic {
+    p.err_builder(
+        "Found a text expression that doesn't have the closing expression:",
+        curr_range,
+    )
+    .with_detail(
+        opening_range,
+        "This is where the opening expression was found:",
+    )
+}
+
 pub(crate) fn expected_child(p: &HtmlParser, range: TextRange) -> ParseDiagnostic {
     expect_one_of(&["element", "text"], range).into_diagnostic(p)
 }
diff --git a/crates/biome_html_parser/src/token_source.rs b/crates/biome_html_parser/src/token_source.rs
index fffa2145235b..f4e9b2db2ea0 100644
--- a/crates/biome_html_parser/src/token_source.rs
+++ b/crates/biome_html_parser/src/token_source.rs
@@ -4,7 +4,9 @@ use biome_html_syntax::{HtmlSyntaxKind, TextRange};
 use biome_parser::diagnostic::ParseDiagnostic;
 use biome_parser::lexer::{BufferedLexer, LexContext};
 use biome_parser::prelude::BumpWithContext;
-use biome_parser::token_source::{TokenSource, TokenSourceWithBufferedLexer, Trivia};
+use biome_parser::token_source::{
+    TokenSource, TokenSourceCheckpoint, TokenSourceWithBufferedLexer, Trivia,
+};
 use biome_rowan::TriviaPieceKind;
 
 pub(crate) struct HtmlTokenSource<'source> {
@@ -20,7 +22,7 @@ pub(crate) enum HtmlLexContext {
     ///
     /// When the lexer is outside of a tag, special characters are lexed as text.
     ///
-    /// The exeptions being `<` which indicates the start of a tag, and `>` which is invalid syntax if not preceeded with a `<`.
+    /// The exceptions being `<` which indicates the start of a tag, and `>` which is invalid syntax if not preceeded with a `<`.
     #[default]
     Regular,
     /// When the lexer is inside a tag, special characters are lexed as tag tokens.
@@ -29,6 +31,11 @@ pub(crate) enum HtmlLexContext {
     ///
     /// This is because attribute values can start and end with a `"` or `'` character, or be unquoted, and the lexer needs to know to start lexing a string literal.
     AttributeValue,
+
+    /// Lex tokens inside text expressions. In the following examples, `foo` is the text expression:
+    /// - `{{ foo }}`
+    /// - `attr={ foo }`
+    TextExpression(TextExpressionKind),
     /// Enables the `html` keyword token.
     ///
     /// When the parser has encounters the sequence `<!DOCTYPE`, it switches to this context. It will remain in this context until the next `>` token is encountered.
@@ -37,10 +44,20 @@ pub(crate) enum HtmlLexContext {
     EmbeddedLanguage(HtmlEmbeddedLanguage),
     /// CDATA Sections are treated as text until the closing CDATA token is encountered.
     CdataSection,
-    /// Lexing the Astro frontmatter
+    /// Lexing the Astro frontmatter. When in this context, the lexer will treat `---`
+    /// as a boundary for `HTML_LITERAL`
     AstroFencedCodeBlock,
 }
 
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub(crate) enum TextExpressionKind {
+    // {{ expr }}
+    #[default]
+    Double,
+    // { expr }
+    Single,
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub(crate) enum HtmlEmbeddedLanguage {
     Script,
@@ -64,6 +81,8 @@ impl LexContext for HtmlLexContext {
     }
 }
 
+pub(crate) type HtmlTokenSourceCheckpoint = TokenSourceCheckpoint<HtmlSyntaxKind>;
+
 impl<'source> HtmlTokenSource<'source> {
     /// Creates a new token source for the given string
     pub fn from_str(source: &'source str) -> Self {
@@ -108,6 +127,21 @@ impl<'source> HtmlTokenSource<'source> {
             }
         }
     }
+
+    /// Creates a checkpoint to which it can later return using [Self::rewind].
+    pub fn checkpoint(&self) -> HtmlTokenSourceCheckpoint {
+        HtmlTokenSourceCheckpoint {
+            trivia_len: self.trivia_list.len() as u32,
+            lexer_checkpoint: self.lexer.checkpoint(),
+        }
+    }
+
+    /// Restores the token source to a previous state
+    pub fn rewind(&mut self, checkpoint: HtmlTokenSourceCheckpoint) {
+        assert!(self.trivia_list.len() >= checkpoint.trivia_len as usize);
+        self.trivia_list.truncate(checkpoint.trivia_len as usize);
+        self.lexer.rewind(checkpoint.lexer_checkpoint);
+    }
 }
 
 impl TokenSource for HtmlTokenSource<'_> {
diff --git a/crates/biome_html_parser/tests/html_specs/error/astro/attribute_expression.astro b/crates/biome_html_parser/tests/html_specs/error/astro/attribute_expression.astro
new file mode 100644
index 000000000000..b83c89077cd9
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/astro/attribute_expression.astro
@@ -0,0 +1,6 @@
+---
+const foo = "lorem ipsum";
+---
+<html>
+<span id={foo></span>
+</html>
diff --git a/crates/biome_html_parser/tests/html_specs/error/astro/attribute_expression.astro.snap b/crates/biome_html_parser/tests/html_specs/error/astro/attribute_expression.astro.snap
new file mode 100644
index 000000000000..a371d16ed40f
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/astro/attribute_expression.astro.snap
@@ -0,0 +1,187 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```astro
+---
+const foo = "lorem ipsum";
+---
+<html>
+<span id={foo></span>
+</html>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: AstroFrontmatterElement {
+        l_fence_token: FENCE@0..3 "---" [] [],
+        content_token: HTML_LITERAL@3..31 "const foo = \"lorem ipsum\";\n" [Newline("\n")] [],
+        r_fence_token: FENCE@31..34 "---" [] [],
+    },
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@34..36 "<" [Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@36..40 "html" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@40..41 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@41..43 "<" [Newline("\n")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@43..48 "span" [] [Whitespace(" ")],
+                        },
+                        attributes: HtmlAttributeList [
+                            HtmlBogusAttribute {
+                                items: [
+                                    HtmlAttributeName {
+                                        value_token: HTML_LITERAL@48..50 "id" [] [],
+                                    },
+                                    HtmlBogus {
+                                        items: [
+                                            EQ@50..51 "=" [] [],
+                                            HtmlBogusTextExpression {
+                                                items: [
+                                                    L_CURLY@51..52 "{" [] [],
+                                                    HTML_LITERAL@52..56 "foo>" [] [],
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                        r_angle_token: missing (required),
+                    },
+                    children: HtmlElementList [],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@56..57 "<" [] [],
+                        slash_token: SLASH@57..58 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@58..62 "span" [] [],
+                        },
+                        r_angle_token: R_ANGLE@62..63 ">" [] [],
+                    },
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@63..65 "<" [Newline("\n")] [],
+                slash_token: SLASH@65..66 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@66..70 "html" [] [],
+                },
+                r_angle_token: R_ANGLE@70..71 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@71..72 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..72
+  0: (empty)
+  1: ASTRO_FRONTMATTER_ELEMENT@0..34
+    0: FENCE@0..3 "---" [] []
+    1: HTML_LITERAL@3..31 "const foo = \"lorem ipsum\";\n" [Newline("\n")] []
+    2: FENCE@31..34 "---" [] []
+  2: (empty)
+  3: HTML_ELEMENT_LIST@34..71
+    0: HTML_ELEMENT@34..71
+      0: HTML_OPENING_ELEMENT@34..41
+        0: L_ANGLE@34..36 "<" [Newline("\n")] []
+        1: HTML_TAG_NAME@36..40
+          0: HTML_LITERAL@36..40 "html" [] []
+        2: HTML_ATTRIBUTE_LIST@40..40
+        3: R_ANGLE@40..41 ">" [] []
+      1: HTML_ELEMENT_LIST@41..63
+        0: HTML_ELEMENT@41..63
+          0: HTML_OPENING_ELEMENT@41..56
+            0: L_ANGLE@41..43 "<" [Newline("\n")] []
+            1: HTML_TAG_NAME@43..48
+              0: HTML_LITERAL@43..48 "span" [] [Whitespace(" ")]
+            2: HTML_ATTRIBUTE_LIST@48..56
+              0: HTML_BOGUS_ATTRIBUTE@48..56
+                0: HTML_ATTRIBUTE_NAME@48..50
+                  0: HTML_LITERAL@48..50 "id" [] []
+                1: HTML_BOGUS@50..56
+                  0: EQ@50..51 "=" [] []
+                  1: HTML_BOGUS_TEXT_EXPRESSION@51..56
+                    0: L_CURLY@51..52 "{" [] []
+                    1: HTML_LITERAL@52..56 "foo>" [] []
+            3: (empty)
+          1: HTML_ELEMENT_LIST@56..56
+          2: HTML_CLOSING_ELEMENT@56..63
+            0: L_ANGLE@56..57 "<" [] []
+            1: SLASH@57..58 "/" [] []
+            2: HTML_TAG_NAME@58..62
+              0: HTML_LITERAL@58..62 "span" [] []
+            3: R_ANGLE@62..63 ">" [] []
+      2: HTML_CLOSING_ELEMENT@63..71
+        0: L_ANGLE@63..65 "<" [Newline("\n")] []
+        1: SLASH@65..66 "/" [] []
+        2: HTML_TAG_NAME@66..70
+          0: HTML_LITERAL@66..70 "html" [] []
+        3: R_ANGLE@70..71 ">" [] []
+  4: EOF@71..72 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+attribute_expression.astro:5:10 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Found a text expression that doesn't have the closing expression:
+  
+    3 │ ---
+    4 │ <html>
+  > 5 │ <span id={foo></span>
+      │          ^^^^^
+    6 │ </html>
+    7 │ 
+  
+  i This is where the opening expression was found:
+  
+    3 │ ---
+    4 │ <html>
+  > 5 │ <span id={foo></span>
+      │          ^
+    6 │ </html>
+    7 │ 
+  
+attribute_expression.astro:5:15 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected an attribute but instead found '<'.
+  
+    3 │ ---
+    4 │ <html>
+  > 5 │ <span id={foo></span>
+      │               ^
+    6 │ </html>
+    7 │ 
+  
+  i Expected an attribute here.
+  
+    3 │ ---
+    4 │ <html>
+  > 5 │ <span id={foo></span>
+      │               ^
+    6 │ </html>
+    7 │ 
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/interpolation.html b/crates/biome_html_parser/tests/html_specs/error/interpolation.html
similarity index 100%
rename from crates/biome_html_parser/tests/html_specs/ok/interpolation.html
rename to crates/biome_html_parser/tests/html_specs/error/interpolation.html
diff --git a/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap b/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap
new file mode 100644
index 000000000000..c651032b767f
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap
@@ -0,0 +1,159 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```html
+<div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+
+
+	x => {
+	const hello = 'world'
+	return hello;
+	}
+
+
+	}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlBogusElement {
+            items: [
+                HtmlOpeningElement {
+                    l_angle_token: L_ANGLE@0..1 "<" [] [],
+                    name: HtmlTagName {
+                        value_token: HTML_LITERAL@1..4 "div" [] [],
+                    },
+                    attributes: HtmlAttributeList [],
+                    r_angle_token: R_ANGLE@4..5 ">" [] [],
+                },
+                HtmlBogus {
+                    items: [
+                        HtmlContent {
+                            value_token: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] [],
+                        },
+                        HtmlBogusAttribute {
+                            items: [
+                                L_DOUBLE_CURLY@51..53 "{{" [] [],
+                                HtmlTextExpression {
+                                    html_literal_token: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] [],
+                                },
+                                R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")],
+                            ],
+                        },
+                        HtmlContent {
+                            value_token: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")],
+                        },
+                        HtmlBogusAttribute {
+                            items: [
+                                L_DOUBLE_CURLY@142..144 "{{" [] [],
+                                HtmlTextExpression {
+                                    html_literal_token: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] [],
+                                },
+                                R_DOUBLE_CURLY@179..182 "}}" [] [Whitespace(" ")],
+                            ],
+                        },
+                        HtmlContent {
+                            value_token: HTML_LITERAL@182..187 "nemo." [] [],
+                        },
+                    ],
+                },
+                HtmlClosingElement {
+                    l_angle_token: L_ANGLE@187..188 "<" [] [],
+                    slash_token: SLASH@188..189 "/" [] [],
+                    name: HtmlTagName {
+                        value_token: HTML_LITERAL@189..192 "div" [] [],
+                    },
+                    r_angle_token: R_ANGLE@192..193 ">" [] [],
+                },
+            ],
+        },
+    ],
+    eof_token: EOF@193..194 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..194
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..193
+    0: HTML_BOGUS_ELEMENT@0..193
+      0: HTML_OPENING_ELEMENT@0..5
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..4
+          0: HTML_LITERAL@1..4 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@4..4
+        3: R_ANGLE@4..5 ">" [] []
+      1: HTML_BOGUS@5..187
+        0: HTML_CONTENT@5..51
+          0: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] []
+        1: HTML_BOGUS_ATTRIBUTE@51..111
+          0: L_DOUBLE_CURLY@51..53 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@53..108
+            0: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] []
+          2: R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")]
+        2: HTML_CONTENT@111..142
+          0: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")]
+        3: HTML_BOGUS_ATTRIBUTE@142..182
+          0: L_DOUBLE_CURLY@142..144 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@144..179
+            0: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] []
+          2: R_DOUBLE_CURLY@179..182 "}}" [] [Whitespace(" ")]
+        4: HTML_CONTENT@182..187
+          0: HTML_LITERAL@182..187 "nemo." [] []
+      2: HTML_CLOSING_ELEMENT@187..193
+        0: L_ANGLE@187..188 "<" [] []
+        1: SLASH@188..189 "/" [] []
+        2: HTML_TAG_NAME@189..192
+          0: HTML_LITERAL@189..192 "div" [] []
+        3: R_ANGLE@192..193 ">" [] []
+  4: EOF@193..194 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+interpolation.html:1:52 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+   > 1 │ <div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+       │                                                    ^^
+   > 2 │ 
+   > 3 │ 
+   > 4 │ 	x => {
+        ...
+   > 8 │ 
+   > 9 │ 
+  > 10 │ 	}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+       │ 	^^
+    11 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+interpolation.html:10:36 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+  > 10 │ 	}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+       │ 	                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    11 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-5450.html.snap b/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-5450.html.snap
index 65f9983a6573..9c9a18edc3f8 100644
--- a/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-5450.html.snap
+++ b/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-5450.html.snap
@@ -26,23 +26,18 @@ HtmlRoot {
                         value_token: HTML_LITERAL@1..2 "h" [] [],
                     },
                     attributes: HtmlAttributeList [
-                        HtmlAttribute {
-                            name: HtmlAttributeName {
-                                value_token: HTML_LITERAL@2..5 "{{" [] [Whitespace(" ")],
-                            },
-                            initializer: missing (optional),
-                        },
-                        HtmlAttribute {
-                            name: HtmlAttributeName {
-                                value_token: HTML_LITERAL@5..29 "heading_level|default:2" [] [Whitespace(" ")],
-                            },
-                            initializer: missing (optional),
-                        },
-                        HtmlAttribute {
-                            name: HtmlAttributeName {
-                                value_token: HTML_LITERAL@29..31 "}}" [] [],
-                            },
-                            initializer: missing (optional),
+                        HtmlBogusAttribute {
+                            items: [
+                                HtmlBogusAttribute {
+                                    items: [
+                                        L_DOUBLE_CURLY@2..4 "{{" [] [],
+                                        HtmlTextExpression {
+                                            html_literal_token: HTML_LITERAL@4..29 " heading_level|default:2 " [] [],
+                                        },
+                                        R_DOUBLE_CURLY@29..31 "}}" [] [],
+                                    ],
+                                },
+                            ],
                         },
                     ],
                     r_angle_token: R_ANGLE@31..32 ">" [] [],
@@ -85,18 +80,12 @@ HtmlRoot {
         1: HTML_TAG_NAME@1..2
           0: HTML_LITERAL@1..2 "h" [] []
         2: HTML_ATTRIBUTE_LIST@2..31
-          0: HTML_ATTRIBUTE@2..5
-            0: HTML_ATTRIBUTE_NAME@2..5
-              0: HTML_LITERAL@2..5 "{{" [] [Whitespace(" ")]
-            1: (empty)
-          1: HTML_ATTRIBUTE@5..29
-            0: HTML_ATTRIBUTE_NAME@5..29
-              0: HTML_LITERAL@5..29 "heading_level|default:2" [] [Whitespace(" ")]
-            1: (empty)
-          2: HTML_ATTRIBUTE@29..31
-            0: HTML_ATTRIBUTE_NAME@29..31
-              0: HTML_LITERAL@29..31 "}}" [] []
-            1: (empty)
+          0: HTML_BOGUS_ATTRIBUTE@2..31
+            0: HTML_BOGUS_ATTRIBUTE@2..31
+              0: L_DOUBLE_CURLY@2..4 "{{" [] []
+              1: HTML_TEXT_EXPRESSION@4..29
+                0: HTML_LITERAL@4..29 " heading_level|default:2 " [] []
+              2: R_DOUBLE_CURLY@29..31 "}}" [] []
         3: R_ANGLE@31..32 ">" [] []
       1: HTML_ELEMENT_LIST@32..36
         0: HTML_CONTENT@32..36
@@ -116,6 +105,16 @@ HtmlRoot {
 ## Diagnostics
 
 ```
+issue-5450.html:1:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+  > 1 │ <h{{ heading_level|default:2 }}>name</h{{ heading_level|default:2 }}>
+      │   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    2 │ 
+  
+  i Remove it or enable the parsing using the html.parser.textExpression option.
+  
 issue-5450.html:1:43 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   × Closing tags should not have attributes.
diff --git a/crates/biome_html_parser/tests/html_specs/error/vue_unclosed_expression.vue.snap b/crates/biome_html_parser/tests/html_specs/error/vue_unclosed_expression.vue.snap
index 516f9016093c..57e77718bd05 100644
--- a/crates/biome_html_parser/tests/html_specs/error/vue_unclosed_expression.vue.snap
+++ b/crates/biome_html_parser/tests/html_specs/error/vue_unclosed_expression.vue.snap
@@ -20,32 +20,31 @@ HtmlRoot {
     frontmatter: missing (optional),
     directive: missing (optional),
     html: HtmlElementList [
-        HtmlBogusElement {
-            items: [
-                HtmlOpeningElement {
-                    l_angle_token: L_ANGLE@0..1 "<" [] [],
-                    name: HtmlTagName {
-                        value_token: HTML_LITERAL@1..9 "template" [] [],
-                    },
-                    attributes: HtmlAttributeList [],
-                    r_angle_token: R_ANGLE@9..10 ">" [] [],
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..9 "template" [] [],
                 },
-                HtmlBogus {
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@9..10 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlBogusTextExpression {
                     items: [
                         L_DOUBLE_CURLY@10..14 "{{" [Newline("\n"), Whitespace("\t")] [],
                         HTML_LITERAL@14..17 "xyz" [] [],
-                        HtmlContent {
-                            value_token: HTML_LITERAL@17..19 "<" [Newline("\n")] [],
-                        },
-                        HtmlBogusElement {
-                            items: [
-                                SLASH@19..20 "/" [] [],
-                                HTML_LITERAL@20..29 "template>" [] [],
-                            ],
-                        },
                     ],
                 },
             ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@17..19 "<" [Newline("\n")] [],
+                slash_token: SLASH@19..20 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@20..28 "template" [] [],
+                },
+                r_angle_token: R_ANGLE@28..29 ">" [] [],
+            },
         },
     ],
     eof_token: EOF@29..30 "" [Newline("\n")] [],
@@ -60,21 +59,23 @@ HtmlRoot {
   1: (empty)
   2: (empty)
   3: HTML_ELEMENT_LIST@0..29
-    0: HTML_BOGUS_ELEMENT@0..29
+    0: HTML_ELEMENT@0..29
       0: HTML_OPENING_ELEMENT@0..10
         0: L_ANGLE@0..1 "<" [] []
         1: HTML_TAG_NAME@1..9
           0: HTML_LITERAL@1..9 "template" [] []
         2: HTML_ATTRIBUTE_LIST@9..9
         3: R_ANGLE@9..10 ">" [] []
-      1: HTML_BOGUS@10..29
-        0: L_DOUBLE_CURLY@10..14 "{{" [Newline("\n"), Whitespace("\t")] []
-        1: HTML_LITERAL@14..17 "xyz" [] []
-        2: HTML_CONTENT@17..19
-          0: HTML_LITERAL@17..19 "<" [Newline("\n")] []
-        3: HTML_BOGUS_ELEMENT@19..29
-          0: SLASH@19..20 "/" [] []
-          1: HTML_LITERAL@20..29 "template>" [] []
+      1: HTML_ELEMENT_LIST@10..17
+        0: HTML_BOGUS_TEXT_EXPRESSION@10..17
+          0: L_DOUBLE_CURLY@10..14 "{{" [Newline("\n"), Whitespace("\t")] []
+          1: HTML_LITERAL@14..17 "xyz" [] []
+      2: HTML_CLOSING_ELEMENT@17..29
+        0: L_ANGLE@17..19 "<" [Newline("\n")] []
+        1: SLASH@19..20 "/" [] []
+        2: HTML_TAG_NAME@20..28
+          0: HTML_LITERAL@20..28 "template" [] []
+        3: R_ANGLE@28..29 ">" [] []
   4: EOF@29..30 "" [Newline("\n")] []
 
 ```
@@ -82,14 +83,14 @@ HtmlRoot {
 ## Diagnostics
 
 ```
-vue_unclosed_expression.vue:3:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+vue_unclosed_expression.vue:2:2 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Found a text expression that doesn't have the closing }}
+  × Found a text expression that doesn't have the closing expression:
   
     1 │ <template>
-    2 │ 	{{xyz
-  > 3 │ </template>
-      │ ^
+  > 2 │ 	{{xyz
+      │ 	^^^^^
+    3 │ </template>
     4 │ 
   
   i This is where the opening expression was found:
@@ -100,35 +101,4 @@ vue_unclosed_expression.vue:3:1 parse ━━━━━━━━━━━━━━
     3 │ </template>
     4 │ 
   
-vue_unclosed_expression.vue:3:2 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Unexpected value or character.
-  
-    1 │ <template>
-    2 │ 	{{xyz
-  > 3 │ </template>
-      │  ^^^^^^^^^^
-    4 │ 
-  
-  i Expected one of:
-  
-  - element
-  - text
-  
-vue_unclosed_expression.vue:4:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × Expected a closing tag but instead found the end of the file.
-  
-    2 │ 	{{xyz
-    3 │ </template>
-  > 4 │ 
-      │ 
-  
-  i Expected a closing tag here.
-  
-    2 │ 	{{xyz
-    3 │ </template>
-  > 4 │ 
-      │ 
-  
 ```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro b/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro
new file mode 100644
index 000000000000..3318f1d97a90
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro
@@ -0,0 +1,6 @@
+---
+const foo = "lorem ipsum";
+---
+<html>
+	<span id={foo}></span>
+</html>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap b/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap
new file mode 100644
index 000000000000..1f43377eed95
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap
@@ -0,0 +1,141 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```astro
+---
+const foo = "lorem ipsum";
+---
+<html>
+	<span id={foo}></span>
+</html>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: AstroFrontmatterElement {
+        l_fence_token: FENCE@0..3 "---" [] [],
+        content_token: HTML_LITERAL@3..31 "const foo = \"lorem ipsum\";\n" [Newline("\n")] [],
+        r_fence_token: FENCE@31..34 "---" [] [],
+    },
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@34..36 "<" [Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@36..40 "html" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@40..41 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@41..44 "<" [Newline("\n"), Whitespace("\t")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@44..49 "span" [] [Whitespace(" ")],
+                        },
+                        attributes: HtmlAttributeList [
+                            HtmlAttribute {
+                                name: HtmlAttributeName {
+                                    value_token: HTML_LITERAL@49..51 "id" [] [],
+                                },
+                                initializer: HtmlAttributeInitializerClause {
+                                    eq_token: EQ@51..52 "=" [] [],
+                                    value: HtmlSingleTextExpression {
+                                        l_curly_token: L_CURLY@52..53 "{" [] [],
+                                        expression: HtmlTextExpression {
+                                            html_literal_token: HTML_LITERAL@53..56 "foo" [] [],
+                                        },
+                                        r_curly_token: R_CURLY@56..57 "}" [] [],
+                                    },
+                                },
+                            },
+                        ],
+                        r_angle_token: R_ANGLE@57..58 ">" [] [],
+                    },
+                    children: HtmlElementList [],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@58..59 "<" [] [],
+                        slash_token: SLASH@59..60 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@60..64 "span" [] [],
+                        },
+                        r_angle_token: R_ANGLE@64..65 ">" [] [],
+                    },
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@65..67 "<" [Newline("\n")] [],
+                slash_token: SLASH@67..68 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@68..72 "html" [] [],
+                },
+                r_angle_token: R_ANGLE@72..73 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@73..74 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..74
+  0: (empty)
+  1: ASTRO_FRONTMATTER_ELEMENT@0..34
+    0: FENCE@0..3 "---" [] []
+    1: HTML_LITERAL@3..31 "const foo = \"lorem ipsum\";\n" [Newline("\n")] []
+    2: FENCE@31..34 "---" [] []
+  2: (empty)
+  3: HTML_ELEMENT_LIST@34..73
+    0: HTML_ELEMENT@34..73
+      0: HTML_OPENING_ELEMENT@34..41
+        0: L_ANGLE@34..36 "<" [Newline("\n")] []
+        1: HTML_TAG_NAME@36..40
+          0: HTML_LITERAL@36..40 "html" [] []
+        2: HTML_ATTRIBUTE_LIST@40..40
+        3: R_ANGLE@40..41 ">" [] []
+      1: HTML_ELEMENT_LIST@41..65
+        0: HTML_ELEMENT@41..65
+          0: HTML_OPENING_ELEMENT@41..58
+            0: L_ANGLE@41..44 "<" [Newline("\n"), Whitespace("\t")] []
+            1: HTML_TAG_NAME@44..49
+              0: HTML_LITERAL@44..49 "span" [] [Whitespace(" ")]
+            2: HTML_ATTRIBUTE_LIST@49..57
+              0: HTML_ATTRIBUTE@49..57
+                0: HTML_ATTRIBUTE_NAME@49..51
+                  0: HTML_LITERAL@49..51 "id" [] []
+                1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@51..57
+                  0: EQ@51..52 "=" [] []
+                  1: HTML_SINGLE_TEXT_EXPRESSION@52..57
+                    0: L_CURLY@52..53 "{" [] []
+                    1: HTML_TEXT_EXPRESSION@53..56
+                      0: HTML_LITERAL@53..56 "foo" [] []
+                    2: R_CURLY@56..57 "}" [] []
+            3: R_ANGLE@57..58 ">" [] []
+          1: HTML_ELEMENT_LIST@58..58
+          2: HTML_CLOSING_ELEMENT@58..65
+            0: L_ANGLE@58..59 "<" [] []
+            1: SLASH@59..60 "/" [] []
+            2: HTML_TAG_NAME@60..64
+              0: HTML_LITERAL@60..64 "span" [] []
+            3: R_ANGLE@64..65 ">" [] []
+      2: HTML_CLOSING_ELEMENT@65..73
+        0: L_ANGLE@65..67 "<" [Newline("\n")] []
+        1: SLASH@67..68 "/" [] []
+        2: HTML_TAG_NAME@68..72
+          0: HTML_LITERAL@68..72 "html" [] []
+        3: R_ANGLE@72..73 ">" [] []
+  4: EOF@73..74 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/interpolation.html.snap b/crates/biome_html_parser/tests/html_specs/ok/interpolation.html.snap
deleted file mode 100644
index 0d1b64f3c516..000000000000
--- a/crates/biome_html_parser/tests/html_specs/ok/interpolation.html.snap
+++ /dev/null
@@ -1,114 +0,0 @@
----
-source: crates/biome_html_parser/tests/spec_test.rs
-expression: snapshot
----
-## Input
-
-```html
-<div>Fuga magnam facilis. Voluptatem quaerat porro.{{
-
-
-	x => {
-	const hello = 'world'
-	return hello;
-	}
-
-
-	}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
-
-```
-
-
-## AST
-
-```
-HtmlRoot {
-    bom_token: missing (optional),
-    frontmatter: missing (optional),
-    directive: missing (optional),
-    html: HtmlElementList [
-        HtmlElement {
-            opening_element: HtmlOpeningElement {
-                l_angle_token: L_ANGLE@0..1 "<" [] [],
-                name: HtmlTagName {
-                    value_token: HTML_LITERAL@1..4 "div" [] [],
-                },
-                attributes: HtmlAttributeList [],
-                r_angle_token: R_ANGLE@4..5 ">" [] [],
-            },
-            children: HtmlElementList [
-                HtmlContent {
-                    value_token: HTML_LITERAL@5..53 "Fuga magnam facilis. Voluptatem quaerat porro.{{" [] [],
-                },
-                HtmlContent {
-                    value_token: HTML_LITERAL@53..104 "x => {\n\tconst hello = 'world'\n\treturn hello;\n\t}" [Newline("\n"), Newline("\n"), Newline("\n"), Whitespace("\t")] [],
-                },
-                HtmlContent {
-                    value_token: HTML_LITERAL@104..111 "}}" [Newline("\n"), Newline("\n"), Newline("\n"), Whitespace("\t")] [Whitespace(" ")],
-                },
-                HtmlContent {
-                    value_token: HTML_LITERAL@111..125 "reprehenderit" [] [Whitespace(" ")],
-                },
-                HtmlContent {
-                    value_token: HTML_LITERAL@125..179 "voluptates minus {{console.log(  short_interpolation )" [] [],
-                },
-                HtmlContent {
-                    value_token: HTML_LITERAL@179..182 "}}" [] [Whitespace(" ")],
-                },
-                HtmlContent {
-                    value_token: HTML_LITERAL@182..187 "nemo." [] [],
-                },
-            ],
-            closing_element: HtmlClosingElement {
-                l_angle_token: L_ANGLE@187..188 "<" [] [],
-                slash_token: SLASH@188..189 "/" [] [],
-                name: HtmlTagName {
-                    value_token: HTML_LITERAL@189..192 "div" [] [],
-                },
-                r_angle_token: R_ANGLE@192..193 ">" [] [],
-            },
-        },
-    ],
-    eof_token: EOF@193..194 "" [Newline("\n")] [],
-}
-```
-
-## CST
-
-```
-0: HTML_ROOT@0..194
-  0: (empty)
-  1: (empty)
-  2: (empty)
-  3: HTML_ELEMENT_LIST@0..193
-    0: HTML_ELEMENT@0..193
-      0: HTML_OPENING_ELEMENT@0..5
-        0: L_ANGLE@0..1 "<" [] []
-        1: HTML_TAG_NAME@1..4
-          0: HTML_LITERAL@1..4 "div" [] []
-        2: HTML_ATTRIBUTE_LIST@4..4
-        3: R_ANGLE@4..5 ">" [] []
-      1: HTML_ELEMENT_LIST@5..187
-        0: HTML_CONTENT@5..53
-          0: HTML_LITERAL@5..53 "Fuga magnam facilis. Voluptatem quaerat porro.{{" [] []
-        1: HTML_CONTENT@53..104
-          0: HTML_LITERAL@53..104 "x => {\n\tconst hello = 'world'\n\treturn hello;\n\t}" [Newline("\n"), Newline("\n"), Newline("\n"), Whitespace("\t")] []
-        2: HTML_CONTENT@104..111
-          0: HTML_LITERAL@104..111 "}}" [Newline("\n"), Newline("\n"), Newline("\n"), Whitespace("\t")] [Whitespace(" ")]
-        3: HTML_CONTENT@111..125
-          0: HTML_LITERAL@111..125 "reprehenderit" [] [Whitespace(" ")]
-        4: HTML_CONTENT@125..179
-          0: HTML_LITERAL@125..179 "voluptates minus {{console.log(  short_interpolation )" [] []
-        5: HTML_CONTENT@179..182
-          0: HTML_LITERAL@179..182 "}}" [] [Whitespace(" ")]
-        6: HTML_CONTENT@182..187
-          0: HTML_LITERAL@182..187 "nemo." [] []
-      2: HTML_CLOSING_ELEMENT@187..193
-        0: L_ANGLE@187..188 "<" [] []
-        1: SLASH@188..189 "/" [] []
-        2: HTML_TAG_NAME@189..192
-          0: HTML_LITERAL@189..192 "div" [] []
-        3: R_ANGLE@192..193 ">" [] []
-  4: EOF@193..194 "" [Newline("\n")] []
-
-```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/interpolation.vue b/crates/biome_html_parser/tests/html_specs/ok/interpolation.vue
new file mode 100644
index 000000000000..0069b8ac7f11
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/interpolation.vue
@@ -0,0 +1,14 @@
+<div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+
+
+	x => {
+	const hello = 'world'
+	return hello;
+	}
+
+
+	}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+
+<div>Too small: {{ x < 5 }} {{ y / 16}}</div>
+
+<div>{{ call(fn({ inner })) }}</div>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/interpolation.vue.snap b/crates/biome_html_parser/tests/html_specs/ok/interpolation.vue.snap
new file mode 100644
index 000000000000..216b52184f63
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/interpolation.vue.snap
@@ -0,0 +1,231 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```vue
+<div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+
+
+	x => {
+	const hello = 'world'
+	return hello;
+	}
+
+
+	}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+
+<div>Too small: {{ x < 5 }} {{ y / 16}}</div>
+
+<div>{{ call(fn({ inner })) }}</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..4 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@4..5 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlContent {
+                    value_token: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] [],
+                },
+                HtmlDoubleTextExpression {
+                    l_double_curly_token: L_DOUBLE_CURLY@51..53 "{{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] [],
+                    },
+                    r_double_curly_token: R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")],
+                },
+                HtmlContent {
+                    value_token: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")],
+                },
+                HtmlDoubleTextExpression {
+                    l_double_curly_token: L_DOUBLE_CURLY@142..144 "{{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] [],
+                    },
+                    r_double_curly_token: R_DOUBLE_CURLY@179..182 "}}" [] [Whitespace(" ")],
+                },
+                HtmlContent {
+                    value_token: HTML_LITERAL@182..187 "nemo." [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@187..188 "<" [] [],
+                slash_token: SLASH@188..189 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@189..192 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@192..193 ">" [] [],
+            },
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@193..196 "<" [Newline("\n"), Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@196..199 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@199..200 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlContent {
+                    value_token: HTML_LITERAL@200..211 "Too small:" [] [Whitespace(" ")],
+                },
+                HtmlDoubleTextExpression {
+                    l_double_curly_token: L_DOUBLE_CURLY@211..213 "{{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@213..220 " x < 5 " [] [],
+                    },
+                    r_double_curly_token: R_DOUBLE_CURLY@220..223 "}}" [] [Whitespace(" ")],
+                },
+                HtmlDoubleTextExpression {
+                    l_double_curly_token: L_DOUBLE_CURLY@223..225 "{{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@225..232 " y / 16" [] [],
+                    },
+                    r_double_curly_token: R_DOUBLE_CURLY@232..234 "}}" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@234..235 "<" [] [],
+                slash_token: SLASH@235..236 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@236..239 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@239..240 ">" [] [],
+            },
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@240..243 "<" [Newline("\n"), Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@243..246 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@246..247 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlDoubleTextExpression {
+                    l_double_curly_token: L_DOUBLE_CURLY@247..249 "{{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@249..270 " call(fn({ inner })) " [] [],
+                    },
+                    r_double_curly_token: R_DOUBLE_CURLY@270..272 "}}" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@272..273 "<" [] [],
+                slash_token: SLASH@273..274 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@274..277 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@277..278 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@278..279 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..279
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..278
+    0: HTML_ELEMENT@0..193
+      0: HTML_OPENING_ELEMENT@0..5
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..4
+          0: HTML_LITERAL@1..4 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@4..4
+        3: R_ANGLE@4..5 ">" [] []
+      1: HTML_ELEMENT_LIST@5..187
+        0: HTML_CONTENT@5..51
+          0: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] []
+        1: HTML_DOUBLE_TEXT_EXPRESSION@51..111
+          0: L_DOUBLE_CURLY@51..53 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@53..108
+            0: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] []
+          2: R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")]
+        2: HTML_CONTENT@111..142
+          0: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")]
+        3: HTML_DOUBLE_TEXT_EXPRESSION@142..182
+          0: L_DOUBLE_CURLY@142..144 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@144..179
+            0: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] []
+          2: R_DOUBLE_CURLY@179..182 "}}" [] [Whitespace(" ")]
+        4: HTML_CONTENT@182..187
+          0: HTML_LITERAL@182..187 "nemo." [] []
+      2: HTML_CLOSING_ELEMENT@187..193
+        0: L_ANGLE@187..188 "<" [] []
+        1: SLASH@188..189 "/" [] []
+        2: HTML_TAG_NAME@189..192
+          0: HTML_LITERAL@189..192 "div" [] []
+        3: R_ANGLE@192..193 ">" [] []
+    1: HTML_ELEMENT@193..240
+      0: HTML_OPENING_ELEMENT@193..200
+        0: L_ANGLE@193..196 "<" [Newline("\n"), Newline("\n")] []
+        1: HTML_TAG_NAME@196..199
+          0: HTML_LITERAL@196..199 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@199..199
+        3: R_ANGLE@199..200 ">" [] []
+      1: HTML_ELEMENT_LIST@200..234
+        0: HTML_CONTENT@200..211
+          0: HTML_LITERAL@200..211 "Too small:" [] [Whitespace(" ")]
+        1: HTML_DOUBLE_TEXT_EXPRESSION@211..223
+          0: L_DOUBLE_CURLY@211..213 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@213..220
+            0: HTML_LITERAL@213..220 " x < 5 " [] []
+          2: R_DOUBLE_CURLY@220..223 "}}" [] [Whitespace(" ")]
+        2: HTML_DOUBLE_TEXT_EXPRESSION@223..234
+          0: L_DOUBLE_CURLY@223..225 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@225..232
+            0: HTML_LITERAL@225..232 " y / 16" [] []
+          2: R_DOUBLE_CURLY@232..234 "}}" [] []
+      2: HTML_CLOSING_ELEMENT@234..240
+        0: L_ANGLE@234..235 "<" [] []
+        1: SLASH@235..236 "/" [] []
+        2: HTML_TAG_NAME@236..239
+          0: HTML_LITERAL@236..239 "div" [] []
+        3: R_ANGLE@239..240 ">" [] []
+    2: HTML_ELEMENT@240..278
+      0: HTML_OPENING_ELEMENT@240..247
+        0: L_ANGLE@240..243 "<" [Newline("\n"), Newline("\n")] []
+        1: HTML_TAG_NAME@243..246
+          0: HTML_LITERAL@243..246 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@246..246
+        3: R_ANGLE@246..247 ">" [] []
+      1: HTML_ELEMENT_LIST@247..272
+        0: HTML_DOUBLE_TEXT_EXPRESSION@247..272
+          0: L_DOUBLE_CURLY@247..249 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@249..270
+            0: HTML_LITERAL@249..270 " call(fn({ inner })) " [] []
+          2: R_DOUBLE_CURLY@270..272 "}}" [] []
+      2: HTML_CLOSING_ELEMENT@272..278
+        0: L_ANGLE@272..273 "<" [] []
+        1: SLASH@273..274 "/" [] []
+        2: HTML_TAG_NAME@274..277
+          0: HTML_LITERAL@274..277 "div" [] []
+        3: R_ANGLE@277..278 ">" [] []
+  4: EOF@278..279 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/multiple_expressions.vue b/crates/biome_html_parser/tests/html_specs/ok/multiple_expressions.vue
new file mode 100644
index 000000000000..07cd70e03de4
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/multiple_expressions.vue
@@ -0,0 +1,3 @@
+<template>
+	Foo {{xyz}} bar
+</template>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/multiple_expressions.vue.snap b/crates/biome_html_parser/tests/html_specs/ok/multiple_expressions.vue.snap
new file mode 100644
index 000000000000..e1698da43f6f
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/multiple_expressions.vue.snap
@@ -0,0 +1,94 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```vue
+<template>
+	Foo {{xyz}} bar
+</template>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..9 "template" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@9..10 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlContent {
+                    value_token: HTML_LITERAL@10..16 "Foo" [Newline("\n"), Whitespace("\t")] [Whitespace(" ")],
+                },
+                HtmlDoubleTextExpression {
+                    l_double_curly_token: L_DOUBLE_CURLY@16..18 "{{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@18..21 "xyz" [] [],
+                    },
+                    r_double_curly_token: R_DOUBLE_CURLY@21..24 "}}" [] [Whitespace(" ")],
+                },
+                HtmlContent {
+                    value_token: HTML_LITERAL@24..27 "bar" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@27..29 "<" [Newline("\n")] [],
+                slash_token: SLASH@29..30 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@30..38 "template" [] [],
+                },
+                r_angle_token: R_ANGLE@38..39 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@39..40 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..40
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..39
+    0: HTML_ELEMENT@0..39
+      0: HTML_OPENING_ELEMENT@0..10
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..9
+          0: HTML_LITERAL@1..9 "template" [] []
+        2: HTML_ATTRIBUTE_LIST@9..9
+        3: R_ANGLE@9..10 ">" [] []
+      1: HTML_ELEMENT_LIST@10..27
+        0: HTML_CONTENT@10..16
+          0: HTML_LITERAL@10..16 "Foo" [Newline("\n"), Whitespace("\t")] [Whitespace(" ")]
+        1: HTML_DOUBLE_TEXT_EXPRESSION@16..24
+          0: L_DOUBLE_CURLY@16..18 "{{" [] []
+          1: HTML_TEXT_EXPRESSION@18..21
+            0: HTML_LITERAL@18..21 "xyz" [] []
+          2: R_DOUBLE_CURLY@21..24 "}}" [] [Whitespace(" ")]
+        2: HTML_CONTENT@24..27
+          0: HTML_LITERAL@24..27 "bar" [] []
+      2: HTML_CLOSING_ELEMENT@27..39
+        0: L_ANGLE@27..29 "<" [Newline("\n")] []
+        1: SLASH@29..30 "/" [] []
+        2: HTML_TAG_NAME@30..38
+          0: HTML_LITERAL@30..38 "template" [] []
+        3: R_ANGLE@38..39 ">" [] []
+  4: EOF@39..40 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte b/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte
new file mode 100644
index 000000000000..3ba7a69cd66f
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte
@@ -0,0 +1,5 @@
+<script>
+	let binding = "World";
+</script>
+
+<span>{binding}</span>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap
new file mode 100644
index 000000000000..134cb19c7bca
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap
@@ -0,0 +1,125 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```svelte
+<script>
+	let binding = "World";
+</script>
+
+<span>{binding}</span>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..7 "script" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@7..8 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlContent {
+                    value_token: HTML_LITERAL@8..33 "\n\tlet binding = \"World\";\n" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@33..34 "<" [] [],
+                slash_token: SLASH@34..35 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@35..41 "script" [] [],
+                },
+                r_angle_token: R_ANGLE@41..42 ">" [] [],
+            },
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@42..45 "<" [Newline("\n"), Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@45..49 "span" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@49..50 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlSingleTextExpression {
+                    l_curly_token: L_CURLY@50..51 "{" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@51..58 "binding" [] [],
+                    },
+                    r_curly_token: R_CURLY@58..59 "}" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@59..60 "<" [] [],
+                slash_token: SLASH@60..61 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@61..65 "span" [] [],
+                },
+                r_angle_token: R_ANGLE@65..66 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@66..67 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..67
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..66
+    0: HTML_ELEMENT@0..42
+      0: HTML_OPENING_ELEMENT@0..8
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..7
+          0: HTML_LITERAL@1..7 "script" [] []
+        2: HTML_ATTRIBUTE_LIST@7..7
+        3: R_ANGLE@7..8 ">" [] []
+      1: HTML_ELEMENT_LIST@8..33
+        0: HTML_CONTENT@8..33
+          0: HTML_LITERAL@8..33 "\n\tlet binding = \"World\";\n" [] []
+      2: HTML_CLOSING_ELEMENT@33..42
+        0: L_ANGLE@33..34 "<" [] []
+        1: SLASH@34..35 "/" [] []
+        2: HTML_TAG_NAME@35..41
+          0: HTML_LITERAL@35..41 "script" [] []
+        3: R_ANGLE@41..42 ">" [] []
+    1: HTML_ELEMENT@42..66
+      0: HTML_OPENING_ELEMENT@42..50
+        0: L_ANGLE@42..45 "<" [Newline("\n"), Newline("\n")] []
+        1: HTML_TAG_NAME@45..49
+          0: HTML_LITERAL@45..49 "span" [] []
+        2: HTML_ATTRIBUTE_LIST@49..49
+        3: R_ANGLE@49..50 ">" [] []
+      1: HTML_ELEMENT_LIST@50..59
+        0: HTML_SINGLE_TEXT_EXPRESSION@50..59
+          0: L_CURLY@50..51 "{" [] []
+          1: HTML_TEXT_EXPRESSION@51..58
+            0: HTML_LITERAL@51..58 "binding" [] []
+          2: R_CURLY@58..59 "}" [] []
+      2: HTML_CLOSING_ELEMENT@59..66
+        0: L_ANGLE@59..60 "<" [] []
+        1: SLASH@60..61 "/" [] []
+        2: HTML_TAG_NAME@61..65
+          0: HTML_LITERAL@61..65 "span" [] []
+        3: R_ANGLE@65..66 ">" [] []
+  4: EOF@66..67 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/vue_expressions.vue.snap b/crates/biome_html_parser/tests/html_specs/ok/vue_expressions.vue.snap
index 6590aaa71e6e..f1e305a8186d 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/vue_expressions.vue.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/vue_expressions.vue.snap
@@ -30,9 +30,11 @@ HtmlRoot {
                 r_angle_token: R_ANGLE@9..10 ">" [] [],
             },
             children: HtmlElementList [
-                HtmlTextExpression {
+                HtmlDoubleTextExpression {
                     l_double_curly_token: L_DOUBLE_CURLY@10..14 "{{" [Newline("\n"), Whitespace("\t")] [],
-                    expression_token: HTML_LITERAL@14..17 "xyz" [] [],
+                    expression: HtmlTextExpression {
+                        html_literal_token: HTML_LITERAL@14..17 "xyz" [] [],
+                    },
                     r_double_curly_token: R_DOUBLE_CURLY@17..19 "}}" [] [],
                 },
             ],
@@ -66,9 +68,10 @@ HtmlRoot {
         2: HTML_ATTRIBUTE_LIST@9..9
         3: R_ANGLE@9..10 ">" [] []
       1: HTML_ELEMENT_LIST@10..19
-        0: HTML_TEXT_EXPRESSION@10..19
+        0: HTML_DOUBLE_TEXT_EXPRESSION@10..19
           0: L_DOUBLE_CURLY@10..14 "{{" [Newline("\n"), Whitespace("\t")] []
-          1: HTML_LITERAL@14..17 "xyz" [] []
+          1: HTML_TEXT_EXPRESSION@14..17
+            0: HTML_LITERAL@14..17 "xyz" [] []
           2: R_DOUBLE_CURLY@17..19 "}}" [] []
       2: HTML_CLOSING_ELEMENT@19..31
         0: L_ANGLE@19..21 "<" [Newline("\n")] []
diff --git a/crates/biome_html_parser/tests/spec_test.rs b/crates/biome_html_parser/tests/spec_test.rs
index c3f9693b7fb9..ada6bda0ca0b 100644
--- a/crates/biome_html_parser/tests/spec_test.rs
+++ b/crates/biome_html_parser/tests/spec_test.rs
@@ -1,7 +1,7 @@
 use biome_console::fmt::{Formatter, Termcolor};
 use biome_console::markup;
 use biome_diagnostics::{DiagnosticExt, PrintDiagnostic, termcolor};
-use biome_html_parser::parse_html;
+use biome_html_parser::{HtmlParseOptions, parse_html};
 use biome_html_syntax::{HtmlFileSource, HtmlVariant};
 use biome_rowan::SyntaxKind;
 use biome_test_utils::{has_bogus_nodes_or_empty_slots, validate_eof_token};
@@ -32,15 +32,15 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_
         .expect("Expected test path to be a readable file in UTF8 encoding");
 
     let file_source = HtmlFileSource::try_from(test_case_path).unwrap_or_default();
-
-    let parsed = parse_html(&content, file_source);
+    let parser_options = HtmlParseOptions::from(&file_source);
+    let parsed = parse_html(&content, parser_options);
     validate_eof_token(parsed.syntax());
 
     let formatted_ast = format!("{:#?}", parsed.tree());
 
     let mut snapshot = String::new();
     let code_block = match file_source.variant() {
-        HtmlVariant::Standard => "html",
+        HtmlVariant::Standard(_) => "html",
         HtmlVariant::Astro => "astro",
         HtmlVariant::Vue => "vue",
         HtmlVariant::Svelte => "svelte",
@@ -145,7 +145,7 @@ pub fn quick_test() {
     let code = r#"<template>{{foo}}</template>
     "#;
 
-    let root = parse_html(code, HtmlFileSource::astro());
+    let root = parse_html(code, (&HtmlFileSource::astro()).into());
     let syntax = root.syntax();
     dbg!(&syntax, root.diagnostics(), root.has_errors());
     if has_bogus_nodes_or_empty_slots(&syntax) {
diff --git a/crates/biome_html_syntax/src/file_source.rs b/crates/biome_html_syntax/src/file_source.rs
index d630c4ff2572..4c0d85f14a53 100644
--- a/crates/biome_html_syntax/src/file_source.rs
+++ b/crates/biome_html_syntax/src/file_source.rs
@@ -18,15 +18,31 @@ impl HtmlFileSource {
     pub fn variant(&self) -> &HtmlVariant {
         &self.variant
     }
+
+    pub fn text_expressions(&self) -> Option<&HtmlTextExpressions> {
+        if let HtmlVariant::Standard(text_expressions) = &self.variant {
+            Some(text_expressions)
+        } else {
+            None
+        }
+    }
 }
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(
     Debug, Clone, Default, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize,
 )]
-pub enum HtmlVariant {
+pub enum HtmlTextExpressions {
     #[default]
-    Standard,
+    None,
+    Single,
+    Double,
+}
+
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
+pub enum HtmlVariant {
+    Standard(HtmlTextExpressions),
     /// Use this variant to parse an Astro file
     Astro,
     /// Use this variant to parse a Vue file
@@ -35,12 +51,31 @@ pub enum HtmlVariant {
     Svelte,
 }
 
+impl Default for HtmlVariant {
+    fn default() -> Self {
+        Self::Standard(HtmlTextExpressions::None)
+    }
+}
+
 impl HtmlFileSource {
     pub fn html() -> Self {
         Self {
-            variant: HtmlVariant::Standard,
+            variant: HtmlVariant::default(),
         }
     }
+
+    /// Returns `true` if the current file is `.html` and doesn't support
+    /// any text expression capability
+    pub fn is_html(&self) -> bool {
+        self.variant == HtmlVariant::default()
+    }
+
+    pub fn html_with_text_expressions() -> Self {
+        Self {
+            variant: HtmlVariant::Standard(HtmlTextExpressions::Double),
+        }
+    }
+
     pub fn astro() -> Self {
         Self {
             variant: HtmlVariant::Astro,
diff --git a/crates/biome_html_syntax/src/generated/kind.rs b/crates/biome_html_syntax/src/generated/kind.rs
index 3cb0f980d1c7..5edc36f15042 100644
--- a/crates/biome_html_syntax/src/generated/kind.rs
+++ b/crates/biome_html_syntax/src/generated/kind.rs
@@ -55,11 +55,13 @@ pub enum HtmlSyntaxKind {
     HTML_CONTENT,
     HTML_CDATA_SECTION,
     COMMENT,
+    HTML_DOUBLE_TEXT_EXPRESSION,
+    HTML_SINGLE_TEXT_EXPRESSION,
     HTML_TEXT_EXPRESSION,
-    SVELTE_TEXT_EXPRESSION,
     HTML_BOGUS,
     HTML_BOGUS_ELEMENT,
     HTML_BOGUS_ATTRIBUTE,
+    HTML_BOGUS_TEXT_EXPRESSION,
     ASTRO_BOGUS_FRONTMATTER,
     #[doc(hidden)]
     __LAST,
diff --git a/crates/biome_html_syntax/src/generated/macros.rs b/crates/biome_html_syntax/src/generated/macros.rs
index 3070d9ef3e19..55bd8b9c27fa 100644
--- a/crates/biome_html_syntax/src/generated/macros.rs
+++ b/crates/biome_html_syntax/src/generated/macros.rs
@@ -49,6 +49,10 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlDirective::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::HTML_DOUBLE_TEXT_EXPRESSION => {
+                    let $pattern = unsafe { $crate::HtmlDoubleTextExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_ELEMENT => {
                     let $pattern = unsafe { $crate::HtmlElement::new_unchecked(node) };
                     $body
@@ -65,6 +69,10 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlSelfClosingElement::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::HTML_SINGLE_TEXT_EXPRESSION => {
+                    let $pattern = unsafe { $crate::HtmlSingleTextExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_STRING => {
                     let $pattern = unsafe { $crate::HtmlString::new_unchecked(node) };
                     $body
@@ -77,10 +85,6 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlTextExpression::new_unchecked(node) };
                     $body
                 }
-                $crate::HtmlSyntaxKind::SVELTE_TEXT_EXPRESSION => {
-                    let $pattern = unsafe { $crate::SvelteTextExpression::new_unchecked(node) };
-                    $body
-                }
                 $crate::HtmlSyntaxKind::ASTRO_BOGUS_FRONTMATTER => {
                     let $pattern = unsafe { $crate::AstroBogusFrontmatter::new_unchecked(node) };
                     $body
@@ -97,6 +101,10 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlBogusElement::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::HTML_BOGUS_TEXT_EXPRESSION => {
+                    let $pattern = unsafe { $crate::HtmlBogusTextExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_ATTRIBUTE_LIST => {
                     let $pattern = unsafe { $crate::HtmlAttributeList::new_unchecked(node) };
                     $body
diff --git a/crates/biome_html_syntax/src/generated/nodes.rs b/crates/biome_html_syntax/src/generated/nodes.rs
index a387e0c2615f..126711d7dcfd 100644
--- a/crates/biome_html_syntax/src/generated/nodes.rs
+++ b/crates/biome_html_syntax/src/generated/nodes.rs
@@ -127,7 +127,7 @@ impl HtmlAttributeInitializerClause {
     pub fn eq_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn value(&self) -> SyntaxResult<HtmlString> {
+    pub fn value(&self) -> SyntaxResult<AnyHtmlAttributeInitializer> {
         support::required_node(&self.syntax, 1usize)
     }
 }
@@ -142,7 +142,7 @@ impl Serialize for HtmlAttributeInitializerClause {
 #[derive(Serialize)]
 pub struct HtmlAttributeInitializerClauseFields {
     pub eq_token: SyntaxResult<SyntaxToken>,
-    pub value: SyntaxResult<HtmlString>,
+    pub value: SyntaxResult<AnyHtmlAttributeInitializer>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct HtmlAttributeName {
@@ -380,6 +380,51 @@ pub struct HtmlDirectiveFields {
     pub r_angle_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlDoubleTextExpression {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlDoubleTextExpression {
+    #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
+    #[doc = r""]
+    #[doc = r" # Safety"]
+    #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"]
+    #[doc = r" or a match on [SyntaxNode::kind]"]
+    #[inline]
+    pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self { syntax }
+    }
+    pub fn as_fields(&self) -> HtmlDoubleTextExpressionFields {
+        HtmlDoubleTextExpressionFields {
+            l_double_curly_token: self.l_double_curly_token(),
+            expression: self.expression(),
+            r_double_curly_token: self.r_double_curly_token(),
+        }
+    }
+    pub fn l_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn r_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlDoubleTextExpression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlDoubleTextExpressionFields {
+    pub l_double_curly_token: SyntaxResult<SyntaxToken>,
+    pub expression: SyntaxResult<HtmlTextExpression>,
+    pub r_double_curly_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct HtmlElement {
     pub(crate) syntax: SyntaxNode,
 }
@@ -585,10 +630,10 @@ pub struct HtmlSelfClosingElementFields {
     pub r_angle_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlString {
+pub struct HtmlSingleTextExpression {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlString {
+impl HtmlSingleTextExpression {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -598,16 +643,24 @@ impl HtmlString {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlStringFields {
-        HtmlStringFields {
-            value_token: self.value_token(),
+    pub fn as_fields(&self) -> HtmlSingleTextExpressionFields {
+        HtmlSingleTextExpressionFields {
+            l_curly_token: self.l_curly_token(),
+            expression: self.expression(),
+            r_curly_token: self.r_curly_token(),
         }
     }
-    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_curly_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
+    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
 }
-impl Serialize for HtmlString {
+impl Serialize for HtmlSingleTextExpression {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -616,14 +669,16 @@ impl Serialize for HtmlString {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlStringFields {
-    pub value_token: SyntaxResult<SyntaxToken>,
+pub struct HtmlSingleTextExpressionFields {
+    pub l_curly_token: SyntaxResult<SyntaxToken>,
+    pub expression: SyntaxResult<HtmlTextExpression>,
+    pub r_curly_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlTagName {
+pub struct HtmlString {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlTagName {
+impl HtmlString {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -633,8 +688,8 @@ impl HtmlTagName {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlTagNameFields {
-        HtmlTagNameFields {
+    pub fn as_fields(&self) -> HtmlStringFields {
+        HtmlStringFields {
             value_token: self.value_token(),
         }
     }
@@ -642,7 +697,7 @@ impl HtmlTagName {
         support::required_token(&self.syntax, 0usize)
     }
 }
-impl Serialize for HtmlTagName {
+impl Serialize for HtmlString {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -651,14 +706,14 @@ impl Serialize for HtmlTagName {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlTagNameFields {
+pub struct HtmlStringFields {
     pub value_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlTextExpression {
+pub struct HtmlTagName {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlTextExpression {
+impl HtmlTagName {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -668,24 +723,16 @@ impl HtmlTextExpression {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlTextExpressionFields {
-        HtmlTextExpressionFields {
-            l_double_curly_token: self.l_double_curly_token(),
-            expression_token: self.expression_token(),
-            r_double_curly_token: self.r_double_curly_token(),
+    pub fn as_fields(&self) -> HtmlTagNameFields {
+        HtmlTagNameFields {
+            value_token: self.value_token(),
         }
     }
-    pub fn l_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn expression_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 1usize)
-    }
-    pub fn r_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 2usize)
-    }
 }
-impl Serialize for HtmlTextExpression {
+impl Serialize for HtmlTagName {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -694,16 +741,14 @@ impl Serialize for HtmlTextExpression {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlTextExpressionFields {
-    pub l_double_curly_token: SyntaxResult<SyntaxToken>,
-    pub expression_token: SyntaxResult<SyntaxToken>,
-    pub r_double_curly_token: SyntaxResult<SyntaxToken>,
+pub struct HtmlTagNameFields {
+    pub value_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct SvelteTextExpression {
+pub struct HtmlTextExpression {
     pub(crate) syntax: SyntaxNode,
 }
-impl SvelteTextExpression {
+impl HtmlTextExpression {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -713,24 +758,16 @@ impl SvelteTextExpression {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> SvelteTextExpressionFields {
-        SvelteTextExpressionFields {
-            l_curly_token: self.l_curly_token(),
-            expression_token: self.expression_token(),
-            r_curly_token: self.r_curly_token(),
+    pub fn as_fields(&self) -> HtmlTextExpressionFields {
+        HtmlTextExpressionFields {
+            html_literal_token: self.html_literal_token(),
         }
     }
-    pub fn l_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn html_literal_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn expression_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 1usize)
-    }
-    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 2usize)
-    }
 }
-impl Serialize for SvelteTextExpression {
+impl Serialize for HtmlTextExpression {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -739,10 +776,8 @@ impl Serialize for SvelteTextExpression {
     }
 }
 #[derive(Serialize)]
-pub struct SvelteTextExpressionFields {
-    pub l_curly_token: SyntaxResult<SyntaxToken>,
-    pub expression_token: SyntaxResult<SyntaxToken>,
-    pub r_curly_token: SyntaxResult<SyntaxToken>,
+pub struct HtmlTextExpressionFields {
+    pub html_literal_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash, Serialize)]
 pub enum AnyAstroFrontmatterElement {
@@ -767,6 +802,7 @@ impl AnyAstroFrontmatterElement {
 pub enum AnyHtmlAttribute {
     HtmlAttribute(HtmlAttribute),
     HtmlBogusAttribute(HtmlBogusAttribute),
+    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
 }
 impl AnyHtmlAttribute {
     pub fn as_html_attribute(&self) -> Option<&HtmlAttribute> {
@@ -781,6 +817,31 @@ impl AnyHtmlAttribute {
             _ => None,
         }
     }
+    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
+        match &self {
+            Self::HtmlDoubleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyHtmlAttributeInitializer {
+    HtmlSingleTextExpression(HtmlSingleTextExpression),
+    HtmlString(HtmlString),
+}
+impl AnyHtmlAttributeInitializer {
+    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+        match &self {
+            Self::HtmlSingleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_string(&self) -> Option<&HtmlString> {
+        match &self {
+            Self::HtmlString(item) => Some(item),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, PartialEq, Eq, Hash, Serialize)]
 pub enum AnyHtmlContent {
@@ -843,19 +904,26 @@ impl AnyHtmlElement {
 }
 #[derive(Clone, PartialEq, Eq, Hash, Serialize)]
 pub enum AnyHtmlTextExpression {
-    HtmlTextExpression(HtmlTextExpression),
-    SvelteTextExpression(SvelteTextExpression),
+    HtmlBogusTextExpression(HtmlBogusTextExpression),
+    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
+    HtmlSingleTextExpression(HtmlSingleTextExpression),
 }
 impl AnyHtmlTextExpression {
-    pub fn as_html_text_expression(&self) -> Option<&HtmlTextExpression> {
+    pub fn as_html_bogus_text_expression(&self) -> Option<&HtmlBogusTextExpression> {
         match &self {
-            Self::HtmlTextExpression(item) => Some(item),
+            Self::HtmlBogusTextExpression(item) => Some(item),
             _ => None,
         }
     }
-    pub fn as_svelte_text_expression(&self) -> Option<&SvelteTextExpression> {
+    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
         match &self {
-            Self::SvelteTextExpression(item) => Some(item),
+            Self::HtmlDoubleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+        match &self {
+            Self::HtmlSingleTextExpression(item) => Some(item),
             _ => None,
         }
     }
@@ -1309,6 +1377,61 @@ impl From<HtmlDirective> for SyntaxElement {
         n.syntax.into()
     }
 }
+impl AstNode for HtmlDoubleTextExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_DOUBLE_TEXT_EXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == HTML_DOUBLE_TEXT_EXPRESSION
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
+    }
+}
+impl std::fmt::Debug for HtmlDoubleTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
+        let current_depth = DEPTH.get();
+        let result = if current_depth < 16 {
+            DEPTH.set(current_depth + 1);
+            f.debug_struct("HtmlDoubleTextExpression")
+                .field(
+                    "l_double_curly_token",
+                    &support::DebugSyntaxResult(self.l_double_curly_token()),
+                )
+                .field("expression", &support::DebugSyntaxResult(self.expression()))
+                .field(
+                    "r_double_curly_token",
+                    &support::DebugSyntaxResult(self.r_double_curly_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("HtmlDoubleTextExpression").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<HtmlDoubleTextExpression> for SyntaxNode {
+    fn from(n: HtmlDoubleTextExpression) -> Self {
+        n.syntax
+    }
+}
+impl From<HtmlDoubleTextExpression> for SyntaxElement {
+    fn from(n: HtmlDoubleTextExpression) -> Self {
+        n.syntax.into()
+    }
+}
 impl AstNode for HtmlElement {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
@@ -1540,12 +1663,12 @@ impl From<HtmlSelfClosingElement> for SyntaxElement {
         n.syntax.into()
     }
 }
-impl AstNode for HtmlString {
+impl AstNode for HtmlSingleTextExpression {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_STRING as u16));
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_SINGLE_TEXT_EXPRESSION as u16));
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == HTML_STRING
+        kind == HTML_SINGLE_TEXT_EXPRESSION
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
@@ -1561,41 +1684,46 @@ impl AstNode for HtmlString {
         self.syntax
     }
 }
-impl std::fmt::Debug for HtmlString {
+impl std::fmt::Debug for HtmlSingleTextExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
         let current_depth = DEPTH.get();
         let result = if current_depth < 16 {
             DEPTH.set(current_depth + 1);
-            f.debug_struct("HtmlString")
+            f.debug_struct("HtmlSingleTextExpression")
                 .field(
-                    "value_token",
-                    &support::DebugSyntaxResult(self.value_token()),
+                    "l_curly_token",
+                    &support::DebugSyntaxResult(self.l_curly_token()),
+                )
+                .field("expression", &support::DebugSyntaxResult(self.expression()))
+                .field(
+                    "r_curly_token",
+                    &support::DebugSyntaxResult(self.r_curly_token()),
                 )
                 .finish()
         } else {
-            f.debug_struct("HtmlString").finish()
+            f.debug_struct("HtmlSingleTextExpression").finish()
         };
         DEPTH.set(current_depth);
         result
     }
 }
-impl From<HtmlString> for SyntaxNode {
-    fn from(n: HtmlString) -> Self {
+impl From<HtmlSingleTextExpression> for SyntaxNode {
+    fn from(n: HtmlSingleTextExpression) -> Self {
         n.syntax
     }
 }
-impl From<HtmlString> for SyntaxElement {
-    fn from(n: HtmlString) -> Self {
+impl From<HtmlSingleTextExpression> for SyntaxElement {
+    fn from(n: HtmlSingleTextExpression) -> Self {
         n.syntax.into()
     }
 }
-impl AstNode for HtmlTagName {
+impl AstNode for HtmlString {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_TAG_NAME as u16));
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_STRING as u16));
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == HTML_TAG_NAME
+        kind == HTML_STRING
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
@@ -1611,41 +1739,41 @@ impl AstNode for HtmlTagName {
         self.syntax
     }
 }
-impl std::fmt::Debug for HtmlTagName {
+impl std::fmt::Debug for HtmlString {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
         let current_depth = DEPTH.get();
         let result = if current_depth < 16 {
             DEPTH.set(current_depth + 1);
-            f.debug_struct("HtmlTagName")
+            f.debug_struct("HtmlString")
                 .field(
                     "value_token",
                     &support::DebugSyntaxResult(self.value_token()),
                 )
                 .finish()
         } else {
-            f.debug_struct("HtmlTagName").finish()
+            f.debug_struct("HtmlString").finish()
         };
         DEPTH.set(current_depth);
         result
     }
 }
-impl From<HtmlTagName> for SyntaxNode {
-    fn from(n: HtmlTagName) -> Self {
+impl From<HtmlString> for SyntaxNode {
+    fn from(n: HtmlString) -> Self {
         n.syntax
     }
 }
-impl From<HtmlTagName> for SyntaxElement {
-    fn from(n: HtmlTagName) -> Self {
+impl From<HtmlString> for SyntaxElement {
+    fn from(n: HtmlString) -> Self {
         n.syntax.into()
     }
 }
-impl AstNode for HtmlTextExpression {
+impl AstNode for HtmlTagName {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_TEXT_EXPRESSION as u16));
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_TAG_NAME as u16));
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == HTML_TEXT_EXPRESSION
+        kind == HTML_TAG_NAME
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
@@ -1661,49 +1789,41 @@ impl AstNode for HtmlTextExpression {
         self.syntax
     }
 }
-impl std::fmt::Debug for HtmlTextExpression {
+impl std::fmt::Debug for HtmlTagName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
         let current_depth = DEPTH.get();
         let result = if current_depth < 16 {
             DEPTH.set(current_depth + 1);
-            f.debug_struct("HtmlTextExpression")
-                .field(
-                    "l_double_curly_token",
-                    &support::DebugSyntaxResult(self.l_double_curly_token()),
-                )
-                .field(
-                    "expression_token",
-                    &support::DebugSyntaxResult(self.expression_token()),
-                )
+            f.debug_struct("HtmlTagName")
                 .field(
-                    "r_double_curly_token",
-                    &support::DebugSyntaxResult(self.r_double_curly_token()),
+                    "value_token",
+                    &support::DebugSyntaxResult(self.value_token()),
                 )
                 .finish()
         } else {
-            f.debug_struct("HtmlTextExpression").finish()
+            f.debug_struct("HtmlTagName").finish()
         };
         DEPTH.set(current_depth);
         result
     }
 }
-impl From<HtmlTextExpression> for SyntaxNode {
-    fn from(n: HtmlTextExpression) -> Self {
+impl From<HtmlTagName> for SyntaxNode {
+    fn from(n: HtmlTagName) -> Self {
         n.syntax
     }
 }
-impl From<HtmlTextExpression> for SyntaxElement {
-    fn from(n: HtmlTextExpression) -> Self {
+impl From<HtmlTagName> for SyntaxElement {
+    fn from(n: HtmlTagName) -> Self {
         n.syntax.into()
     }
 }
-impl AstNode for SvelteTextExpression {
+impl AstNode for HtmlTextExpression {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        SyntaxKindSet::from_raw(RawSyntaxKind(SVELTE_TEXT_EXPRESSION as u16));
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_TEXT_EXPRESSION as u16));
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == SVELTE_TEXT_EXPRESSION
+        kind == HTML_TEXT_EXPRESSION
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
@@ -1719,40 +1839,32 @@ impl AstNode for SvelteTextExpression {
         self.syntax
     }
 }
-impl std::fmt::Debug for SvelteTextExpression {
+impl std::fmt::Debug for HtmlTextExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
         let current_depth = DEPTH.get();
         let result = if current_depth < 16 {
             DEPTH.set(current_depth + 1);
-            f.debug_struct("SvelteTextExpression")
-                .field(
-                    "l_curly_token",
-                    &support::DebugSyntaxResult(self.l_curly_token()),
-                )
+            f.debug_struct("HtmlTextExpression")
                 .field(
-                    "expression_token",
-                    &support::DebugSyntaxResult(self.expression_token()),
-                )
-                .field(
-                    "r_curly_token",
-                    &support::DebugSyntaxResult(self.r_curly_token()),
+                    "html_literal_token",
+                    &support::DebugSyntaxResult(self.html_literal_token()),
                 )
                 .finish()
         } else {
-            f.debug_struct("SvelteTextExpression").finish()
+            f.debug_struct("HtmlTextExpression").finish()
         };
         DEPTH.set(current_depth);
         result
     }
 }
-impl From<SvelteTextExpression> for SyntaxNode {
-    fn from(n: SvelteTextExpression) -> Self {
+impl From<HtmlTextExpression> for SyntaxNode {
+    fn from(n: HtmlTextExpression) -> Self {
         n.syntax
     }
 }
-impl From<SvelteTextExpression> for SyntaxElement {
-    fn from(n: SvelteTextExpression) -> Self {
+impl From<HtmlTextExpression> for SyntaxElement {
+    fn from(n: HtmlTextExpression) -> Self {
         n.syntax.into()
     }
 }
@@ -1830,17 +1942,29 @@ impl From<HtmlBogusAttribute> for AnyHtmlAttribute {
         Self::HtmlBogusAttribute(node)
     }
 }
+impl From<HtmlDoubleTextExpression> for AnyHtmlAttribute {
+    fn from(node: HtmlDoubleTextExpression) -> Self {
+        Self::HtmlDoubleTextExpression(node)
+    }
+}
 impl AstNode for AnyHtmlAttribute {
     type Language = Language;
-    const KIND_SET: SyntaxKindSet<Language> =
-        HtmlAttribute::KIND_SET.union(HtmlBogusAttribute::KIND_SET);
+    const KIND_SET: SyntaxKindSet<Language> = HtmlAttribute::KIND_SET
+        .union(HtmlBogusAttribute::KIND_SET)
+        .union(HtmlDoubleTextExpression::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
-        matches!(kind, HTML_ATTRIBUTE | HTML_BOGUS_ATTRIBUTE)
+        matches!(
+            kind,
+            HTML_ATTRIBUTE | HTML_BOGUS_ATTRIBUTE | HTML_DOUBLE_TEXT_EXPRESSION
+        )
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
             HTML_ATTRIBUTE => Self::HtmlAttribute(HtmlAttribute { syntax }),
             HTML_BOGUS_ATTRIBUTE => Self::HtmlBogusAttribute(HtmlBogusAttribute { syntax }),
+            HTML_DOUBLE_TEXT_EXPRESSION => {
+                Self::HtmlDoubleTextExpression(HtmlDoubleTextExpression { syntax })
+            }
             _ => return None,
         };
         Some(res)
@@ -1849,12 +1973,14 @@ impl AstNode for AnyHtmlAttribute {
         match self {
             Self::HtmlAttribute(it) => &it.syntax,
             Self::HtmlBogusAttribute(it) => &it.syntax,
+            Self::HtmlDoubleTextExpression(it) => &it.syntax,
         }
     }
     fn into_syntax(self) -> SyntaxNode {
         match self {
             Self::HtmlAttribute(it) => it.syntax,
             Self::HtmlBogusAttribute(it) => it.syntax,
+            Self::HtmlDoubleTextExpression(it) => it.syntax,
         }
     }
 }
@@ -1863,6 +1989,7 @@ impl std::fmt::Debug for AnyHtmlAttribute {
         match self {
             Self::HtmlAttribute(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlBogusAttribute(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlDoubleTextExpression(it) => std::fmt::Debug::fmt(it, f),
         }
     }
 }
@@ -1871,6 +1998,7 @@ impl From<AnyHtmlAttribute> for SyntaxNode {
         match n {
             AnyHtmlAttribute::HtmlAttribute(it) => it.into(),
             AnyHtmlAttribute::HtmlBogusAttribute(it) => it.into(),
+            AnyHtmlAttribute::HtmlDoubleTextExpression(it) => it.into(),
         }
     }
 }
@@ -1880,6 +2008,68 @@ impl From<AnyHtmlAttribute> for SyntaxElement {
         node.into()
     }
 }
+impl From<HtmlSingleTextExpression> for AnyHtmlAttributeInitializer {
+    fn from(node: HtmlSingleTextExpression) -> Self {
+        Self::HtmlSingleTextExpression(node)
+    }
+}
+impl From<HtmlString> for AnyHtmlAttributeInitializer {
+    fn from(node: HtmlString) -> Self {
+        Self::HtmlString(node)
+    }
+}
+impl AstNode for AnyHtmlAttributeInitializer {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        HtmlSingleTextExpression::KIND_SET.union(HtmlString::KIND_SET);
+    fn can_cast(kind: SyntaxKind) -> bool {
+        matches!(kind, HTML_SINGLE_TEXT_EXPRESSION | HTML_STRING)
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            HTML_SINGLE_TEXT_EXPRESSION => {
+                Self::HtmlSingleTextExpression(HtmlSingleTextExpression { syntax })
+            }
+            HTML_STRING => Self::HtmlString(HtmlString { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Self::HtmlSingleTextExpression(it) => &it.syntax,
+            Self::HtmlString(it) => &it.syntax,
+        }
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        match self {
+            Self::HtmlSingleTextExpression(it) => it.syntax,
+            Self::HtmlString(it) => it.syntax,
+        }
+    }
+}
+impl std::fmt::Debug for AnyHtmlAttributeInitializer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::HtmlSingleTextExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlString(it) => std::fmt::Debug::fmt(it, f),
+        }
+    }
+}
+impl From<AnyHtmlAttributeInitializer> for SyntaxNode {
+    fn from(n: AnyHtmlAttributeInitializer) -> Self {
+        match n {
+            AnyHtmlAttributeInitializer::HtmlSingleTextExpression(it) => it.into(),
+            AnyHtmlAttributeInitializer::HtmlString(it) => it.into(),
+        }
+    }
+}
+impl From<AnyHtmlAttributeInitializer> for SyntaxElement {
+    fn from(n: AnyHtmlAttributeInitializer) -> Self {
+        let node: SyntaxNode = n.into();
+        node.into()
+    }
+}
 impl From<HtmlContent> for AnyHtmlContent {
     fn from(node: HtmlContent) -> Self {
         Self::HtmlContent(node)
@@ -2043,57 +2233,77 @@ impl From<AnyHtmlElement> for SyntaxElement {
         node.into()
     }
 }
-impl From<HtmlTextExpression> for AnyHtmlTextExpression {
-    fn from(node: HtmlTextExpression) -> Self {
-        Self::HtmlTextExpression(node)
+impl From<HtmlBogusTextExpression> for AnyHtmlTextExpression {
+    fn from(node: HtmlBogusTextExpression) -> Self {
+        Self::HtmlBogusTextExpression(node)
+    }
+}
+impl From<HtmlDoubleTextExpression> for AnyHtmlTextExpression {
+    fn from(node: HtmlDoubleTextExpression) -> Self {
+        Self::HtmlDoubleTextExpression(node)
     }
 }
-impl From<SvelteTextExpression> for AnyHtmlTextExpression {
-    fn from(node: SvelteTextExpression) -> Self {
-        Self::SvelteTextExpression(node)
+impl From<HtmlSingleTextExpression> for AnyHtmlTextExpression {
+    fn from(node: HtmlSingleTextExpression) -> Self {
+        Self::HtmlSingleTextExpression(node)
     }
 }
 impl AstNode for AnyHtmlTextExpression {
     type Language = Language;
-    const KIND_SET: SyntaxKindSet<Language> =
-        HtmlTextExpression::KIND_SET.union(SvelteTextExpression::KIND_SET);
+    const KIND_SET: SyntaxKindSet<Language> = HtmlBogusTextExpression::KIND_SET
+        .union(HtmlDoubleTextExpression::KIND_SET)
+        .union(HtmlSingleTextExpression::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
-        matches!(kind, HTML_TEXT_EXPRESSION | SVELTE_TEXT_EXPRESSION)
+        matches!(
+            kind,
+            HTML_BOGUS_TEXT_EXPRESSION | HTML_DOUBLE_TEXT_EXPRESSION | HTML_SINGLE_TEXT_EXPRESSION
+        )
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
-            HTML_TEXT_EXPRESSION => Self::HtmlTextExpression(HtmlTextExpression { syntax }),
-            SVELTE_TEXT_EXPRESSION => Self::SvelteTextExpression(SvelteTextExpression { syntax }),
+            HTML_BOGUS_TEXT_EXPRESSION => {
+                Self::HtmlBogusTextExpression(HtmlBogusTextExpression { syntax })
+            }
+            HTML_DOUBLE_TEXT_EXPRESSION => {
+                Self::HtmlDoubleTextExpression(HtmlDoubleTextExpression { syntax })
+            }
+            HTML_SINGLE_TEXT_EXPRESSION => {
+                Self::HtmlSingleTextExpression(HtmlSingleTextExpression { syntax })
+            }
             _ => return None,
         };
         Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
         match self {
-            Self::HtmlTextExpression(it) => &it.syntax,
-            Self::SvelteTextExpression(it) => &it.syntax,
+            Self::HtmlBogusTextExpression(it) => &it.syntax,
+            Self::HtmlDoubleTextExpression(it) => &it.syntax,
+            Self::HtmlSingleTextExpression(it) => &it.syntax,
         }
     }
     fn into_syntax(self) -> SyntaxNode {
         match self {
-            Self::HtmlTextExpression(it) => it.syntax,
-            Self::SvelteTextExpression(it) => it.syntax,
+            Self::HtmlBogusTextExpression(it) => it.syntax,
+            Self::HtmlDoubleTextExpression(it) => it.syntax,
+            Self::HtmlSingleTextExpression(it) => it.syntax,
         }
     }
 }
 impl std::fmt::Debug for AnyHtmlTextExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::HtmlTextExpression(it) => std::fmt::Debug::fmt(it, f),
-            Self::SvelteTextExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlBogusTextExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlDoubleTextExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlSingleTextExpression(it) => std::fmt::Debug::fmt(it, f),
         }
     }
 }
 impl From<AnyHtmlTextExpression> for SyntaxNode {
     fn from(n: AnyHtmlTextExpression) -> Self {
         match n {
-            AnyHtmlTextExpression::HtmlTextExpression(it) => it.into(),
-            AnyHtmlTextExpression::SvelteTextExpression(it) => it.into(),
+            AnyHtmlTextExpression::HtmlBogusTextExpression(it) => it.into(),
+            AnyHtmlTextExpression::HtmlDoubleTextExpression(it) => it.into(),
+            AnyHtmlTextExpression::HtmlSingleTextExpression(it) => it.into(),
         }
     }
 }
@@ -2113,6 +2323,11 @@ impl std::fmt::Display for AnyHtmlAttribute {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for AnyHtmlAttributeInitializer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for AnyHtmlContent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
@@ -2168,6 +2383,11 @@ impl std::fmt::Display for HtmlDirective {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for HtmlDoubleTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for HtmlElement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
@@ -2188,22 +2408,22 @@ impl std::fmt::Display for HtmlSelfClosingElement {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for HtmlString {
+impl std::fmt::Display for HtmlSingleTextExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for HtmlTagName {
+impl std::fmt::Display for HtmlString {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for HtmlTextExpression {
+impl std::fmt::Display for HtmlTagName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for SvelteTextExpression {
+impl std::fmt::Display for HtmlTextExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
@@ -2432,7 +2652,63 @@ impl From<HtmlBogusElement> for SyntaxElement {
         n.syntax.into()
     }
 }
-biome_rowan::declare_node_union! { pub AnyHtmlBogusNode = AstroBogusFrontmatter | HtmlBogus | HtmlBogusAttribute | HtmlBogusElement }
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub struct HtmlBogusTextExpression {
+    syntax: SyntaxNode,
+}
+impl HtmlBogusTextExpression {
+    #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
+    #[doc = r""]
+    #[doc = r" # Safety"]
+    #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"]
+    #[doc = r" or a match on [SyntaxNode::kind]"]
+    #[inline]
+    pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self { syntax }
+    }
+    pub fn items(&self) -> SyntaxElementChildren {
+        support::elements(&self.syntax)
+    }
+}
+impl AstNode for HtmlBogusTextExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_BOGUS_TEXT_EXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == HTML_BOGUS_TEXT_EXPRESSION
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
+    }
+}
+impl std::fmt::Debug for HtmlBogusTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HtmlBogusTextExpression")
+            .field("items", &DebugSyntaxElementChildren(self.items()))
+            .finish()
+    }
+}
+impl From<HtmlBogusTextExpression> for SyntaxNode {
+    fn from(n: HtmlBogusTextExpression) -> Self {
+        n.syntax
+    }
+}
+impl From<HtmlBogusTextExpression> for SyntaxElement {
+    fn from(n: HtmlBogusTextExpression) -> Self {
+        n.syntax.into()
+    }
+}
+biome_rowan::declare_node_union! { pub AnyHtmlBogusNode = AstroBogusFrontmatter | HtmlBogus | HtmlBogusAttribute | HtmlBogusElement | HtmlBogusTextExpression }
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub struct HtmlAttributeList {
     syntax_list: SyntaxList,
diff --git a/crates/biome_html_syntax/src/generated/nodes_mut.rs b/crates/biome_html_syntax/src/generated/nodes_mut.rs
index 9aa643368c91..3a0ef8e5326b 100644
--- a/crates/biome_html_syntax/src/generated/nodes_mut.rs
+++ b/crates/biome_html_syntax/src/generated/nodes_mut.rs
@@ -44,7 +44,7 @@ impl HtmlAttributeInitializerClause {
                 .splice_slots(0usize..=0usize, once(Some(element.into()))),
         )
     }
-    pub fn with_value(self, element: HtmlString) -> Self {
+    pub fn with_value(self, element: AnyHtmlAttributeInitializer) -> Self {
         Self::unwrap_cast(
             self.syntax
                 .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
@@ -163,6 +163,26 @@ impl HtmlDirective {
         )
     }
 }
+impl HtmlDoubleTextExpression {
+    pub fn with_l_double_curly_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_expression(self, element: HtmlTextExpression) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_double_curly_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into()))),
+        )
+    }
+}
 impl HtmlElement {
     pub fn with_opening_element(self, element: HtmlOpeningElement) -> Self {
         Self::unwrap_cast(
@@ -273,59 +293,47 @@ impl HtmlSelfClosingElement {
         )
     }
 }
-impl HtmlString {
-    pub fn with_value_token(self, element: SyntaxToken) -> Self {
-        Self::unwrap_cast(
-            self.syntax
-                .splice_slots(0usize..=0usize, once(Some(element.into()))),
-        )
-    }
-}
-impl HtmlTagName {
-    pub fn with_value_token(self, element: SyntaxToken) -> Self {
-        Self::unwrap_cast(
-            self.syntax
-                .splice_slots(0usize..=0usize, once(Some(element.into()))),
-        )
-    }
-}
-impl HtmlTextExpression {
-    pub fn with_l_double_curly_token(self, element: SyntaxToken) -> Self {
+impl HtmlSingleTextExpression {
+    pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
             self.syntax
                 .splice_slots(0usize..=0usize, once(Some(element.into()))),
         )
     }
-    pub fn with_expression_token(self, element: SyntaxToken) -> Self {
+    pub fn with_expression(self, element: HtmlTextExpression) -> Self {
         Self::unwrap_cast(
             self.syntax
-                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
         )
     }
-    pub fn with_r_double_curly_token(self, element: SyntaxToken) -> Self {
+    pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
             self.syntax
                 .splice_slots(2usize..=2usize, once(Some(element.into()))),
         )
     }
 }
-impl SvelteTextExpression {
-    pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
+impl HtmlString {
+    pub fn with_value_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
             self.syntax
                 .splice_slots(0usize..=0usize, once(Some(element.into()))),
         )
     }
-    pub fn with_expression_token(self, element: SyntaxToken) -> Self {
+}
+impl HtmlTagName {
+    pub fn with_value_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
             self.syntax
-                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
         )
     }
-    pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
+}
+impl HtmlTextExpression {
+    pub fn with_html_literal_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
             self.syntax
-                .splice_slots(2usize..=2usize, once(Some(element.into()))),
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
         )
     }
 }
diff --git a/crates/biome_html_syntax/src/lib.rs b/crates/biome_html_syntax/src/lib.rs
index 3061eaae149e..f659581049fe 100644
--- a/crates/biome_html_syntax/src/lib.rs
+++ b/crates/biome_html_syntax/src/lib.rs
@@ -8,12 +8,12 @@ mod syntax_node;
 
 pub use self::generated::*;
 pub use biome_rowan::{TextLen, TextRange, TextSize, TokenAtOffset, TriviaPieceKind, WalkEvent};
-pub use file_source::{HtmlFileSource, HtmlVariant};
+pub use file_source::{HtmlFileSource, HtmlTextExpressions, HtmlVariant};
 pub use syntax_node::*;
 
 use crate::HtmlSyntaxKind::{
     ASTRO_BOGUS_FRONTMATTER, HTML_BOGUS, HTML_BOGUS_ATTRIBUTE, HTML_BOGUS_ELEMENT,
-    HTML_CLOSING_ELEMENT,
+    HTML_BOGUS_TEXT_EXPRESSION, HTML_CLOSING_ELEMENT,
 };
 use biome_rowan::{AstNode, RawSyntaxKind, SyntaxKind, TokenText};
 
@@ -57,6 +57,7 @@ impl biome_rowan::SyntaxKind for HtmlSyntaxKind {
             kind if AnyHtmlAttribute::can_cast(*kind) => HTML_BOGUS_ATTRIBUTE,
             kind if AnyHtmlElement::can_cast(*kind) => HTML_BOGUS_ELEMENT,
             kind if AnyAstroFrontmatterElement::can_cast(*kind) => ASTRO_BOGUS_FRONTMATTER,
+            kind if AnyHtmlTextExpression::can_cast(*kind) => HTML_BOGUS_TEXT_EXPRESSION,
             HTML_CLOSING_ELEMENT => HTML_BOGUS_ELEMENT,
 
             _ => HTML_BOGUS,
diff --git a/crates/biome_parser/src/lib.rs b/crates/biome_parser/src/lib.rs
index aa743227e1dd..d1647011e8ce 100644
--- a/crates/biome_parser/src/lib.rs
+++ b/crates/biome_parser/src/lib.rs
@@ -271,7 +271,7 @@ pub trait Parser: Sized {
         self.bump_any()
     }
 
-    /// Consume any token but cast it as a different kind using the specified `context`.
+    /// Consume the token but cast it as a different kind using the specified `context`.
     fn bump_remap_with_context(
         &mut self,
         kind: Self::Kind,
@@ -282,6 +282,15 @@ pub trait Parser: Sized {
         self.do_bump_with_context(kind, context);
     }
 
+    fn bump_remap_any_with_context(&mut self, context: <Self::Source as BumpWithContext>::Context)
+    where
+        Self::Source: BumpWithContext,
+    {
+        let kind = self.cur();
+        assert_ne!(kind, Self::Kind::EOF);
+        self.do_bump_with_context(kind, context);
+    }
+
     /// Consume any token but cast it as a different kind
     fn bump_remap(&mut self, kind: Self::Kind) {
         self.do_bump(kind);
diff --git a/crates/biome_service/src/file_handlers/html.rs b/crates/biome_service/src/file_handlers/html.rs
index d5a3be4d8e2a..f449c1be894e 100644
--- a/crates/biome_service/src/file_handlers/html.rs
+++ b/crates/biome_service/src/file_handlers/html.rs
@@ -12,7 +12,10 @@ use crate::{
     workspace::GetSyntaxTreeResult,
 };
 use biome_analyze::AnalyzerOptions;
-use biome_configuration::html::{HtmlFormatterConfiguration, HtmlFormatterEnabled};
+use biome_configuration::html::{
+    HtmlFormatterConfiguration, HtmlFormatterEnabled, HtmlParseInterpolation,
+    HtmlParserConfiguration,
+};
 use biome_css_parser::{CssParserOptions, parse_css_with_offset_and_cache};
 use biome_diagnostics::{Diagnostic, Severity};
 use biome_formatter::{
@@ -25,7 +28,7 @@ use biome_html_formatter::{
     context::{IndentScriptAndStyle, WhitespaceSensitivity},
     format_node,
 };
-use biome_html_parser::parse_html_with_cache;
+use biome_html_parser::{HtmlParseOptions, parse_html_with_cache};
 use biome_html_syntax::{HtmlElement, HtmlLanguage, HtmlRoot, HtmlSyntaxNode};
 use biome_js_parser::{JsParserOptions, parse_js_with_offset_and_cache};
 use biome_js_syntax::JsFileSource;
@@ -34,6 +37,20 @@ use biome_rowan::{AstNode, AstNodeList, NodeCache};
 use camino::Utf8Path;
 use tracing::debug_span;
 
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub struct HtmlParserSettings {
+    pub interpolation: Option<HtmlParseInterpolation>,
+}
+
+impl From<HtmlParserConfiguration> for HtmlParserSettings {
+    fn from(configuration: HtmlParserConfiguration) -> Self {
+        Self {
+            interpolation: configuration.interpolation,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct HtmlFormatterSettings {
@@ -70,7 +87,7 @@ impl ServiceLanguage for HtmlLanguage {
     type FormatterSettings = HtmlFormatterSettings;
     type LinterSettings = ();
     type FormatOptions = HtmlFormatOptions;
-    type ParserSettings = ();
+    type ParserSettings = HtmlParserSettings;
     type EnvironmentSettings = ();
     type AssistSettings = ();
 
@@ -242,11 +259,23 @@ fn parse(
     _biome_path: &BiomePath,
     file_source: DocumentFileSource,
     text: &str,
-    _settings: &Settings,
+    settings: &Settings,
     cache: &mut NodeCache,
 ) -> ParseResult {
     let html_file_source = file_source.to_html_file_source().unwrap_or_default();
-    let parse = parse_html_with_cache(text, html_file_source, cache);
+    let mut options = HtmlParseOptions::from(&html_file_source);
+    if settings
+        .languages
+        .html
+        .parser
+        .interpolation
+        .unwrap_or_default()
+        .into()
+        && html_file_source.is_html()
+    {
+        options = options.with_double_text_expression();
+    }
+    let parse = parse_html_with_cache(text, cache, options);
 
     ParseResult {
         any_parse: parse.into(),
diff --git a/crates/biome_service/src/settings.rs b/crates/biome_service/src/settings.rs
index 82ca48d909bd..3d4291704158 100644
--- a/crates/biome_service/src/settings.rs
+++ b/crates/biome_service/src/settings.rs
@@ -600,6 +600,10 @@ impl From<HtmlConfiguration> for LanguageSettings<HtmlLanguage> {
             language_setting.formatter = formatter.into();
         }
 
+        if let Some(parser) = html.parser {
+            language_setting.parser = parser.into();
+        }
+
         // NOTE: uncomment once ready
         // if let Some(linter) = html.linter {
         //     language_setting.linter = linter.into();
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index 4f7eb411c8d3..4f1a5b38a2b7 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -588,7 +588,12 @@ export interface HtmlFormatterConfiguration {
 /**
  * Options that changes how the HTML parser behaves
  */
-export type HtmlParserConfiguration = null;
+export interface HtmlParserConfiguration {
+	/**
+	 * Enables the parsing of double text expressions such as `{{ expression }}` inside `.html` files
+	 */
+	interpolation?: Bool;
+}
 /**
  * Assist options specific to the JavaScript assist
  */
@@ -9000,8 +9005,13 @@ export type CssVariant = "standard";
  * The style of GraphQL contained in the file.
  */
 export type GraphqlVariant = "standard";
-export type HtmlVariant = "Standard" | "Astro" | "Vue" | "Svelte";
+export type HtmlVariant =
+	| { Standard: HtmlTextExpressions }
+	| "Astro"
+	| "Vue"
+	| "Svelte";
 export type GritVariant = "Standard";
+export type HtmlTextExpressions = "None" | "Single" | "Double";
 export interface ChangeFileParams {
 	content: string;
 	path: BiomePath;
diff --git a/packages/@biomejs/biome/configuration_schema.json b/packages/@biomejs/biome/configuration_schema.json
index 9b3f49342607..7ec0abadadc0 100644
--- a/packages/@biomejs/biome/configuration_schema.json
+++ b/packages/@biomejs/biome/configuration_schema.json
@@ -1838,7 +1838,14 @@
 		},
 		"HtmlParserConfiguration": {
 			"description": "Options that changes how the HTML parser behaves",
-			"type": "null"
+			"type": "object",
+			"properties": {
+				"interpolation": {
+					"description": "Enables the parsing of double text expressions such as `{{ expression }}` inside `.html` files",
+					"anyOf": [{ "$ref": "#/definitions/Bool" }, { "type": "null" }]
+				}
+			},
+			"additionalProperties": false
 		},
 		"ImportGroup": {
 			"anyOf": [
diff --git a/xtask/codegen/html.ungram b/xtask/codegen/html.ungram
index b39b5661a813..92113baabfb1 100644
--- a/xtask/codegen/html.ungram
+++ b/xtask/codegen/html.ungram
@@ -40,6 +40,7 @@ HtmlBogus = SyntaxElement*
 HtmlBogusElement = SyntaxElement*
 HtmlBogusAttribute = SyntaxElement*
 AstroBogusFrontmatter = SyntaxElement*
+HtmlBogusTextExpression = SyntaxElement*
 
 HtmlRoot =
 	bom: 'UNICODE_BOM'?
@@ -78,24 +79,28 @@ AnyHtmlContent =
 	| AnyHtmlTextExpression
 
 AnyHtmlTextExpression =
-	HtmlTextExpression
-	| SvelteTextExpression
+	HtmlDoubleTextExpression
+	| HtmlSingleTextExpression
+	| HtmlBogusTextExpression
 
 
 // {{ expression }}
 // ^^^^^^^^^^^^^^^^
-HtmlTextExpression =
+HtmlDoubleTextExpression =
 	'{{'
-	expression: 'html_literal'
+	expression: HtmlTextExpression
 	'}}'
 
 // {expression}
 // ^^^^^^^^^^^^
-SvelteTextExpression =
+HtmlSingleTextExpression =
 	'{'
-	expression: 'html_literal'
+	expression: HtmlTextExpression
 	'}'
 
+HtmlTextExpression = 'html_literal'
+
+
 // <a />
 HtmlSelfClosingElement =
 	'<'
@@ -149,8 +154,11 @@ HtmlAttributeList = AnyHtmlAttribute*
 
 AnyHtmlAttribute =
 	HtmlAttribute
+	| HtmlDoubleTextExpression
 	| HtmlBogusAttribute
 
+// <a href="">
+//    ^^^^^^^
 HtmlAttribute =
 	name: HtmlAttributeName
 	initializer: HtmlAttributeInitializerClause?
@@ -160,7 +168,13 @@ HtmlAttribute =
 //        ^^^
 HtmlAttributeInitializerClause =
 	'='
-	value: HtmlString
+	value: AnyHtmlAttributeInitializer
+
+
+AnyHtmlAttributeInitializer =
+	HtmlString
+	| HtmlSingleTextExpression
+
 
 
 HtmlString = value: 'html_string_literal'
diff --git a/xtask/codegen/src/html_kinds_src.rs b/xtask/codegen/src/html_kinds_src.rs
index 8c5e89bce0b7..b88e0465ea4b 100644
--- a/xtask/codegen/src/html_kinds_src.rs
+++ b/xtask/codegen/src/html_kinds_src.rs
@@ -44,12 +44,14 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         "HTML_CONTENT",
         "HTML_CDATA_SECTION",
         "COMMENT",
+        "HTML_DOUBLE_TEXT_EXPRESSION",
+        "HTML_SINGLE_TEXT_EXPRESSION",
         "HTML_TEXT_EXPRESSION",
-        "SVELTE_TEXT_EXPRESSION",
         // Bogus nodes
         "HTML_BOGUS",
         "HTML_BOGUS_ELEMENT",
         "HTML_BOGUS_ATTRIBUTE",
+        "HTML_BOGUS_TEXT_EXPRESSION",
         "ASTRO_BOGUS_FRONTMATTER",
     ],
 };